diff --git a/Ix/IxVM/Kernel/Check.lean b/Ix/IxVM/Kernel/Check.lean index 51723f33..2f707c05 100644 --- a/Ix/IxVM/Kernel/Check.lean +++ b/Ix/IxVM/Kernel/Check.lean @@ -2339,6 +2339,22 @@ def check := ⟦ univ_offset, flat, flat_own_params, self_pos); assert_eq!(k_is_def_eq(ty, canonical_ty, store(ListNode.Nil)), 1, "recursor's declared type is not def-eq to the canonical reconstruction"); + -- The type check pins the SUM of the motive and minor binders, but + -- not the SPLIT between them: a def-eq between two Pi telescopes + -- cannot tell where the motives end and the minors begin. Yet + -- `minor_var` (`populate_rules`) reads the declared `n_min` ALONE + -- to pick which binder each canonical rule body points at, so a + -- prover who moves mass between the two fields (sum preserved) + -- retargets every rule while the type stays honest. Pin both + -- against the reconstruction, as the reference does (`inductive.rs` + -- check_recursor "arity metadata mismatch"). + let canon_n_motives = list_length(flat); + let canon_n_minors = list_length(build_all_minors(flat, + flat_own_params, n_p, canon_n_motives, n_p)); + assert_eq!(n_mot, canon_n_motives, + "recursor motive count disagrees with the canonical reconstruction"); + assert_eq!(n_min, canon_n_minors, + "recursor minor count disagrees with the canonical reconstruction"); let self_ctors_offset = ctors_before_pos(flat, self_pos, 0); let canonical = populate_rules(num_ctors, self_ctors_offset, parent_block_addr, parent_ind_idx, n_p, n_mot, n_min, occ_us, diff --git a/Ix/IxVM/Kernel/DefEq.lean b/Ix/IxVM/Kernel/DefEq.lean index 01b927c5..8b8f54f6 100644 --- a/Ix/IxVM/Kernel/DefEq.lean +++ b/Ix/IxVM/Kernel/DefEq.lean @@ -877,35 +877,28 @@ def defEq := ⟦ } } - -- 1 iff `whnf(infer_only(ty))` is `Sort 0`. + -- 1 iff `whnf(infer_only(ty))` is a `Sort` whose level is SEMANTICALLY + -- zero (i.e. `Prop`). -- - -- STRUCTURAL on purpose — do not swap this for `level_equal`. All three - -- references gate struct-eta and proof irrelevance on the level being - -- literally `Zero`: Rust `KUniv::is_zero` (`level.rs:112-114`, a - -- `matches!` on `UnivData::Zero`), `Ix/Tc` `KUniv.isZero` - -- (`Level.lean:64-66`), and lean4lean's `isProp` - -- (`TypeChecker.lean:192-193`), which compares against `.prop` with - -- structural `==`. + -- SEMANTIC on purpose — `level_equal`, matching `is_inductive_prop` + -- (`Infer.lean:260`) and all three references: Rust gates both struct- + -- eta (`whnf.rs:1884`) and proof irrelevance (`def_eq.rs:878`) on + -- `KUniv::is_semantic_zero`, `Ix/Tc` on `isSemanticZero` + -- (`Whnf.lean:1139`, `DefEq.lean:817`), and lean4lean's `isProp` on + -- `Level.isAlwaysZero` (`TypeChecker.lean:230`), all of which normalize. -- - -- It is sound because levels are built by SIMPLIFYING constructors — - -- `level_imax` collapses `imax u 0` to `Zero` at construction, as - -- Rust's `KUniv::imax` and lean4lean's `mkLevelIMax'` do — and because - -- the test runs after `whnf`. So a Prop cannot reach here spelled any - -- other way. - -- - -- Note this is NOT the rule everywhere: the projection-field Prop test - -- normalizes in Rust (`univ_eq`, `infer.rs:516`) and in `Ix/Tc` - -- (`Infer.lean:315`), which is why `is_inductive_prop` uses - -- `level_equal`. Those two tests are deliberately different. + -- A structural `KLevelNode.Zero` test is UNSOUND here: `convert_univ` + -- (`Convert.lean:87`) is a raw conversion, so a prover can author + -- `Sort (max 0 0)` / `Sort (imax 1 0)` — semantically zero, structurally + -- not — and `whnf` is the identity on `Srt`. Reading such a Prop as + -- "not Prop" fires `try_struct_eta_iota` on a proof, the reduction + -- lean4#14613 fixed (see `Tests/Ix/IxVM/Exploits.lean` + -- `struct-eta-fires-on-semantic-prop`). fn is_prop_type(ty: KExpr, types: List‹KExpr›) -> G { let sort = k_infer_only(ty, types); let sort_w = whnf(sort, types); match load(sort_w) { - KExprNode.Srt(l) => - match load(l) { - KLevelNode.Zero => 1, - _ => 0, - }, + KExprNode.Srt(l) => level_equal(l, store(KLevelNode.Zero)), _ => 0, } } diff --git a/Ix/IxVM/Kernel/NatPrim.lean b/Ix/IxVM/Kernel/NatPrim.lean index 39da6c18..100b9419 100644 --- a/Ix/IxVM/Kernel/NatPrim.lean +++ b/Ix/IxVM/Kernel/NatPrim.lean @@ -229,26 +229,6 @@ def natPrim := ⟦ 0x11u8, 0x9bu8, 0xcau8, 0x51u8, 0xd7u8, 0xb0u8, 0xbdu8, 0xd5u8]) } - fn size_of_size_of_addr() -> Addr { - store([0xa3u8, 0x43u8, 0xa6u8, 0x51u8, 0xbfu8, 0xf4u8, 0x08u8, 0xc3u8, - 0xa2u8, 0x9fu8, 0xf2u8, 0x7bu8, 0x2bu8, 0x62u8, 0xe3u8, 0x4bu8, - 0x54u8, 0xb2u8, 0xabu8, 0x38u8, 0x1cu8, 0xf6u8, 0xf3u8, 0xadu8, - 0x87u8, 0xc5u8, 0x40u8, 0xc9u8, 0x77u8, 0xdcu8, 0x3cu8, 0x4au8]) - } - - fn punit_addr() -> Addr { - store([0x2du8, 0xfcu8, 0x16u8, 0xafu8, 0x01u8, 0xb8u8, 0x2bu8, 0x3bu8, - 0x91u8, 0xc2u8, 0xffu8, 0x70u8, 0x44u8, 0x09u8, 0xd7u8, 0x62u8, - 0x36u8, 0xa8u8, 0x3fu8, 0x95u8, 0x6cu8, 0x0cu8, 0x6eu8, 0x66u8, - 0x59u8, 0xa6u8, 0x4fu8, 0xe2u8, 0x1du8, 0x76u8, 0x69u8, 0x5bu8]) - } - - fn unit_addr() -> Addr { - store([0x92u8, 0x32u8, 0x49u8, 0x86u8, 0x67u8, 0xf7u8, 0x65u8, 0xf4u8, - 0x37u8, 0xdeu8, 0xdau8, 0xacu8, 0x82u8, 0x8eu8, 0x55u8, 0x5fu8, - 0x6cu8, 0xc6u8, 0x7au8, 0x20u8, 0xe6u8, 0xdbu8, 0x28u8, 0xf6u8, - 0x14u8, 0xfdu8, 0xf3u8, 0xc2u8, 0x62u8, 0x71u8, 0x0fu8, 0xebu8]) - } fn is_native_prim_addr(a: Addr) -> G { match address_eq(a, system_platform_num_bits_addr()) { @@ -265,11 +245,7 @@ def natPrim := ⟦ _ => match address_eq(a, subtype_val_addr()) { 1 => 1, - _ => - match address_eq(a, size_of_size_of_addr()) { - 1 => 1, - _ => 0, - }, + _ => 0, }, }, }, @@ -305,9 +281,6 @@ def natPrim := ⟦ match address_eq(head_addr, subtype_val_addr()) { 1 => try_reduce_subtype_val(spine), _ => - match address_eq(head_addr, size_of_size_of_addr()) { - 1 => try_reduce_size_of_unit(spine), - _ => let is_rb = address_eq(head_addr, reduce_bool_addr()); let is_rn = address_eq(head_addr, reduce_nat_addr()); match is_rb + is_rn { @@ -324,7 +297,6 @@ def natPrim := ⟦ }, }, }, - }, }, }, } @@ -350,29 +322,6 @@ def natPrim := ⟦ } } - -- SizeOf.sizeOf.{u} Unit/PUnit ... → 1. First arg = type. - fn try_reduce_size_of_unit(spine: List‹KExpr›) -> (G, KExpr) { - match u32_less_than(list_length(spine), 1) { - 1 => (0, store(KExprNode.BVar(0))), - _ => - match collect_spine(list_lookup(spine, 0)) { - (head, _) => - match load(head) { - KExprNode.Const(caddr, _) => - match address_eq(caddr, unit_addr()) { - 1 => (1, mk_nat_one()), - _ => - match address_eq(caddr, punit_addr()) { - 1 => (1, mk_nat_one()), - _ => (0, store(KExprNode.BVar(0))), - }, - }, - _ => (0, store(KExprNode.BVar(0))), - }, - }, - } - } - fn check_native_bool(e: KExpr) -> (G, KExpr) { match load(e) { KExprNode.Const(caddr, _) => @@ -800,17 +749,12 @@ def natPrim := ⟦ KExprNode.Lit(lit) => match lit { KLiteral.Str(bs) => - -- The length must be a CANONICAL `KLimbs`, because - -- `klimbs_eq` — behind `Nat.beq`/`Nat.decEq`/ - -- `literal_eq` — compares limbs without normalizing. - -- `klimbs_from_g` range-checks and pins its byte - -- decomposition (so a length >= 256 lands in the right - -- limb instead of an out-of-range digit), and - -- `klimbs_normalize` strips the all-zero limb so the - -- empty string yields the canonical zero rather than - -- `[[0;8]]`. - let limbs = - klimbs_normalize(klimbs_from_g(list_length(bs))); + -- `klimbs_from_g` range-checks its byte decomposition + -- (so a length >= 256 lands in the right limb) and + -- returns a canonical `KLimbs` — required because + -- `klimbs_eq` (behind `Nat.beq`/`Nat.decEq`/ + -- `literal_eq`) compares limbs without normalizing. + let limbs = klimbs_from_g(list_length(bs)); (1, store(KExprNode.Lit(KLiteral.Nat(limbs)))), _ => (0, store(KExprNode.BVar(0))), }, @@ -1153,8 +1097,14 @@ def natPrim := ⟦ assert_eq!(x, to_field(b0) + 256 * to_field(b1) + 65536 * to_field(b2) + 16777216 * to_field(b3), "u32 byte split does not recompose to the original value"); - store(ListNode.Cons([b0, b1, b2, b3, 0u8, 0u8, 0u8, 0u8], - store(ListNode.Nil))), + -- Normalize HERE, not at each caller: `x == 0` gives the all-zero + -- limb, which is the denormalized `[[0;8]]`. `klimbs_eq` (behind + -- `Nat.beq`/`decEq`) compares limbs without normalizing, so an + -- unnormalized zero disagrees with the canonical empty list and + -- makes a reducer's literal wrong. Callers used to normalize + -- individually and one (`String.back`) was missed. + klimbs_normalize(store(ListNode.Cons( + [b0, b1, b2, b3, 0u8, 0u8, 0u8, 0u8], store(ListNode.Nil)))), } } diff --git a/Tests/Ix/IxVM.lean b/Tests/Ix/IxVM.lean index 6a0b7867..4a37c94e 100644 --- a/Tests/Ix/IxVM.lean +++ b/Tests/Ix/IxVM.lean @@ -95,6 +95,15 @@ public theorem str_size_lit : "hello".utf8ByteSize = 5 := rfl -- BitVec primitives (try_bitvec_dispatch) public theorem bv_to_nat_lit : (BitVec.ofNat 16 1234).toNat = 1234 := rfl +-- `SizeOf.sizeOf Unit` is no longer natively folded to 1: it must reduce +-- honestly, delta-unfolding the CANONICAL `SizeOf Unit` instance (a +-- `Const`, not a literal `SizeOf.mk`) to expose its field, projecting it +-- and applying `()`. A prover-chosen instance would give a different +-- value — that's the hole the fold left open. This pins that the honest +-- reduction still fires: if the projection path regresses, the constant +-- goes stuck and this check fails. +public theorem sizeof_unit : sizeOf () = 1 := rfl + end IxVMPrim /-! ## Inductive shape fixtures -/ @@ -344,83 +353,84 @@ private def nameOfString (str : String) : Lean.Name := and an improvement has to be acknowledged by re-pinning. -/ private def kernelCheckEntries : List (String × Nat) := [ ("HEq", 129_401_040), - ("HEq.rec", 133_148_512), - ("Eq.rec", 132_535_244), - ("Nat", 129_438_584), - ("Nat.add", 166_225_532), - ("Nat.add_comm", 308_457_475), - ("Nat.decEq", 364_638_853), - ("Nat.decLe", 777_229_532), - ("Nat.sub_le_of_le_add", 1_896_516_418), - ("Nat.shiftRight_succ", 1_404_793_386), - ("Trans.mk", 135_383_805), - ("Array.append_assoc", 9_070_739_205), - ("Vector.append", 9_269_843_706), - ("IxVMPrim.nat_add_lit", 205_587_450), - ("IxVMPrim.nat_sub_lit", 220_246_949), - ("IxVMPrim.nat_mul_lit", 197_091_263), - ("IxVMPrim.nat_mul_big", 195_620_487), - ("IxVMPrim.nat_div_lit", 1_371_606_999), - ("IxVMPrim.nat_mod_lit", 1_397_464_597), - ("IxVMPrim.nat_succ_lit", 143_056_464), - ("IxVMPrim.nat_pred_lit", 162_882_946), - ("IxVMPrim.nat_gcd_lit", 2_157_471_570), - ("IxVMPrim.nat_land_lit", 3_557_993_290), - ("IxVMPrim.nat_lor_lit", 3_559_819_986), - ("IxVMPrim.nat_xor_lit", 3_578_368_535), - ("IxVMPrim.nat_shl_lit", 224_281_532), - ("IxVMPrim.nat_shr_lit", 1_385_626_324), - ("IxVMPrim.nat_pow_big", 385_807_614), - ("IxVMPrim.nat_beq_lit", 195_813_453), - ("IxVMPrim.nat_ble_lit", 190_326_816), - ("IxVMPrim.nat_cases_big", 163_037_161), - ("IxVMPrim.nat_dec_le", 794_753_434), - ("IxVMPrim.nat_dec_lt", 805_826_434), - ("IxVMPrim.nat_dec_eq", 402_422_679), - ("IxVMPrim.str_size_lit", 2_468_609_203), - ("IxVMPrim.bv_to_nat_lit", 2_058_943_633), - ("IxVMInd.Even", 198_963_024), - ("IxVMInd.Odd", 198_965_621), - ("IxVMInd.Even.rec", 215_995_195), - ("IxVMInd.Odd.rec", 215_994_271), - ("IxVMInd.IdxTeleN.rec", 157_255_988), - ("IxVMInd.IdxTeleB.rec", 157_255_146), - ("IxVMInd.SoloA.rec", 152_850_190), - ("IxVMInd.SoloB.rec", 152_850_190), + ("HEq.rec", 133_148_547), + ("Eq.rec", 132_535_279), + ("Nat", 129_434_056), + ("Nat.add", 166_201_885), + ("Nat.add_comm", 308_402_453), + ("Nat.decEq", 364_556_339), + ("Nat.decLe", 777_061_206), + ("Nat.sub_le_of_le_add", 1_896_237_494), + ("Nat.shiftRight_succ", 1_404_500_485), + ("Trans.mk", 135_379_249), + ("Array.append_assoc", 9_069_712_075), + ("Vector.append", 9_268_784_695), + ("IxVMPrim.nat_add_lit", 205_554_370), + ("IxVMPrim.nat_sub_lit", 220_228_259), + ("IxVMPrim.nat_mul_lit", 197_048_801), + ("IxVMPrim.nat_mul_big", 195_577_122), + ("IxVMPrim.nat_div_lit", 1_371_395_799), + ("IxVMPrim.nat_mod_lit", 1_397_240_565), + ("IxVMPrim.nat_succ_lit", 143_042_327), + ("IxVMPrim.nat_pred_lit", 162_860_908), + ("IxVMPrim.nat_gcd_lit", 2_157_096_411), + ("IxVMPrim.nat_land_lit", 3_557_575_125), + ("IxVMPrim.nat_lor_lit", 3_559_403_739), + ("IxVMPrim.nat_xor_lit", 3_577_939_488), + ("IxVMPrim.nat_shl_lit", 224_284_431), + ("IxVMPrim.nat_shr_lit", 1_385_401_634), + ("IxVMPrim.nat_pow_big", 385_741_876), + ("IxVMPrim.nat_beq_lit", 195_776_017), + ("IxVMPrim.nat_ble_lit", 190_277_382), + ("IxVMPrim.nat_cases_big", 163_000_088), + ("IxVMPrim.nat_dec_le", 794_551_504), + ("IxVMPrim.nat_dec_lt", 805_599_013), + ("IxVMPrim.nat_dec_eq", 402_260_970), + ("IxVMPrim.str_size_lit", 2_468_126_499), + ("IxVMPrim.bv_to_nat_lit", 2_058_465_428), + ("IxVMInd.Even", 198_955_196), + ("IxVMInd.Odd", 198_957_960), + ("IxVMInd.Even.rec", 216_000_626), + ("IxVMInd.Odd.rec", 215_998_777), + ("IxVMInd.IdxTeleN.rec", 157_234_156), + ("IxVMInd.IdxTeleB.rec", 157_233_314), + ("IxVMInd.SoloA.rec", 152_828_427), + ("IxVMInd.SoloB.rec", 152_828_427), ("IxVMInd.UnsafeSquash", 131_117_557), - ("IxVMInd.Tree", 130_802_963), - ("IxVMInd.Tree.rec", 139_790_913), - ("IxVMInd.DedupM", 133_837_112), - ("IxVMInd.DedupM.rec", 145_992_467), - ("IxVMInd.DepthM", 132_388_056), - ("IxVMInd.DepthM.rec", 142_682_129), - ("String.Internal.append", 2_439_897_505), - ("_private.Init.Prelude.0.Lean.extractMainModule._unsafe_rec", 3_636_655_453), - ("Lean.Syntax.rec", 2_494_352_709), - ("IxVMInd.AuxTie", 307_684_302), - ("IxVMInd.AuxTie.rec", 347_798_352), - ("IxVMInd.HiddenIdx", 129_987_097), - ("IxVMInd.HiddenIdx.rec", 132_516_236), - ("IxVMInd.thmMajorUse", 498_291_604), - ("IxVMInd.partialKRec", 148_528_671), - ("IxVMInd.deepRebase", 212_996_576), - ("String.Slice.Pattern.Model.NoPrefixPatternModel.rec", 3_401_124_861), - ("Lean.Widget.TaggedText.rec", 2_467_059_285), - ("Lean.Doc.Part.rec", 2_506_906_864), - ("Lean.Doc.Block.rec", 2_726_901_380), - ("_private.Tests.Ix.Compile.Mutual.0.Tests.Ix.Compile.Mutual.AuxDedup1.A", 131_985_878), - ("_private.Tests.Ix.Compile.Mutual.0.Tests.Ix.Compile.Mutual.AuxDedup1.A.rec", 134_785_783), - ("_private.Tests.Ix.Compile.Mutual.0.Tests.Ix.Compile.Mutual.AuxDedup1.A.rec_1", 134_230_554), - ("_private.Tests.Ix.Compile.Mutual.0.Tests.Ix.Compile.Mutual.AuxDedup1.A.rec_2", 134_230_554), - ("_private.Tests.Ix.Compile.Mutual.0.Tests.Ix.Compile.Mutual.AuxDedup2.A.rec_1", 134_230_554), - ("_private.Tests.Ix.Compile.Mutual.0.Tests.Ix.Compile.Mutual.AuxDedupMixed.M", 132_238_939), - ("_private.Tests.Ix.Compile.Mutual.0.Tests.Ix.Compile.Mutual.AuxDedupMixed.M.rec", 142_358_345), - ("_private.Tests.Ix.Compile.Mutual.0.Tests.Ix.Compile.Mutual.AuxDedupMixed.M.rec_1", 142_356_772), - ("_private.Tests.Ix.Compile.Mutual.0.Tests.Ix.Compile.Mutual.AuxDedupMixed.M.rec_2", 134_230_554), - ("strOfListFoldSize", 2_744_277_864), - ("strOfListFoldSizeAscii", 2_745_050_429), - ("IxVMPrim.lazy_ble_offset", 225_108_246), - ("IxVMPrim.lazy_unit_cast", 534_750_477), + ("IxVMInd.Tree", 130_794_604), + ("IxVMInd.Tree.rec", 139_782_495), + ("IxVMInd.DedupM", 133_824_522), + ("IxVMInd.DedupM.rec", 145_979_900), + ("IxVMInd.DepthM", 132_375_494), + ("IxVMInd.DepthM.rec", 142_669_488), + ("String.Internal.append", 2_439_443_551), + ("_private.Init.Prelude.0.Lean.extractMainModule._unsafe_rec", 3_636_038_614), + ("Lean.Syntax.rec", 2_493_854_041), + ("IxVMInd.AuxTie", 307_634_206), + ("IxVMInd.AuxTie.rec", 347_749_398), + ("IxVMInd.HiddenIdx", 129_982_557), + ("IxVMInd.HiddenIdx.rec", 132_511_691), + ("IxVMInd.thmMajorUse", 498_209_507), + ("IxVMInd.partialKRec", 148_505_275), + ("IxVMInd.deepRebase", 212_934_853), + ("String.Slice.Pattern.Model.NoPrefixPatternModel.rec", 3_400_436_539), + ("Lean.Widget.TaggedText.rec", 2_466_579_842), + ("Lean.Doc.Part.rec", 2_506_403_048), + ("Lean.Doc.Block.rec", 2_726_399_446), + ("_private.Tests.Ix.Compile.Mutual.0.Tests.Ix.Compile.Mutual.AuxDedup1.A", 131_981_254), + ("_private.Tests.Ix.Compile.Mutual.0.Tests.Ix.Compile.Mutual.AuxDedup1.A.rec", 134_781_143), + ("_private.Tests.Ix.Compile.Mutual.0.Tests.Ix.Compile.Mutual.AuxDedup1.A.rec_1", 134_225_999), + ("_private.Tests.Ix.Compile.Mutual.0.Tests.Ix.Compile.Mutual.AuxDedup1.A.rec_2", 134_225_999), + ("_private.Tests.Ix.Compile.Mutual.0.Tests.Ix.Compile.Mutual.AuxDedup2.A.rec_1", 134_225_999), + ("_private.Tests.Ix.Compile.Mutual.0.Tests.Ix.Compile.Mutual.AuxDedupMixed.M", 132_230_529), + ("_private.Tests.Ix.Compile.Mutual.0.Tests.Ix.Compile.Mutual.AuxDedupMixed.M.rec", 142_349_866), + ("_private.Tests.Ix.Compile.Mutual.0.Tests.Ix.Compile.Mutual.AuxDedupMixed.M.rec_1", 142_348_292), + ("_private.Tests.Ix.Compile.Mutual.0.Tests.Ix.Compile.Mutual.AuxDedupMixed.M.rec_2", 134_225_999), + ("strOfListFoldSize", 2_743_699_657), + ("strOfListFoldSizeAscii", 2_744_475_760), + ("IxVMPrim.lazy_ble_offset", 225_096_361), + ("IxVMPrim.lazy_unit_cast", 534_588_120), + ("IxVMPrim.sizeof_unit", 158_539_438), ] /-- Variant of `kernelChecks`, pinned to the baseline diff --git a/Tests/Ix/IxVM/Exploits.lean b/Tests/Ix/IxVM/Exploits.lean index 8d302cdc..a4edbaf7 100644 --- a/Tests/Ix/IxVM/Exploits.lean +++ b/Tests/Ix/IxVM/Exploits.lean @@ -419,6 +419,53 @@ def corruptRecrRules (c : Ixon.Constant) (nBinders : Nat) | other => other } | _ => c +/-! ### Recursor `motives`/`minors` arity metadata + +`compare_rules` reconstructs each canonical rule body and asserts it is +def-eq to the STORED rule body, and the declared recursor type is matched +against `build_rec_type`. Both derive their motive/minor counts from the +inductive block (`flat`), so they stay honest. But EVERY consumer uses +only the SUM `motives + minors` — the peel count, the major-spine +position, the type reconstruction — EXCEPT `minor_var` +(`Kernel/Check.lean:2573`), where `n_minors` ALONE selects which binder +each canonical body points at. IxVM never compares the prover's declared +`motives`/`minors` against the reconstruction; both references do +(`inductive.rs:4945`, `Ix/Tc/Inductive.lean:2346`, error "arity metadata +mismatch"). -/ + +/-- Replace the innermost (non-`lam`) body of a `lam` telescope, keeping + the binder count and every domain. -/ +partial def setLamBody (newBody : Ixon.Expr) : Ixon.Expr → Ixon.Expr + | .lam d b => .lam d (setLamBody newBody b) + | _ => newBody + +/-- Move all of `motives` into `minors` (sum preserved, so the peel count + and declared type are unchanged), then rewrite each FIELD-FREE rule's + body to the BVar the reconstruction now expects, + `minor_var = (minors' - 1) - ctorIdx`. Under the honest split every + body pointed at its own minor premise; under the forged split the + first rule's body points one binder further out — at the MOTIVE — so + `R mo m0 … c0` reduces to `mo`, i.e. `(I → Type) : Type`. Only + applies to a recursor whose rules are all nullary (`fields == 0`), so + the canonical body is a bare minor variable with no IH application. -/ +def forgeRecMetadata (c : Ixon.Constant) : Ixon.Constant := + let forgeOne (r : Ixon.Recursor) : Ixon.Recursor := + if r.rules.size < 2 || r.motives == 0 || r.rules.any (·.fields != 0) then r + else + let minors' : UInt64 := r.motives + r.minors + let rules' := (Array.range r.rules.size).map fun i => + let target : UInt64 := (minors' - 1) - i.toUInt64 + { r.rules[i]! with rhs := setLamBody (.var target) r.rules[i]!.rhs } + { r with motives := 0, minors := minors', rules := rules' } + match c.info with + | .recr r => { c with info := .recr (forgeOne r) } + | .muts members => + { c with info := .muts <| members.map fun m => + match m with + | .recr r => .recr (forgeOne r) + | other => other } + | _ => c + /-! ### Byte-level encodings Every other fixture here is built from an `Ixon.Constant` VALUE and @@ -529,6 +576,94 @@ def utf8SizeBeq (eqA boolA beqA sizeA blobA rhsA reflA : Address) : ⟨.defn ⟨.thm, .safe, 0, typ, val⟩, #[], #[eqA, boolA, beqA, sizeA, blobA, rhsA, reflA], #[.succ .zero]⟩ +/-! ### Native `SizeOf.sizeOf` reduction ignores the instance + +`try_reduce_size_of_unit` (`Ix/IxVM/Kernel/NatPrim.lean:354-374`) folds +`@SizeOf.sizeOf Unit _ x` to `Lit(Nat 1)` after inspecting ONLY the type +argument — the `[self : SizeOf Unit]` instance is never read. But +`SizeOf` is a one-field class, so its instance is prover-chosen: +`@SizeOf.sizeOf Unit ⟨fun _ => 5⟩ ()` is `5` in Lean (project the field, +apply). lean4lean unfolds the instance and computes `5`; IxVM answers +`1`. The reference IxVM kernels (`whnf.rs`, `Ix/Tc/Whnf.lean`) share the +blindness, but lean4lean — the ground truth — does not, so the three do +NOT agree and IxVM is free to follow Lean. -/ + +/-- `theorem _ : @SizeOf.sizeOf Unit ⟨fun _ => payload⟩ () = rhs := Eq.refl Nat rhs` + + `refs`: 0=Eq, 1=Nat, 2=SizeOf.sizeOf, 3=SizeOf.mk, 4=Unit, + 5=Unit.unit, 6=Eq.refl, then the appended nat-literal blobs. Both the + instance's payload and the right-hand side are `Expr.nat` indices into + those blobs. All four polymorphic heads instantiate at `Sort 1` + (`Nat, Unit : Type`), so a single `univs = #[Succ Zero]` entry serves + every `#[0]`. -/ +def sizeOfUnitInstanceThm (eqA natA sizeOfA mkA unitA unitUnitA reflA : Address) + (blobRefs : Array Address) (payloadIdx rhsIdx : UInt64) : Ixon.Constant := + -- `@SizeOf.mk.{1} Unit (fun (_ : Unit) => Nat.lit payload)` + let inst : Ixon.Expr := + .app (.app (.ref 3 #[0]) (.ref 4 #[])) (.lam (.ref 4 #[]) (.nat payloadIdx)) + -- `@SizeOf.sizeOf.{1} Unit inst Unit.unit` + let lhs : Ixon.Expr := + .app (.app (.app (.ref 2 #[0]) (.ref 4 #[])) inst) (.ref 5 #[]) + let typ : Ixon.Expr := + .app (.app (.app (.ref 0 #[0]) (.ref 1 #[])) lhs) (.nat rhsIdx) + let val : Ixon.Expr := .app (.app (.ref 6 #[0]) (.ref 1 #[])) (.nat rhsIdx) + ⟨.defn ⟨.thm, .safe, 0, typ, val⟩, #[], + #[eqA, natA, sizeOfA, mkA, unitA, unitUnitA, reflA] ++ blobRefs, + #[.succ .zero]⟩ + +/-! ### Struct-eta fires on a semantically-Prop major + +`is_prop_type` (`Ix/IxVM/Kernel/DefEq.lean:900`) decides Prop by testing +the inferred sort against the STRUCTURAL node `KLevelNode.Zero`; all three +references — including lean4lean, the ground truth — test SEMANTIC zero +(`is_semantic_zero` / `isAlwaysZero`). `convert_univ` is a raw conversion, +so a prover can author `Sort (max 0 0)`: semantically Prop, structurally +`Max`. `try_struct_eta_iota` (`Whnf.lean:951`) then reduces a recursor on +a Prop-typed major where every reference leaves it stuck — the reduction +lean4#14613 was filed and fixed for. The equation it proves is TRUE by +proof irrelevance, so this is a reference divergence in the unsound +DIRECTION (a broken defense-in-depth layer), not a false theorem today; +the fix is `level_equal(l, Zero)`, at which point this flips to REJECT. -/ + +/-- `J := Iff False False`, declared at `Sort sortUniv`. `Iff False False` + is `Prop`, and `level_equal` is semantic, so it typechecks for any + semantically-zero `sortUniv`; the DECLARED spelling is what + `is_prop_type` later reads verbatim. refs: 0=Iff, 1=False. -/ +def propAliasAtSort (iffA falseA : Address) (sortUniv : Ixon.Univ) : + Ixon.Constant := + defnConst .defn (.sort 0) + (.app (.app (.ref 0 #[]) (.ref 1 #[])) (.ref 1 #[])) + (refs := #[iffA, falseA]) (univs := #[sortUniv]) + +/-- `theorem _ (h : J) : @Iff.rec False False (fun _ => Nat) + (fun _ _ => 0) h = 0 := fun _ => Eq.refl Nat 0` + + `Iff` is a subsingleton (single ctor, both fields Prop), so it is + struct-like and large-eliminating — the motive may land in `Type`. + Struct-eta on the opaque `h : J` reduces `Iff.rec … h` to + `(fun _ _ => 0) (h.1) (h.2)`, i.e. `0`, so the `rfl` typechecks — but + only if `is_prop_type(J)` answered "not Prop". With `J : Sort 0` it + answers Prop and eta declines (the control); with `J : Sort (max 0 0)` + the structural test answers "not Prop" and eta fires (the divergence). + refs: 0=Eq,1=Nat,2=Iff.rec,3=Iff,4=False,5=Eq.refl,6=J,7=nat-0 blob. -/ +def structEtaOnAlias (eqA natA iffRecA iffA falseA reflA jA zeroBlobA : + Address) : Ixon.Constant := + let iffFF : Ixon.Expr := .app (.app (.ref 3 #[]) (.ref 4 #[])) (.ref 4 #[]) + let motiveE : Ixon.Expr := .lam iffFF (.ref 1 #[]) + let ffArrow : Ixon.Expr := .all (.ref 4 #[]) (.ref 4 #[]) + let minorE : Ixon.Expr := .lam ffArrow (.lam ffArrow (.nat 7)) + -- `@Iff.rec.{1} False False motive minor h`, with `h` the `∀`-bound BVar. + let lhs : Ixon.Expr := + .app (.app (.app (.app (.app (.ref 2 #[0]) (.ref 4 #[])) (.ref 4 #[])) + motiveE) minorE) (.var 0) + let eqE : Ixon.Expr := + .app (.app (.app (.ref 0 #[0]) (.ref 1 #[])) lhs) (.nat 7) + let typ : Ixon.Expr := .all (.ref 6 #[]) eqE + let val : Ixon.Expr := + .lam (.ref 6 #[]) (.app (.app (.ref 5 #[0]) (.ref 1 #[])) (.nat 7)) + ⟨.defn ⟨.thm, .safe, 0, typ, val⟩, #[], + #[eqA, natA, iffRecA, iffA, falseA, reflA, jA, zeroBlobA], #[.succ .zero]⟩ + /-! ### Nested-inductive positivity Two single-inductive blocks in `Prop`. The outer one takes the inner @@ -702,7 +837,9 @@ def indOnlyBlock (falseAddr : Address) (field : Ixon.Expr) : Ixon.Constant := ⟨.muts #[.indc ind], #[], #[falseAddr], #[.zero]⟩ def cases (base : Ixon.Env) (strAddr falseAddr : Address) - (eqA boolA beqA sizeA trueA falseBoolA reflA : Address) : + (eqA boolA beqA sizeA trueA falseBoolA reflA : Address) + (natA sizeOfSizeOfA sizeOfMkA unitA unitUnitA : Address) + (iffA iffRecA : Address) : Array ExploitCase := Id.run do -- `""` and `0` share one blob: both are the empty byte string. let emptyBlob : ByteArray := ⟨#[]⟩ @@ -730,8 +867,8 @@ def cases (base : Ixon.Env) (strAddr falseAddr : Address) -- difference between them is the binder domains. let refIdx := block.refs.size.toUInt64 let block := { block with refs := block.refs.push falseAddr } - let mk (retype : Option Ixon.Expr) : Ixon.Env × Address := Id.run do - let (env, blockAddr) := storeAt base (corruptRecrRules block 2 retype) + let mkFrom (corrupted : Ixon.Constant) : Ixon.Env × Address := Id.run do + let (env, blockAddr) := storeAt base corrupted let mut e := env for i in [:2] do e := (storeAt e ⟨.iPrj ⟨i.toUInt64, blockAddr⟩, #[], #[], #[]⟩).1 @@ -739,8 +876,10 @@ def cases (base : Ixon.Env) (strAddr falseAddr : Address) e := (storeAt e ⟨.cPrj ⟨i.toUInt64, 0, blockAddr⟩, #[], #[], #[]⟩).1 e := (storeAt e ⟨.cPrj ⟨i.toUInt64, 1, blockAddr⟩, #[], #[], #[]⟩).1 return (e, blockAddr) - let (honestEnv, honestAddr) := mk none - let (doctoredEnv, doctoredAddr) := mk (some (.ref refIdx #[])) + let (honestEnv, honestAddr) := mkFrom (corruptRecrRules block 2 none) + let (doctoredEnv, doctoredAddr) := + mkFrom (corruptRecrRules block 2 (some (.ref refIdx #[]))) + let (forgedEnv, forgedAddr) := mkFrom (forgeRecMetadata block) #[ -- CONTROL: swapped rules with the compiler's own binder domains. -- The comparison then infers through honest types and the @@ -757,7 +896,21 @@ def cases (base : Ixon.Env) (strAddr falseAddr : Address) intent := "a recursor accepted with swapped computation rules, \ because the rule's own binder domains chose the context the \ comparison infers through" - env := doctoredEnv, claim := .check doctoredAddr none } + env := doctoredEnv, claim := .check doctoredAddr none }, + -- EXPLOIT: forge the motives/minors SPLIT (sum preserved) and + -- shift each rule body to the binder the reconstruction expects + -- under that split. The declared type still matches + -- `build_rec_type` (which reads the honest counts from the + -- block), and `compare_rules` reconstructs the SAME shifted + -- bodies, so the def-eq passes — but the reduction now fires the + -- first rule against the motive instead of its minor. References + -- reject via the arity-metadata equality check IxVM omits. + { name := "recursor-motives-minors-split-forged" + intent := "a recursor accepted with a forged motives/minors \ + split: `minor_var` reads `minors` alone, so `R mo m0 m1 c0` \ + reduces to `mo` — an impredicative `(I → Type) : Type`, from \ + which Girard yields False" + env := forgedEnv, claim := .check forgedAddr none } ] let axiomBytes := Ixon.ser propAxiom let (canonBytesEnv, canonBytesAddr) := storeRawAt base axiomBytes @@ -840,6 +993,39 @@ def cases (base : Ixon.Env) (strAddr falseAddr : Address) let (plainEnv, plainAddr) := dependentTarget (deadSharing := false) let (deadEnv, deadAddr) := dependentTarget (deadSharing := true) let (bothEnv, bothAddr) := bothUsedTarget + -- `SizeOf.sizeOf Unit ()`: nat-literal blobs for the + -- instance payload (5) and the claimed result (1). A one-byte LE + -- magnitude decodes to the canonical `KLimbs` via `bytes_to_limbs`. + let blob1 : ByteArray := ⟨#[0x01]⟩ + let blob5 : ByteArray := ⟨#[0x05]⟩ + let blob1A := Address.blake3 blob1 + let blob5A := Address.blake3 blob5 + let sizeOfEnv := { base with + blobs := (base.blobs.insert blob1A blob1).insert blob5A blob5 } + -- refs append order: [..7 consts.., blob1A@7, blob5A@8]. + let blobRefs : Array Address := #[blob1A, blob5A] + let (sizeOfExploitEnv, sizeOfExploitAddr) := storeAt sizeOfEnv + (sizeOfUnitInstanceThm eqA natA sizeOfSizeOfA sizeOfMkA unitA unitUnitA + reflA blobRefs (payloadIdx := 8) (rhsIdx := 7)) + let (sizeOfControlEnv, sizeOfControlAddr) := storeAt sizeOfEnv + (sizeOfUnitInstanceThm eqA natA sizeOfSizeOfA sizeOfMkA unitA unitUnitA + reflA blobRefs (payloadIdx := 7) (rhsIdx := 7)) + -- Struct-eta: `J := Iff False False` declared at two Prop spellings. + -- The nat `0` is the empty blob (shared with `bytes_to_limbs`). + let etaZeroBlob : ByteArray := ⟨#[]⟩ + let etaZeroBlobA := Address.blake3 etaZeroBlob + let etaBase := { base with blobs := base.blobs.insert etaZeroBlobA etaZeroBlob } + let mkEta (sortUniv : Ixon.Univ) : Ixon.Env × Address := Id.run do + let (env, jA) := storeAt etaBase (propAliasAtSort iffA falseAddr sortUniv) + storeAt env + (structEtaOnAlias eqA natA iffRecA iffA falseAddr reflA jA etaZeroBlobA) + -- CONTROL spelling `Sort 0`: `is_prop_type` says Prop, eta declines, + -- the `rfl` fails to typecheck, so the kernel rejects (as it must). + let (etaCtrlEnv, etaCtrlAddr) := mkEta .zero + -- EXPLOIT spelling `Sort (max 0 0)`: semantically the same Prop, but + -- the structural test says "not Prop", eta fires, and the kernel + -- accepts where every reference leaves the recursor stuck. + let (etaExploitEnv, etaExploitAddr) := mkEta (.max .zero .zero) let selfTree := (Ix.AssumptionTree.canonical #[badAddr]).get! let selfTrees : Std.HashMap Address Ix.AssumptionTree := ({} : Std.HashMap Address Ix.AssumptionTree).insert selfTree.root selfTree @@ -876,6 +1062,46 @@ def cases (base : Ixon.Env) (strAddr falseAddr : Address) intent := "a definition whose ill-typed dependency is hidden \ behind an index that also carries a Nat literal" env := bothEnv, claim := .check bothAddr none }, + -- CONTROL: the same shape with the CANONICAL `SizeOf Unit` value. + -- The instance returns 1, which matches IxVM's hardcoded fold, so + -- both IxVM and Lean accept — this proves the term is well-formed and + -- the native fold fires, isolating the exploit to the payload byte. + { name := "control-sizeof-unit-canonical-value" + intent := "`@SizeOf.sizeOf Unit ⟨fun _ => 1⟩ () = 1` — true in \ + Lean and folded to 1 by the kernel, which must be accepted" + env := sizeOfControlEnv, claim := .check sizeOfControlAddr none + expectAccept := true }, + -- EXPLOIT: `SizeOf` is a one-field class, so the instance is + -- prover-chosen. `@SizeOf.sizeOf Unit ⟨fun _ => 5⟩ ()` is 5 in Lean + -- (project the field, apply `()`), but `try_reduce_size_of_unit` + -- reads only the TYPE argument and folds to 1, so `… = 1` typechecks + -- by rfl. lean4lean unfolds the instance and rejects. + { name := "sizeof-unit-ignores-instance" + intent := "`@SizeOf.sizeOf Unit ⟨fun _ => 5⟩ () = 1` accepted by \ + rfl — a false equation, since projecting the prover's instance \ + gives 5, not the kernel's hardcoded 1" + env := sizeOfExploitEnv, claim := .check sizeOfExploitAddr none }, + -- CONTROL: the same theorem with `J : Sort 0` (syntactic `Zero`). + -- `is_prop_type` returns 1, struct-eta declines, the recursor stays + -- stuck and the `rfl` fails to typecheck — the kernel MUST reject, + -- proving the fixture reaches the struct-eta guard. + { name := "control-struct-eta-syntactic-prop-declines" + intent := "`Iff.rec … h = 0` over `h : (J : Sort 0)` — a correct \ + kernel leaves the recursor stuck, so the rfl must be rejected" + env := etaCtrlEnv, claim := .check etaCtrlAddr none }, + -- DIVERGENCE: `J : Sort (max 0 0)` is the SAME Prop semantically, but + -- `is_prop_type`'s structural `Zero` test says "not Prop", so + -- struct-eta fires and the recursor reduces to `0`, accepting the + -- rfl. Every reference tests semantic zero and declines. The proved + -- equation is true (proof irrelevance), so this pins the divergence / + -- broken guard, not a false theorem — it flips to REJECT once + -- `is_prop_type` uses `level_equal(l, Zero)`. + { name := "struct-eta-fires-on-semantic-prop" + intent := "`Iff.rec … h = 0` over `h : (J : Sort (max 0 0))` \ + accepted via struct-eta on a Prop-typed major — the reduction \ + lean4#14613 fixed, reachable because `is_prop_type` tests \ + structural not semantic zero" + env := etaExploitEnv, claim := .check etaExploitAddr none }, -- BOUNDARY, not a kernel bug: assumption sets are prover-supplied, -- and naming the claim's own target as its own assumption makes the -- walk exit immediately, so an ill-typed constant is accepted. The @@ -1187,7 +1413,8 @@ def exploitTests (leanEnv : Lean.Environment) -- nothing. let base ← IxVM.ClaimHarness.loadSharedIxonEnv #[``String, ``False, ``Eq, ``Eq.refl, ``Bool, ``Nat.beq, - ``String.utf8ByteSize] leanEnv + ``String.utf8ByteSize, ``Nat, ``SizeOf.sizeOf, ``SizeOf.mk, + ``Unit, ``Unit.unit, ``Iff, ``Iff.rec] leanEnv let strAddr ← IxVM.ClaimHarness.lookupAddr base ``String let falseAddr ← IxVM.ClaimHarness.lookupAddr base ``False let eqA ← IxVM.ClaimHarness.lookupAddr base ``Eq @@ -1197,9 +1424,17 @@ def exploitTests (leanEnv : Lean.Environment) let trueA ← IxVM.ClaimHarness.lookupAddr base ``Bool.true let falseBoolA ← IxVM.ClaimHarness.lookupAddr base ``Bool.false let reflA ← IxVM.ClaimHarness.lookupAddr base ``Eq.refl + let natA ← IxVM.ClaimHarness.lookupAddr base ``Nat + let sizeOfSizeOfA ← IxVM.ClaimHarness.lookupAddr base ``SizeOf.sizeOf + let sizeOfMkA ← IxVM.ClaimHarness.lookupAddr base ``SizeOf.mk + let unitA ← IxVM.ClaimHarness.lookupAddr base ``Unit + let unitUnitA ← IxVM.ClaimHarness.lookupAddr base ``Unit.unit + let iffA ← IxVM.ClaimHarness.lookupAddr base ``Iff + let iffRecA ← IxVM.ClaimHarness.lookupAddr base ``Iff.rec let mut tests : TestSeq := .done for c in cases base strAddr falseAddr eqA boolA beqA sizeA trueA - falseBoolA reflA do + falseBoolA reflA natA sizeOfSizeOfA sizeOfMkA unitA unitUnitA + iffA iffRecA do let verdict := if c.expectAccept then "ACCEPT" else "REJECT" let label := s!"exploit {verdict} {c.name}" match IxVM.ClaimHarness.buildClaimWitness c.env c.claim c.trees with diff --git a/Tests/Main.lean b/Tests/Main.lean index 1fef5662..9f4684de 100644 --- a/Tests/Main.lean +++ b/Tests/Main.lean @@ -237,8 +237,8 @@ def ignoredRunners (env : Lean.Environment) : List (String × IO UInt32) := [ let actual := (Aiur.computeStats v2Env.compiled qc v2Env.shapes).totalFftCost.round.toUInt64.toNat pure (LSpec.test - s!"Shard pipeline FFT matches: expected 6_770_109_972, got {actual}" - (actual = 6_770_109_972)) + s!"Shard pipeline FFT matches: expected 6_769_529_091, got {actual}" + (actual = 6_769_529_091)) LSpec.lspecIO (.ofList [("ixvm", [fullSeq, aiurSeq, arenaSeq, exploitSeq, paritySeq, shardSeq])]) []), diff --git a/crates/ixvm-codegen/src/aiur_ixvm.rs b/crates/ixvm-codegen/src/aiur_ixvm.rs index 9c2a3f3e..e0b23dee 100644 --- a/crates/ixvm-codegen/src/aiur_ixvm.rs +++ b/crates/ixvm-codegen/src/aiur_ixvm.rs @@ -5210,7 +5210,7 @@ fn aiur_fn_28( let __v_72: G = __r_arr[63]; match __v_2.as_canonical_u64() { 1023u64 => { - let __r_arr: [G; OUT_772] = { let __args: [G; IN_772] = [__v_0]; let __cu = unconstrained; if let Some(result) = record.function_queries[772].get_mut(&__args[..]) { if !__cu && *result.multiplicity == G::ZERO { aiur_fn_772(__args, record, io_buffer, false)? } else { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_772] = unsafe { *(result.output.as_ptr() as *const [G; OUT_772]) }; __ret } } else { aiur_fn_772(__args, record, io_buffer, __cu)? } }; + let __r_arr: [G; OUT_768] = { let __args: [G; IN_768] = [__v_0]; let __cu = unconstrained; if let Some(result) = record.function_queries[768].get_mut(&__args[..]) { if !__cu && *result.multiplicity == G::ZERO { aiur_fn_768(__args, record, io_buffer, false)? } else { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_768] = unsafe { *(result.output.as_ptr() as *const [G; OUT_768]) }; __ret } } else { aiur_fn_768(__args, record, io_buffer, __cu)? } }; let __v_73: G = __r_arr[0]; let __loaded: [G; 8] = { let __mq = record.memory_queries.get_mut(&8).ok_or(ExecError::InvalidMemorySize(8))?; let __ptr_u64 = __v_3.as_canonical_u64(); let __ptr_usize = usize::try_from(__ptr_u64).ok().ok_or(ExecError::PointerTooLarge(__ptr_u64))?; let (__args, __mult) = __mq.get_index_mut(__ptr_usize).ok_or(ExecError::UnboundPointer { ptr: __ptr_u64, size: 8 })?; if !unconstrained { *__mult += G::ONE; } let __arr: [G; 8] = __args[..8].try_into().unwrap(); __arr }; let __v_74: G = __loaded[0]; @@ -5391,10 +5391,10 @@ fn aiur_fn_28( return Ok(__ret); }, _ => { - let __r_arr: [G; OUT_772] = { let __args: [G; IN_772] = [__v_0]; let __cu = unconstrained; if let Some(result) = record.function_queries[772].get_mut(&__args[..]) { if !__cu && *result.multiplicity == G::ZERO { aiur_fn_772(__args, record, io_buffer, false)? } else { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_772] = unsafe { *(result.output.as_ptr() as *const [G; OUT_772]) }; __ret } } else { aiur_fn_772(__args, record, io_buffer, __cu)? } }; + let __r_arr: [G; OUT_768] = { let __args: [G; IN_768] = [__v_0]; let __cu = unconstrained; if let Some(result) = record.function_queries[768].get_mut(&__args[..]) { if !__cu && *result.multiplicity == G::ZERO { aiur_fn_768(__args, record, io_buffer, false)? } else { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_768] = unsafe { *(result.output.as_ptr() as *const [G; OUT_768]) }; __ret } } else { aiur_fn_768(__args, record, io_buffer, __cu)? } }; let __v_73: G = __r_arr[0]; let __v_74: G = (__v_73 * __v_7); - let __r_arr: [G; OUT_772] = { let __args: [G; IN_772] = [__v_0]; let __cu = unconstrained; if let Some(result) = record.function_queries[772].get_mut(&__args[..]) { if !__cu && *result.multiplicity == G::ZERO { aiur_fn_772(__args, record, io_buffer, false)? } else { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_772] = unsafe { *(result.output.as_ptr() as *const [G; OUT_772]) }; __ret } } else { aiur_fn_772(__args, record, io_buffer, __cu)? } }; + let __r_arr: [G; OUT_768] = { let __args: [G; IN_768] = [__v_0]; let __cu = unconstrained; if let Some(result) = record.function_queries[768].get_mut(&__args[..]) { if !__cu && *result.multiplicity == G::ZERO { aiur_fn_768(__args, record, io_buffer, false)? } else { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_768] = unsafe { *(result.output.as_ptr() as *const [G; OUT_768]) }; __ret } } else { aiur_fn_768(__args, record, io_buffer, __cu)? } }; let __v_75: G = __r_arr[0]; let __loaded: [G; 8] = { let __mq = record.memory_queries.get_mut(&8).ok_or(ExecError::InvalidMemorySize(8))?; let __ptr_u64 = __v_3.as_canonical_u64(); let __ptr_usize = usize::try_from(__ptr_u64).ok().ok_or(ExecError::PointerTooLarge(__ptr_u64))?; let (__args, __mult) = __mq.get_index_mut(__ptr_usize).ok_or(ExecError::UnboundPointer { ptr: __ptr_u64, size: 8 })?; if !unconstrained { *__mult += G::ONE; } let __arr: [G; 8] = __args[..8].try_into().unwrap(); __arr }; let __v_76: G = __loaded[0]; @@ -7929,7 +7929,7 @@ fn aiur_fn_33( return Ok(__ret); }, 2u64 => { - let __r_arr: [G; OUT_758] = { let __args: [G; IN_758] = [__v_9]; let __cu = unconstrained; if let Some(result) = record.function_queries[758].get_mut(&__args[..]) { if !__cu && *result.multiplicity == G::ZERO { aiur_fn_758(__args, record, io_buffer, false)? } else { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_758] = unsafe { *(result.output.as_ptr() as *const [G; OUT_758]) }; __ret } } else { aiur_fn_758(__args, record, io_buffer, __cu)? } }; + let __r_arr: [G; OUT_754] = { let __args: [G; IN_754] = [__v_9]; let __cu = unconstrained; if let Some(result) = record.function_queries[754].get_mut(&__args[..]) { if !__cu && *result.multiplicity == G::ZERO { aiur_fn_754(__args, record, io_buffer, false)? } else { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_754] = unsafe { *(result.output.as_ptr() as *const [G; OUT_754]) }; __ret } } else { aiur_fn_754(__args, record, io_buffer, __cu)? } }; let __v_19: G = __r_arr[0]; let __v_20: G = __r_arr[1]; let __v_21: G = __r_arr[2]; @@ -7950,7 +7950,7 @@ fn aiur_fn_33( return Ok(__ret); }, 3u64 => { - let __r_arr: [G; OUT_758] = { let __args: [G; IN_758] = [__v_9]; let __cu = unconstrained; if let Some(result) = record.function_queries[758].get_mut(&__args[..]) { if !__cu && *result.multiplicity == G::ZERO { aiur_fn_758(__args, record, io_buffer, false)? } else { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_758] = unsafe { *(result.output.as_ptr() as *const [G; OUT_758]) }; __ret } } else { aiur_fn_758(__args, record, io_buffer, __cu)? } }; + let __r_arr: [G; OUT_754] = { let __args: [G; IN_754] = [__v_9]; let __cu = unconstrained; if let Some(result) = record.function_queries[754].get_mut(&__args[..]) { if !__cu && *result.multiplicity == G::ZERO { aiur_fn_754(__args, record, io_buffer, false)? } else { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_754] = unsafe { *(result.output.as_ptr() as *const [G; OUT_754]) }; __ret } } else { aiur_fn_754(__args, record, io_buffer, __cu)? } }; let __v_19: G = __r_arr[0]; let __v_20: G = __r_arr[1]; let __v_21: G = __r_arr[2]; @@ -9931,7 +9931,7 @@ fn aiur_fn_57( let __v_63: G = G::from_u64(2); let __v_64: G = (__v_63 * __v_1); let __v_65: G = (__v_0 + __v_64); - let __r_arr: [G; OUT_770] = { let __args: [G; IN_770] = [__v_43]; let __cu = unconstrained; if let Some(result) = record.function_queries[770].get_mut(&__args[..]) { if !__cu && *result.multiplicity == G::ZERO { aiur_fn_770(__args, record, io_buffer, false)? } else { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_770] = unsafe { *(result.output.as_ptr() as *const [G; OUT_770]) }; __ret } } else { aiur_fn_770(__args, record, io_buffer, __cu)? } }; + let __r_arr: [G; OUT_766] = { let __args: [G; IN_766] = [__v_43]; let __cu = unconstrained; if let Some(result) = record.function_queries[766].get_mut(&__args[..]) { if !__cu && *result.multiplicity == G::ZERO { aiur_fn_766(__args, record, io_buffer, false)? } else { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_766] = unsafe { *(result.output.as_ptr() as *const [G; OUT_766]) }; __ret } } else { aiur_fn_766(__args, record, io_buffer, __cu)? } }; let __v_66: G = __r_arr[0]; let __v_67: G = __r_arr[1]; let __v_68: G = __r_arr[2]; @@ -10294,7 +10294,7 @@ fn aiur_fn_62( let __v_43: G = __loaded[15]; let __v_44: G = __loaded[16]; let __v_45: G = __loaded[17]; - let __r_arr: [G; OUT_765] = { let __args: [G; IN_765] = [__v_26]; let __cu = unconstrained; if let Some(result) = record.function_queries[765].get_mut(&__args[..]) { if !__cu && *result.multiplicity == G::ZERO { aiur_fn_765(__args, record, io_buffer, false)? } else { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_765] = unsafe { *(result.output.as_ptr() as *const [G; OUT_765]) }; __ret } } else { aiur_fn_765(__args, record, io_buffer, __cu)? } }; + let __r_arr: [G; OUT_761] = { let __args: [G; IN_761] = [__v_26]; let __cu = unconstrained; if let Some(result) = record.function_queries[761].get_mut(&__args[..]) { if !__cu && *result.multiplicity == G::ZERO { aiur_fn_761(__args, record, io_buffer, false)? } else { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_761] = unsafe { *(result.output.as_ptr() as *const [G; OUT_761]) }; __ret } } else { aiur_fn_761(__args, record, io_buffer, __cu)? } }; let __v_46: G = __r_arr[0]; let __v_47: G = __r_arr[1]; let __v_48: G = __r_arr[2]; @@ -10711,7 +10711,7 @@ fn aiur_fn_68( stacker::maybe_grow(64 * 1024, 4 * 1024 * 1024, || { let __v_0: G = inp[0]; let __v_1: G = inp[1]; - let __r_arr: [G; OUT_760] = { let __args: [G; IN_760] = [__v_0]; let __cu = unconstrained; if let Some(result) = record.function_queries[760].get_mut(&__args[..]) { if !__cu && *result.multiplicity == G::ZERO { aiur_fn_760(__args, record, io_buffer, false)? } else { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_760] = unsafe { *(result.output.as_ptr() as *const [G; OUT_760]) }; __ret } } else { aiur_fn_760(__args, record, io_buffer, __cu)? } }; + let __r_arr: [G; OUT_756] = { let __args: [G; IN_756] = [__v_0]; let __cu = unconstrained; if let Some(result) = record.function_queries[756].get_mut(&__args[..]) { if !__cu && *result.multiplicity == G::ZERO { aiur_fn_756(__args, record, io_buffer, false)? } else { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_756] = unsafe { *(result.output.as_ptr() as *const [G; OUT_756]) }; __ret } } else { aiur_fn_756(__args, record, io_buffer, __cu)? } }; let __v_2: G = __r_arr[0]; let __v_3: G = __r_arr[1]; let __v_4: G = __r_arr[2]; @@ -10742,7 +10742,7 @@ fn aiur_fn_69( stacker::maybe_grow(64 * 1024, 4 * 1024 * 1024, || { let __v_0: G = inp[0]; let __v_1: G = inp[1]; - let __r_arr: [G; OUT_760] = { let __args: [G; IN_760] = [__v_0]; let __cu = unconstrained; if let Some(result) = record.function_queries[760].get_mut(&__args[..]) { if !__cu && *result.multiplicity == G::ZERO { aiur_fn_760(__args, record, io_buffer, false)? } else { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_760] = unsafe { *(result.output.as_ptr() as *const [G; OUT_760]) }; __ret } } else { aiur_fn_760(__args, record, io_buffer, __cu)? } }; + let __r_arr: [G; OUT_756] = { let __args: [G; IN_756] = [__v_0]; let __cu = unconstrained; if let Some(result) = record.function_queries[756].get_mut(&__args[..]) { if !__cu && *result.multiplicity == G::ZERO { aiur_fn_756(__args, record, io_buffer, false)? } else { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_756] = unsafe { *(result.output.as_ptr() as *const [G; OUT_756]) }; __ret } } else { aiur_fn_756(__args, record, io_buffer, __cu)? } }; let __v_2: G = __r_arr[0]; let __v_3: G = __r_arr[1]; let __v_4: G = __r_arr[2]; @@ -10773,7 +10773,7 @@ fn aiur_fn_70( stacker::maybe_grow(64 * 1024, 4 * 1024 * 1024, || { let __v_0: G = inp[0]; let __v_1: G = inp[1]; - let __r_arr: [G; OUT_760] = { let __args: [G; IN_760] = [__v_0]; let __cu = unconstrained; if let Some(result) = record.function_queries[760].get_mut(&__args[..]) { if !__cu && *result.multiplicity == G::ZERO { aiur_fn_760(__args, record, io_buffer, false)? } else { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_760] = unsafe { *(result.output.as_ptr() as *const [G; OUT_760]) }; __ret } } else { aiur_fn_760(__args, record, io_buffer, __cu)? } }; + let __r_arr: [G; OUT_756] = { let __args: [G; IN_756] = [__v_0]; let __cu = unconstrained; if let Some(result) = record.function_queries[756].get_mut(&__args[..]) { if !__cu && *result.multiplicity == G::ZERO { aiur_fn_756(__args, record, io_buffer, false)? } else { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_756] = unsafe { *(result.output.as_ptr() as *const [G; OUT_756]) }; __ret } } else { aiur_fn_756(__args, record, io_buffer, __cu)? } }; let __v_2: G = __r_arr[0]; let __v_3: G = __r_arr[1]; let __v_4: G = __r_arr[2]; @@ -10861,7 +10861,7 @@ fn aiur_fn_71( let __v_51: G = __r_arr[0]; match __v_0.as_canonical_u64() { 8u64 => { - let __r_arr: [G; OUT_769] = { let __args: [G; IN_769] = [__v_1]; let __cu = unconstrained; if let Some(result) = record.function_queries[769].get_mut(&__args[..]) { if !__cu && *result.multiplicity == G::ZERO { aiur_fn_769(__args, record, io_buffer, false)? } else { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_769] = unsafe { *(result.output.as_ptr() as *const [G; OUT_769]) }; __ret } } else { aiur_fn_769(__args, record, io_buffer, __cu)? } }; + let __r_arr: [G; OUT_765] = { let __args: [G; IN_765] = [__v_1]; let __cu = unconstrained; if let Some(result) = record.function_queries[765].get_mut(&__args[..]) { if !__cu && *result.multiplicity == G::ZERO { aiur_fn_765(__args, record, io_buffer, false)? } else { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_765] = unsafe { *(result.output.as_ptr() as *const [G; OUT_765]) }; __ret } } else { aiur_fn_765(__args, record, io_buffer, __cu)? } }; let __v_52: G = __r_arr[0]; let __v_53: G = __r_arr[1]; let __v_54: G = __r_arr[2]; @@ -14207,7 +14207,7 @@ fn aiur_fn_111( let __r_arr: [G; OUT_111] = { let __args: [G; IN_111] = [__v_2]; let __cu = unconstrained; if let Some(result) = record.function_queries[111].get_mut(&__args[..]) { if !__cu && *result.multiplicity == G::ZERO { aiur_fn_111(__args, record, io_buffer, false)? } else { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_111] = unsafe { *(result.output.as_ptr() as *const [G; OUT_111]) }; __ret } } else { aiur_fn_111(__args, record, io_buffer, __cu)? } }; let __v_5: G = __r_arr[0]; let __v_6: G = __r_arr[1]; - let __r_arr: [G; OUT_757] = { let __args: [G; IN_757] = [__v_6, __v_3]; let __cu = unconstrained; if let Some(result) = record.function_queries[757].get_mut(&__args[..]) { if !__cu && *result.multiplicity == G::ZERO { aiur_fn_757(__args, record, io_buffer, false)? } else { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_757] = unsafe { *(result.output.as_ptr() as *const [G; OUT_757]) }; __ret } } else { aiur_fn_757(__args, record, io_buffer, __cu)? } }; + let __r_arr: [G; OUT_753] = { let __args: [G; IN_753] = [__v_6, __v_3]; let __cu = unconstrained; if let Some(result) = record.function_queries[753].get_mut(&__args[..]) { if !__cu && *result.multiplicity == G::ZERO { aiur_fn_753(__args, record, io_buffer, false)? } else { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_753] = unsafe { *(result.output.as_ptr() as *const [G; OUT_753]) }; __ret } } else { aiur_fn_753(__args, record, io_buffer, __cu)? } }; let __v_7: G = __r_arr[0]; let __ret: [G; OUT_111] = [__v_5, __v_7]; if let Some(result) = record.function_queries[111].get_mut(&inp[..]) { debug_assert_eq!(result.output, &__ret[..]); if !unconstrained { *result.multiplicity += G::ONE; } } else { record.function_queries[111].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained)); }; @@ -15657,7 +15657,7 @@ fn aiur_fn_127( return Ok(__ret); }, 0u64 => { - let __r_arr: [G; OUT_778] = { let __args: [G; IN_778] = [__v_17, __v_9, __v_10, __v_11, __v_12, __v_13, __v_14, __v_15, __v_16]; let __cu = unconstrained; if let Some(result) = record.function_queries[778].get_mut(&__args[..]) { if !__cu && *result.multiplicity == G::ZERO { aiur_fn_778(__args, record, io_buffer, false)? } else { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_778] = unsafe { *(result.output.as_ptr() as *const [G; OUT_778]) }; __ret } } else { aiur_fn_778(__args, record, io_buffer, __cu)? } }; + let __r_arr: [G; OUT_774] = { let __args: [G; IN_774] = [__v_17, __v_9, __v_10, __v_11, __v_12, __v_13, __v_14, __v_15, __v_16]; let __cu = unconstrained; if let Some(result) = record.function_queries[774].get_mut(&__args[..]) { if !__cu && *result.multiplicity == G::ZERO { aiur_fn_774(__args, record, io_buffer, false)? } else { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_774] = unsafe { *(result.output.as_ptr() as *const [G; OUT_774]) }; __ret } } else { aiur_fn_774(__args, record, io_buffer, __cu)? } }; let __v_29: G = __r_arr[0]; let __ret: [G; OUT_127] = [__v_29]; if let Some(result) = record.function_queries[127].get_mut(&inp[..]) { debug_assert_eq!(result.output, &__ret[..]); if !unconstrained { *result.multiplicity += G::ONE; } } else { record.function_queries[127].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained)); }; @@ -15713,7 +15713,7 @@ fn aiur_fn_127( let __v_66: G = __r_arr[6]; let __v_67: G = __r_arr[7]; let __v_68: G = __r_arr[8]; - let __r_arr: [G; OUT_778] = { let __args: [G; IN_778] = [__v_17, __v_44, __v_45, __v_46, __v_47, __v_48, __v_49, __v_50, __v_51]; let __cu = unconstrained; if let Some(result) = record.function_queries[778].get_mut(&__args[..]) { if !__cu && *result.multiplicity == G::ZERO { aiur_fn_778(__args, record, io_buffer, false)? } else { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_778] = unsafe { *(result.output.as_ptr() as *const [G; OUT_778]) }; __ret } } else { aiur_fn_778(__args, record, io_buffer, __cu)? } }; + let __r_arr: [G; OUT_774] = { let __args: [G; IN_774] = [__v_17, __v_44, __v_45, __v_46, __v_47, __v_48, __v_49, __v_50, __v_51]; let __cu = unconstrained; if let Some(result) = record.function_queries[774].get_mut(&__args[..]) { if !__cu && *result.multiplicity == G::ZERO { aiur_fn_774(__args, record, io_buffer, false)? } else { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_774] = unsafe { *(result.output.as_ptr() as *const [G; OUT_774]) }; __ret } } else { aiur_fn_774(__args, record, io_buffer, __cu)? } }; let __v_69: G = __r_arr[0]; let __r_arr: [G; OUT_127] = { let __args: [G; IN_127] = [__v_0, __v_1, __v_2, __v_3, __v_4, __v_5, __v_6, __v_7, __v_27, __v_60, __v_61, __v_62, __v_63, __v_64, __v_65, __v_66, __v_67, __v_69]; let __cu = unconstrained; if let Some(result) = record.function_queries[127].get_mut(&__args[..]) { if !__cu && *result.multiplicity == G::ZERO { aiur_fn_127(__args, record, io_buffer, false)? } else { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_127] = unsafe { *(result.output.as_ptr() as *const [G; OUT_127]) }; __ret } } else { aiur_fn_127(__args, record, io_buffer, __cu)? } }; let __v_70: G = __r_arr[0]; @@ -18281,8 +18281,8 @@ fn aiur_fn_179( }) } -const INPUT_SIZE_180: usize = 0; -const IN_180: usize = 0; +const INPUT_SIZE_180: usize = 1; +const IN_180: usize = 1; const OUT_180: usize = 1; fn aiur_fn_180( inp: [G; IN_180], @@ -18290,153 +18290,6 @@ fn aiur_fn_180( io_buffer: &mut IOBuffer, unconstrained: bool, ) -> Result<[G; OUT_180], ExecError> { - stacker::maybe_grow(64 * 1024, 4 * 1024 * 1024, || { - let __v_0: G = G::from_u64(163); - let __v_1: G = G::from_u64(67); - let __v_2: G = G::from_u64(166); - let __v_3: G = G::from_u64(81); - let __v_4: G = G::from_u64(191); - let __v_5: G = G::from_u64(244); - let __v_6: G = G::from_u64(8); - let __v_7: G = G::from_u64(195); - let __v_8: G = G::from_u64(162); - let __v_9: G = G::from_u64(159); - let __v_10: G = G::from_u64(242); - let __v_11: G = G::from_u64(123); - let __v_12: G = G::from_u64(43); - let __v_13: G = G::from_u64(98); - let __v_14: G = G::from_u64(227); - let __v_15: G = G::from_u64(75); - let __v_16: G = G::from_u64(84); - let __v_17: G = G::from_u64(178); - let __v_18: G = G::from_u64(171); - let __v_19: G = G::from_u64(56); - let __v_20: G = G::from_u64(28); - let __v_21: G = G::from_u64(246); - let __v_22: G = G::from_u64(243); - let __v_23: G = G::from_u64(173); - let __v_24: G = G::from_u64(135); - let __v_25: G = G::from_u64(197); - let __v_26: G = G::from_u64(64); - let __v_27: G = G::from_u64(201); - let __v_28: G = G::from_u64(119); - let __v_29: G = G::from_u64(220); - let __v_30: G = G::from_u64(60); - let __v_31: G = G::from_u64(74); - let __v_32: G = { let __values: [G; 32] = [__v_0, __v_1, __v_2, __v_3, __v_4, __v_5, __v_6, __v_7, __v_8, __v_9, __v_10, __v_11, __v_12, __v_13, __v_14, __v_15, __v_16, __v_17, __v_18, __v_19, __v_20, __v_21, __v_22, __v_23, __v_24, __v_25, __v_26, __v_27, __v_28, __v_29, __v_30, __v_31]; let __mq = record.memory_queries.get_mut(&32).ok_or(ExecError::InvalidMemorySize(32))?; if let Some(result) = __mq.get_mut(&__values[..]) { if !unconstrained { *result.multiplicity += G::ONE; } result.output[0] } else { let __ptr = G::from_usize(__mq.len()); __mq.insert(&__values[..], &[__ptr], G::from_bool(!unconstrained)); __ptr } }; - let __ret: [G; OUT_180] = [__v_32]; - if let Some(result) = record.function_queries[180].get_mut(&inp[..]) { debug_assert_eq!(result.output, &__ret[..]); if !unconstrained { *result.multiplicity += G::ONE; } } else { record.function_queries[180].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained)); }; - return Ok(__ret); - }) -} - -const INPUT_SIZE_181: usize = 0; -const IN_181: usize = 0; -const OUT_181: usize = 1; -fn aiur_fn_181( - inp: [G; IN_181], - record: &mut QueryRecord, - io_buffer: &mut IOBuffer, - unconstrained: bool, -) -> Result<[G; OUT_181], ExecError> { - stacker::maybe_grow(64 * 1024, 4 * 1024 * 1024, || { - let __v_0: G = G::from_u64(45); - let __v_1: G = G::from_u64(252); - let __v_2: G = G::from_u64(22); - let __v_3: G = G::from_u64(175); - let __v_4: G = G::from_u64(1); - let __v_5: G = G::from_u64(184); - let __v_6: G = G::from_u64(43); - let __v_7: G = G::from_u64(59); - let __v_8: G = G::from_u64(145); - let __v_9: G = G::from_u64(194); - let __v_10: G = G::from_u64(255); - let __v_11: G = G::from_u64(112); - let __v_12: G = G::from_u64(68); - let __v_13: G = G::from_u64(9); - let __v_14: G = G::from_u64(215); - let __v_15: G = G::from_u64(98); - let __v_16: G = G::from_u64(54); - let __v_17: G = G::from_u64(168); - let __v_18: G = G::from_u64(63); - let __v_19: G = G::from_u64(149); - let __v_20: G = G::from_u64(108); - let __v_21: G = G::from_u64(12); - let __v_22: G = G::from_u64(110); - let __v_23: G = G::from_u64(102); - let __v_24: G = G::from_u64(89); - let __v_25: G = G::from_u64(166); - let __v_26: G = G::from_u64(79); - let __v_27: G = G::from_u64(226); - let __v_28: G = G::from_u64(29); - let __v_29: G = G::from_u64(118); - let __v_30: G = G::from_u64(105); - let __v_31: G = G::from_u64(91); - let __v_32: G = { let __values: [G; 32] = [__v_0, __v_1, __v_2, __v_3, __v_4, __v_5, __v_6, __v_7, __v_8, __v_9, __v_10, __v_11, __v_12, __v_13, __v_14, __v_15, __v_16, __v_17, __v_18, __v_19, __v_20, __v_21, __v_22, __v_23, __v_24, __v_25, __v_26, __v_27, __v_28, __v_29, __v_30, __v_31]; let __mq = record.memory_queries.get_mut(&32).ok_or(ExecError::InvalidMemorySize(32))?; if let Some(result) = __mq.get_mut(&__values[..]) { if !unconstrained { *result.multiplicity += G::ONE; } result.output[0] } else { let __ptr = G::from_usize(__mq.len()); __mq.insert(&__values[..], &[__ptr], G::from_bool(!unconstrained)); __ptr } }; - let __ret: [G; OUT_181] = [__v_32]; - if let Some(result) = record.function_queries[181].get_mut(&inp[..]) { debug_assert_eq!(result.output, &__ret[..]); if !unconstrained { *result.multiplicity += G::ONE; } } else { record.function_queries[181].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained)); }; - return Ok(__ret); - }) -} - -const INPUT_SIZE_182: usize = 0; -const IN_182: usize = 0; -const OUT_182: usize = 1; -fn aiur_fn_182( - inp: [G; IN_182], - record: &mut QueryRecord, - io_buffer: &mut IOBuffer, - unconstrained: bool, -) -> Result<[G; OUT_182], ExecError> { - stacker::maybe_grow(64 * 1024, 4 * 1024 * 1024, || { - let __v_0: G = G::from_u64(146); - let __v_1: G = G::from_u64(50); - let __v_2: G = G::from_u64(73); - let __v_3: G = G::from_u64(134); - let __v_4: G = G::from_u64(103); - let __v_5: G = G::from_u64(247); - let __v_6: G = G::from_u64(101); - let __v_7: G = G::from_u64(244); - let __v_8: G = G::from_u64(55); - let __v_9: G = G::from_u64(222); - let __v_10: G = G::from_u64(218); - let __v_11: G = G::from_u64(172); - let __v_12: G = G::from_u64(130); - let __v_13: G = G::from_u64(142); - let __v_14: G = G::from_u64(85); - let __v_15: G = G::from_u64(95); - let __v_16: G = G::from_u64(108); - let __v_17: G = G::from_u64(198); - let __v_18: G = G::from_u64(122); - let __v_19: G = G::from_u64(32); - let __v_20: G = G::from_u64(230); - let __v_21: G = G::from_u64(219); - let __v_22: G = G::from_u64(40); - let __v_23: G = G::from_u64(246); - let __v_24: G = G::from_u64(20); - let __v_25: G = G::from_u64(253); - let __v_26: G = G::from_u64(243); - let __v_27: G = G::from_u64(194); - let __v_28: G = G::from_u64(98); - let __v_29: G = G::from_u64(113); - let __v_30: G = G::from_u64(15); - let __v_31: G = G::from_u64(235); - let __v_32: G = { let __values: [G; 32] = [__v_0, __v_1, __v_2, __v_3, __v_4, __v_5, __v_6, __v_7, __v_8, __v_9, __v_10, __v_11, __v_12, __v_13, __v_14, __v_15, __v_16, __v_17, __v_18, __v_19, __v_20, __v_21, __v_22, __v_23, __v_24, __v_25, __v_26, __v_27, __v_28, __v_29, __v_30, __v_31]; let __mq = record.memory_queries.get_mut(&32).ok_or(ExecError::InvalidMemorySize(32))?; if let Some(result) = __mq.get_mut(&__values[..]) { if !unconstrained { *result.multiplicity += G::ONE; } result.output[0] } else { let __ptr = G::from_usize(__mq.len()); __mq.insert(&__values[..], &[__ptr], G::from_bool(!unconstrained)); __ptr } }; - let __ret: [G; OUT_182] = [__v_32]; - if let Some(result) = record.function_queries[182].get_mut(&inp[..]) { debug_assert_eq!(result.output, &__ret[..]); if !unconstrained { *result.multiplicity += G::ONE; } } else { record.function_queries[182].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained)); }; - return Ok(__ret); - }) -} - -const INPUT_SIZE_183: usize = 1; -const IN_183: usize = 1; -const OUT_183: usize = 1; -fn aiur_fn_183( - inp: [G; IN_183], - record: &mut QueryRecord, - io_buffer: &mut IOBuffer, - unconstrained: bool, -) -> Result<[G; OUT_183], ExecError> { stacker::maybe_grow(64 * 1024, 4 * 1024 * 1024, || { let __v_0: G = inp[0]; let __r_arr: [G; OUT_174] = { let __args: [G; IN_174] = []; let __cu = unconstrained; if let Some(result) = record.function_queries[174].get_mut(&__args[..]) { if !__cu && *result.multiplicity == G::ZERO { aiur_fn_174(__args, record, io_buffer, false)? } else { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_174] = unsafe { *(result.output.as_ptr() as *const [G; OUT_174]) }; __ret } } else { aiur_fn_174(__args, record, io_buffer, __cu)? } }; @@ -18446,8 +18299,8 @@ fn aiur_fn_183( match __v_2.as_canonical_u64() { 1u64 => { let __v_3: G = G::from_u64(1); - let __ret: [G; OUT_183] = [__v_3]; - if let Some(result) = record.function_queries[183].get_mut(&inp[..]) { debug_assert_eq!(result.output, &__ret[..]); if !unconstrained { *result.multiplicity += G::ONE; } } else { record.function_queries[183].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained)); }; + let __ret: [G; OUT_180] = [__v_3]; + if let Some(result) = record.function_queries[180].get_mut(&inp[..]) { debug_assert_eq!(result.output, &__ret[..]); if !unconstrained { *result.multiplicity += G::ONE; } } else { record.function_queries[180].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained)); }; return Ok(__ret); }, _ => { @@ -18458,8 +18311,8 @@ fn aiur_fn_183( match __v_4.as_canonical_u64() { 1u64 => { let __v_5: G = G::from_u64(1); - let __ret: [G; OUT_183] = [__v_5]; - if let Some(result) = record.function_queries[183].get_mut(&inp[..]) { debug_assert_eq!(result.output, &__ret[..]); if !unconstrained { *result.multiplicity += G::ONE; } } else { record.function_queries[183].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained)); }; + let __ret: [G; OUT_180] = [__v_5]; + if let Some(result) = record.function_queries[180].get_mut(&inp[..]) { debug_assert_eq!(result.output, &__ret[..]); if !unconstrained { *result.multiplicity += G::ONE; } } else { record.function_queries[180].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained)); }; return Ok(__ret); }, _ => { @@ -18470,8 +18323,8 @@ fn aiur_fn_183( match __v_6.as_canonical_u64() { 1u64 => { let __v_7: G = G::from_u64(1); - let __ret: [G; OUT_183] = [__v_7]; - if let Some(result) = record.function_queries[183].get_mut(&inp[..]) { debug_assert_eq!(result.output, &__ret[..]); if !unconstrained { *result.multiplicity += G::ONE; } } else { record.function_queries[183].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained)); }; + let __ret: [G; OUT_180] = [__v_7]; + if let Some(result) = record.function_queries[180].get_mut(&inp[..]) { debug_assert_eq!(result.output, &__ret[..]); if !unconstrained { *result.multiplicity += G::ONE; } } else { record.function_queries[180].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained)); }; return Ok(__ret); }, _ => { @@ -18482,8 +18335,8 @@ fn aiur_fn_183( match __v_8.as_canonical_u64() { 1u64 => { let __v_9: G = G::from_u64(1); - let __ret: [G; OUT_183] = [__v_9]; - if let Some(result) = record.function_queries[183].get_mut(&inp[..]) { debug_assert_eq!(result.output, &__ret[..]); if !unconstrained { *result.multiplicity += G::ONE; } } else { record.function_queries[183].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained)); }; + let __ret: [G; OUT_180] = [__v_9]; + if let Some(result) = record.function_queries[180].get_mut(&inp[..]) { debug_assert_eq!(result.output, &__ret[..]); if !unconstrained { *result.multiplicity += G::ONE; } } else { record.function_queries[180].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained)); }; return Ok(__ret); }, _ => { @@ -18494,29 +18347,15 @@ fn aiur_fn_183( match __v_10.as_canonical_u64() { 1u64 => { let __v_11: G = G::from_u64(1); - let __ret: [G; OUT_183] = [__v_11]; - if let Some(result) = record.function_queries[183].get_mut(&inp[..]) { debug_assert_eq!(result.output, &__ret[..]); if !unconstrained { *result.multiplicity += G::ONE; } } else { record.function_queries[183].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained)); }; + let __ret: [G; OUT_180] = [__v_11]; + if let Some(result) = record.function_queries[180].get_mut(&inp[..]) { debug_assert_eq!(result.output, &__ret[..]); if !unconstrained { *result.multiplicity += G::ONE; } } else { record.function_queries[180].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained)); }; return Ok(__ret); }, _ => { - let __r_arr: [G; OUT_180] = { let __args: [G; IN_180] = []; let __cu = unconstrained; if let Some(result) = record.function_queries[180].get_mut(&__args[..]) { if !__cu && *result.multiplicity == G::ZERO { aiur_fn_180(__args, record, io_buffer, false)? } else { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_180] = unsafe { *(result.output.as_ptr() as *const [G; OUT_180]) }; __ret } } else { aiur_fn_180(__args, record, io_buffer, __cu)? } }; - let __v_11: G = __r_arr[0]; - let __r_arr: [G; OUT_1] = { let __args: [G; IN_1] = [__v_0, __v_11]; let __cu = unconstrained; if let Some(result) = record.function_queries[1].get_mut(&__args[..]) { if !__cu && *result.multiplicity == G::ZERO { aiur_fn_1(__args, record, io_buffer, false)? } else { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_1] = unsafe { *(result.output.as_ptr() as *const [G; OUT_1]) }; __ret } } else { aiur_fn_1(__args, record, io_buffer, __cu)? } }; - let __v_12: G = __r_arr[0]; - match __v_12.as_canonical_u64() { - 1u64 => { - let __v_13: G = G::from_u64(1); - let __ret: [G; OUT_183] = [__v_13]; - if let Some(result) = record.function_queries[183].get_mut(&inp[..]) { debug_assert_eq!(result.output, &__ret[..]); if !unconstrained { *result.multiplicity += G::ONE; } } else { record.function_queries[183].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained)); }; - return Ok(__ret); - }, - _ => { - let __v_13: G = G::from_u64(0); - let __ret: [G; OUT_183] = [__v_13]; - if let Some(result) = record.function_queries[183].get_mut(&inp[..]) { debug_assert_eq!(result.output, &__ret[..]); if !unconstrained { *result.multiplicity += G::ONE; } } else { record.function_queries[183].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained)); }; - return Ok(__ret); - }, - } + let __v_11: G = G::from_u64(0); + let __ret: [G; OUT_180] = [__v_11]; + if let Some(result) = record.function_queries[180].get_mut(&inp[..]) { debug_assert_eq!(result.output, &__ret[..]); if !unconstrained { *result.multiplicity += G::ONE; } } else { record.function_queries[180].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained)); }; + return Ok(__ret); }, } }, @@ -18530,15 +18369,15 @@ fn aiur_fn_183( }) } -const INPUT_SIZE_184: usize = 0; -const IN_184: usize = 0; -const OUT_184: usize = 1; -fn aiur_fn_184( - inp: [G; IN_184], +const INPUT_SIZE_181: usize = 0; +const IN_181: usize = 0; +const OUT_181: usize = 1; +fn aiur_fn_181( + inp: [G; IN_181], record: &mut QueryRecord, io_buffer: &mut IOBuffer, unconstrained: bool, -) -> Result<[G; OUT_184], ExecError> { +) -> Result<[G; OUT_181], ExecError> { stacker::maybe_grow(64 * 1024, 4 * 1024 * 1024, || { let __v_0: G = G::from_u64(0); let __v_1: G = G::from_u64(64); @@ -18557,21 +18396,21 @@ fn aiur_fn_184( let __v_14: G = G::from_u64(0); let __v_15: G = G::from_u64(0); let __v_16: G = { let __values: [G; 4] = [__v_13, __v_14, __v_12, __v_15]; let __mq = record.memory_queries.get_mut(&4).ok_or(ExecError::InvalidMemorySize(4))?; if let Some(result) = __mq.get_mut(&__values[..]) { if !unconstrained { *result.multiplicity += G::ONE; } result.output[0] } else { let __ptr = G::from_usize(__mq.len()); __mq.insert(&__values[..], &[__ptr], G::from_bool(!unconstrained)); __ptr } }; - let __ret: [G; OUT_184] = [__v_16]; - if let Some(result) = record.function_queries[184].get_mut(&inp[..]) { debug_assert_eq!(result.output, &__ret[..]); if !unconstrained { *result.multiplicity += G::ONE; } } else { record.function_queries[184].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained)); }; + let __ret: [G; OUT_181] = [__v_16]; + if let Some(result) = record.function_queries[181].get_mut(&inp[..]) { debug_assert_eq!(result.output, &__ret[..]); if !unconstrained { *result.multiplicity += G::ONE; } } else { record.function_queries[181].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained)); }; return Ok(__ret); }) } -const INPUT_SIZE_185: usize = 0; -const IN_185: usize = 0; -const OUT_185: usize = 1; -fn aiur_fn_185( - inp: [G; IN_185], +const INPUT_SIZE_182: usize = 0; +const IN_182: usize = 0; +const OUT_182: usize = 1; +fn aiur_fn_182( + inp: [G; IN_182], record: &mut QueryRecord, io_buffer: &mut IOBuffer, unconstrained: bool, -) -> Result<[G; OUT_185], ExecError> { +) -> Result<[G; OUT_182], ExecError> { stacker::maybe_grow(64 * 1024, 4 * 1024 * 1024, || { let __v_0: G = G::from_u64(0); let __v_1: G = G::from_u64(1); @@ -18590,21 +18429,21 @@ fn aiur_fn_185( let __v_14: G = G::from_u64(0); let __v_15: G = G::from_u64(0); let __v_16: G = { let __values: [G; 4] = [__v_13, __v_14, __v_12, __v_15]; let __mq = record.memory_queries.get_mut(&4).ok_or(ExecError::InvalidMemorySize(4))?; if let Some(result) = __mq.get_mut(&__values[..]) { if !unconstrained { *result.multiplicity += G::ONE; } result.output[0] } else { let __ptr = G::from_usize(__mq.len()); __mq.insert(&__values[..], &[__ptr], G::from_bool(!unconstrained)); __ptr } }; - let __ret: [G; OUT_185] = [__v_16]; - if let Some(result) = record.function_queries[185].get_mut(&inp[..]) { debug_assert_eq!(result.output, &__ret[..]); if !unconstrained { *result.multiplicity += G::ONE; } } else { record.function_queries[185].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained)); }; + let __ret: [G; OUT_182] = [__v_16]; + if let Some(result) = record.function_queries[182].get_mut(&inp[..]) { debug_assert_eq!(result.output, &__ret[..]); if !unconstrained { *result.multiplicity += G::ONE; } } else { record.function_queries[182].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained)); }; return Ok(__ret); }) } -const INPUT_SIZE_186: usize = 3; -const IN_186: usize = 3; -const OUT_186: usize = 2; -fn aiur_fn_186( - inp: [G; IN_186], +const INPUT_SIZE_183: usize = 3; +const IN_183: usize = 3; +const OUT_183: usize = 2; +fn aiur_fn_183( + inp: [G; IN_183], record: &mut QueryRecord, io_buffer: &mut IOBuffer, unconstrained: bool, -) -> Result<[G; OUT_186], ExecError> { +) -> Result<[G; OUT_183], ExecError> { stacker::maybe_grow(64 * 1024, 4 * 1024 * 1024, || { let __v_0: G = inp[0]; let __v_1: G = inp[1]; @@ -18616,10 +18455,10 @@ fn aiur_fn_186( match __v_4.as_canonical_u64() { 1u64 => { let __v_5: G = G::from_u64(1); - let __r_arr: [G; OUT_184] = { let __args: [G; IN_184] = []; let __cu = unconstrained; if let Some(result) = record.function_queries[184].get_mut(&__args[..]) { if !__cu && *result.multiplicity == G::ZERO { aiur_fn_184(__args, record, io_buffer, false)? } else { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_184] = unsafe { *(result.output.as_ptr() as *const [G; OUT_184]) }; __ret } } else { aiur_fn_184(__args, record, io_buffer, __cu)? } }; + let __r_arr: [G; OUT_181] = { let __args: [G; IN_181] = []; let __cu = unconstrained; if let Some(result) = record.function_queries[181].get_mut(&__args[..]) { if !__cu && *result.multiplicity == G::ZERO { aiur_fn_181(__args, record, io_buffer, false)? } else { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_181] = unsafe { *(result.output.as_ptr() as *const [G; OUT_181]) }; __ret } } else { aiur_fn_181(__args, record, io_buffer, __cu)? } }; let __v_6: G = __r_arr[0]; - let __ret: [G; OUT_186] = [__v_5, __v_6]; - if let Some(result) = record.function_queries[186].get_mut(&inp[..]) { debug_assert_eq!(result.output, &__ret[..]); if !unconstrained { *result.multiplicity += G::ONE; } } else { record.function_queries[186].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained)); }; + let __ret: [G; OUT_183] = [__v_5, __v_6]; + if let Some(result) = record.function_queries[183].get_mut(&inp[..]) { debug_assert_eq!(result.output, &__ret[..]); if !unconstrained { *result.multiplicity += G::ONE; } } else { record.function_queries[183].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained)); }; return Ok(__ret); }, _ => { @@ -18630,10 +18469,10 @@ fn aiur_fn_186( match __v_6.as_canonical_u64() { 1u64 => { let __v_7: G = G::from_u64(1); - let __r_arr: [G; OUT_185] = { let __args: [G; IN_185] = []; let __cu = unconstrained; if let Some(result) = record.function_queries[185].get_mut(&__args[..]) { if !__cu && *result.multiplicity == G::ZERO { aiur_fn_185(__args, record, io_buffer, false)? } else { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_185] = unsafe { *(result.output.as_ptr() as *const [G; OUT_185]) }; __ret } } else { aiur_fn_185(__args, record, io_buffer, __cu)? } }; + let __r_arr: [G; OUT_182] = { let __args: [G; IN_182] = []; let __cu = unconstrained; if let Some(result) = record.function_queries[182].get_mut(&__args[..]) { if !__cu && *result.multiplicity == G::ZERO { aiur_fn_182(__args, record, io_buffer, false)? } else { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_182] = unsafe { *(result.output.as_ptr() as *const [G; OUT_182]) }; __ret } } else { aiur_fn_182(__args, record, io_buffer, __cu)? } }; let __v_8: G = __r_arr[0]; - let __ret: [G; OUT_186] = [__v_7, __v_8]; - if let Some(result) = record.function_queries[186].get_mut(&inp[..]) { debug_assert_eq!(result.output, &__ret[..]); if !unconstrained { *result.multiplicity += G::ONE; } } else { record.function_queries[186].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained)); }; + let __ret: [G; OUT_183] = [__v_7, __v_8]; + if let Some(result) = record.function_queries[183].get_mut(&inp[..]) { debug_assert_eq!(result.output, &__ret[..]); if !unconstrained { *result.multiplicity += G::ONE; } } else { record.function_queries[183].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained)); }; return Ok(__ret); }, _ => { @@ -18643,88 +18482,72 @@ fn aiur_fn_186( let __v_8: G = __r_arr[0]; match __v_8.as_canonical_u64() { 1u64 => { - let __r_arr: [G; OUT_187] = { let __args: [G; IN_187] = [__v_1]; let __cu = unconstrained; if let Some(result) = record.function_queries[187].get_mut(&__args[..]) { if !__cu && *result.multiplicity == G::ZERO { aiur_fn_187(__args, record, io_buffer, false)? } else { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_187] = unsafe { *(result.output.as_ptr() as *const [G; OUT_187]) }; __ret } } else { aiur_fn_187(__args, record, io_buffer, __cu)? } }; + let __r_arr: [G; OUT_184] = { let __args: [G; IN_184] = [__v_1]; let __cu = unconstrained; if let Some(result) = record.function_queries[184].get_mut(&__args[..]) { if !__cu && *result.multiplicity == G::ZERO { aiur_fn_184(__args, record, io_buffer, false)? } else { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_184] = unsafe { *(result.output.as_ptr() as *const [G; OUT_184]) }; __ret } } else { aiur_fn_184(__args, record, io_buffer, __cu)? } }; let __v_9: G = __r_arr[0]; let __v_10: G = __r_arr[1]; - let __ret: [G; OUT_186] = [__v_9, __v_10]; - if let Some(result) = record.function_queries[186].get_mut(&inp[..]) { debug_assert_eq!(result.output, &__ret[..]); if !unconstrained { *result.multiplicity += G::ONE; } } else { record.function_queries[186].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained)); }; + let __ret: [G; OUT_183] = [__v_9, __v_10]; + if let Some(result) = record.function_queries[183].get_mut(&inp[..]) { debug_assert_eq!(result.output, &__ret[..]); if !unconstrained { *result.multiplicity += G::ONE; } } else { record.function_queries[183].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained)); }; return Ok(__ret); }, _ => { - let __r_arr: [G; OUT_180] = { let __args: [G; IN_180] = []; let __cu = unconstrained; if let Some(result) = record.function_queries[180].get_mut(&__args[..]) { if !__cu && *result.multiplicity == G::ZERO { aiur_fn_180(__args, record, io_buffer, false)? } else { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_180] = unsafe { *(result.output.as_ptr() as *const [G; OUT_180]) }; __ret } } else { aiur_fn_180(__args, record, io_buffer, __cu)? } }; + let __r_arr: [G; OUT_176] = { let __args: [G; IN_176] = []; let __cu = unconstrained; if let Some(result) = record.function_queries[176].get_mut(&__args[..]) { if !__cu && *result.multiplicity == G::ZERO { aiur_fn_176(__args, record, io_buffer, false)? } else { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_176] = unsafe { *(result.output.as_ptr() as *const [G; OUT_176]) }; __ret } } else { aiur_fn_176(__args, record, io_buffer, __cu)? } }; let __v_9: G = __r_arr[0]; let __r_arr: [G; OUT_1] = { let __args: [G; IN_1] = [__v_0, __v_9]; let __cu = unconstrained; if let Some(result) = record.function_queries[1].get_mut(&__args[..]) { if !__cu && *result.multiplicity == G::ZERO { aiur_fn_1(__args, record, io_buffer, false)? } else { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_1] = unsafe { *(result.output.as_ptr() as *const [G; OUT_1]) }; __ret } } else { aiur_fn_1(__args, record, io_buffer, __cu)? } }; let __v_10: G = __r_arr[0]; - match __v_10.as_canonical_u64() { - 1u64 => { - let __r_arr: [G; OUT_188] = { let __args: [G; IN_188] = [__v_1]; let __cu = unconstrained; if let Some(result) = record.function_queries[188].get_mut(&__args[..]) { if !__cu && *result.multiplicity == G::ZERO { aiur_fn_188(__args, record, io_buffer, false)? } else { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_188] = unsafe { *(result.output.as_ptr() as *const [G; OUT_188]) }; __ret } } else { aiur_fn_188(__args, record, io_buffer, __cu)? } }; - let __v_11: G = __r_arr[0]; - let __v_12: G = __r_arr[1]; - let __ret: [G; OUT_186] = [__v_11, __v_12]; - if let Some(result) = record.function_queries[186].get_mut(&inp[..]) { debug_assert_eq!(result.output, &__ret[..]); if !unconstrained { *result.multiplicity += G::ONE; } } else { record.function_queries[186].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained)); }; + let __r_arr: [G; OUT_177] = { let __args: [G; IN_177] = []; let __cu = unconstrained; if let Some(result) = record.function_queries[177].get_mut(&__args[..]) { if !__cu && *result.multiplicity == G::ZERO { aiur_fn_177(__args, record, io_buffer, false)? } else { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_177] = unsafe { *(result.output.as_ptr() as *const [G; OUT_177]) }; __ret } } else { aiur_fn_177(__args, record, io_buffer, __cu)? } }; + let __v_11: G = __r_arr[0]; + let __r_arr: [G; OUT_1] = { let __args: [G; IN_1] = [__v_0, __v_11]; let __cu = unconstrained; if let Some(result) = record.function_queries[1].get_mut(&__args[..]) { if !__cu && *result.multiplicity == G::ZERO { aiur_fn_1(__args, record, io_buffer, false)? } else { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_1] = unsafe { *(result.output.as_ptr() as *const [G; OUT_1]) }; __ret } } else { aiur_fn_1(__args, record, io_buffer, __cu)? } }; + let __v_12: G = __r_arr[0]; + let __v_13: G = (__v_10 + __v_12); + match __v_13.as_canonical_u64() { + 0u64 => { + let __v_14: G = G::from_u64(0); + let __v_15: G = G::from_u64(0); + let __v_16: G = G::from_u64(0); + let __v_17: G = G::from_u64(0); + let __v_18: G = { let __values: [G; 4] = [__v_15, __v_16, __v_17, __v_17]; let __mq = record.memory_queries.get_mut(&4).ok_or(ExecError::InvalidMemorySize(4))?; if let Some(result) = __mq.get_mut(&__values[..]) { if !unconstrained { *result.multiplicity += G::ONE; } result.output[0] } else { let __ptr = G::from_usize(__mq.len()); __mq.insert(&__values[..], &[__ptr], G::from_bool(!unconstrained)); __ptr } }; + let __ret: [G; OUT_183] = [__v_14, __v_18]; + if let Some(result) = record.function_queries[183].get_mut(&inp[..]) { debug_assert_eq!(result.output, &__ret[..]); if !unconstrained { *result.multiplicity += G::ONE; } } else { record.function_queries[183].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained)); }; return Ok(__ret); }, _ => { - let __r_arr: [G; OUT_176] = { let __args: [G; IN_176] = []; let __cu = unconstrained; if let Some(result) = record.function_queries[176].get_mut(&__args[..]) { if !__cu && *result.multiplicity == G::ZERO { aiur_fn_176(__args, record, io_buffer, false)? } else { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_176] = unsafe { *(result.output.as_ptr() as *const [G; OUT_176]) }; __ret } } else { aiur_fn_176(__args, record, io_buffer, __cu)? } }; - let __v_11: G = __r_arr[0]; - let __r_arr: [G; OUT_1] = { let __args: [G; IN_1] = [__v_0, __v_11]; let __cu = unconstrained; if let Some(result) = record.function_queries[1].get_mut(&__args[..]) { if !__cu && *result.multiplicity == G::ZERO { aiur_fn_1(__args, record, io_buffer, false)? } else { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_1] = unsafe { *(result.output.as_ptr() as *const [G; OUT_1]) }; __ret } } else { aiur_fn_1(__args, record, io_buffer, __cu)? } }; - let __v_12: G = __r_arr[0]; - let __r_arr: [G; OUT_177] = { let __args: [G; IN_177] = []; let __cu = unconstrained; if let Some(result) = record.function_queries[177].get_mut(&__args[..]) { if !__cu && *result.multiplicity == G::ZERO { aiur_fn_177(__args, record, io_buffer, false)? } else { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_177] = unsafe { *(result.output.as_ptr() as *const [G; OUT_177]) }; __ret } } else { aiur_fn_177(__args, record, io_buffer, __cu)? } }; - let __v_13: G = __r_arr[0]; - let __r_arr: [G; OUT_1] = { let __args: [G; IN_1] = [__v_0, __v_13]; let __cu = unconstrained; if let Some(result) = record.function_queries[1].get_mut(&__args[..]) { if !__cu && *result.multiplicity == G::ZERO { aiur_fn_1(__args, record, io_buffer, false)? } else { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_1] = unsafe { *(result.output.as_ptr() as *const [G; OUT_1]) }; __ret } } else { aiur_fn_1(__args, record, io_buffer, __cu)? } }; + let __r_arr: [G; OUT_760] = { let __args: [G; IN_760] = [__v_1]; let __cu = unconstrained; if let Some(result) = record.function_queries[760].get_mut(&__args[..]) { if !__cu && *result.multiplicity == G::ZERO { aiur_fn_760(__args, record, io_buffer, false)? } else { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_760] = unsafe { *(result.output.as_ptr() as *const [G; OUT_760]) }; __ret } } else { aiur_fn_760(__args, record, io_buffer, __cu)? } }; let __v_14: G = __r_arr[0]; - let __v_15: G = (__v_12 + __v_14); - match __v_15.as_canonical_u64() { - 0u64 => { - let __v_16: G = G::from_u64(0); + let __v_15: G = G::from_u64(1); + let __v_16: G = { let __a_val = __v_14.as_canonical_u64(); let __b_val = __v_15.as_canonical_u64(); let __a_u32 = u32::try_from(__a_val).ok().ok_or(ExecError::U32OutOfRange(__a_val))?; let __b_u32 = u32::try_from(__b_val).ok().ok_or(ExecError::U32OutOfRange(__b_val))?; let __result = G::from_bool(__a_u32 < __b_u32); if !unconstrained { let __x_bytes = __a_u32.to_le_bytes(); let __z_bytes = __b_u32.to_le_bytes(); let __c_u32 = __b_u32.wrapping_sub(__a_u32).wrapping_sub(1); let __y_bytes = __c_u32.to_le_bytes(); record.bytes2_queries.bump_range_check(&G::from_u8(__x_bytes[0]), &G::from_u8(__x_bytes[1])); record.bytes2_queries.bump_range_check(&G::from_u8(__x_bytes[2]), &G::from_u8(__x_bytes[3])); record.bytes2_queries.bump_range_check(&G::from_u8(__y_bytes[0]), &G::from_u8(__y_bytes[1])); record.bytes2_queries.bump_range_check(&G::from_u8(__y_bytes[2]), &G::from_u8(__y_bytes[3])); record.bytes2_queries.bump_range_check(&G::from_u8(__z_bytes[0]), &G::from_u8(__z_bytes[1])); record.bytes2_queries.bump_range_check(&G::from_u8(__z_bytes[2]), &G::from_u8(__z_bytes[3])); } __result }; + match __v_16.as_canonical_u64() { + 1u64 => { let __v_17: G = G::from_u64(0); let __v_18: G = G::from_u64(0); let __v_19: G = G::from_u64(0); - let __v_20: G = { let __values: [G; 4] = [__v_17, __v_18, __v_19, __v_19]; let __mq = record.memory_queries.get_mut(&4).ok_or(ExecError::InvalidMemorySize(4))?; if let Some(result) = __mq.get_mut(&__values[..]) { if !unconstrained { *result.multiplicity += G::ONE; } result.output[0] } else { let __ptr = G::from_usize(__mq.len()); __mq.insert(&__values[..], &[__ptr], G::from_bool(!unconstrained)); __ptr } }; - let __ret: [G; OUT_186] = [__v_16, __v_20]; - if let Some(result) = record.function_queries[186].get_mut(&inp[..]) { debug_assert_eq!(result.output, &__ret[..]); if !unconstrained { *result.multiplicity += G::ONE; } } else { record.function_queries[186].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained)); }; + let __v_20: G = G::from_u64(0); + let __v_21: G = { let __values: [G; 4] = [__v_18, __v_19, __v_20, __v_20]; let __mq = record.memory_queries.get_mut(&4).ok_or(ExecError::InvalidMemorySize(4))?; if let Some(result) = __mq.get_mut(&__values[..]) { if !unconstrained { *result.multiplicity += G::ONE; } result.output[0] } else { let __ptr = G::from_usize(__mq.len()); __mq.insert(&__values[..], &[__ptr], G::from_bool(!unconstrained)); __ptr } }; + let __ret: [G; OUT_183] = [__v_17, __v_21]; + if let Some(result) = record.function_queries[183].get_mut(&inp[..]) { debug_assert_eq!(result.output, &__ret[..]); if !unconstrained { *result.multiplicity += G::ONE; } } else { record.function_queries[183].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained)); }; return Ok(__ret); }, _ => { - let __r_arr: [G; OUT_764] = { let __args: [G; IN_764] = [__v_1]; let __cu = unconstrained; if let Some(result) = record.function_queries[764].get_mut(&__args[..]) { if !__cu && *result.multiplicity == G::ZERO { aiur_fn_764(__args, record, io_buffer, false)? } else { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_764] = unsafe { *(result.output.as_ptr() as *const [G; OUT_764]) }; __ret } } else { aiur_fn_764(__args, record, io_buffer, __cu)? } }; - let __v_16: G = __r_arr[0]; - let __v_17: G = G::from_u64(1); - let __v_18: G = { let __a_val = __v_16.as_canonical_u64(); let __b_val = __v_17.as_canonical_u64(); let __a_u32 = u32::try_from(__a_val).ok().ok_or(ExecError::U32OutOfRange(__a_val))?; let __b_u32 = u32::try_from(__b_val).ok().ok_or(ExecError::U32OutOfRange(__b_val))?; let __result = G::from_bool(__a_u32 < __b_u32); if !unconstrained { let __x_bytes = __a_u32.to_le_bytes(); let __z_bytes = __b_u32.to_le_bytes(); let __c_u32 = __b_u32.wrapping_sub(__a_u32).wrapping_sub(1); let __y_bytes = __c_u32.to_le_bytes(); record.bytes2_queries.bump_range_check(&G::from_u8(__x_bytes[0]), &G::from_u8(__x_bytes[1])); record.bytes2_queries.bump_range_check(&G::from_u8(__x_bytes[2]), &G::from_u8(__x_bytes[3])); record.bytes2_queries.bump_range_check(&G::from_u8(__y_bytes[0]), &G::from_u8(__y_bytes[1])); record.bytes2_queries.bump_range_check(&G::from_u8(__y_bytes[2]), &G::from_u8(__y_bytes[3])); record.bytes2_queries.bump_range_check(&G::from_u8(__z_bytes[0]), &G::from_u8(__z_bytes[1])); record.bytes2_queries.bump_range_check(&G::from_u8(__z_bytes[2]), &G::from_u8(__z_bytes[3])); } __result }; - match __v_18.as_canonical_u64() { + let __v_17: G = G::from_u64(0); + let __r_arr: [G; OUT_762] = { let __args: [G; IN_762] = [__v_1, __v_17]; let __cu = unconstrained; if let Some(result) = record.function_queries[762].get_mut(&__args[..]) { if !__cu && *result.multiplicity == G::ZERO { aiur_fn_762(__args, record, io_buffer, false)? } else { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_762] = unsafe { *(result.output.as_ptr() as *const [G; OUT_762]) }; __ret } } else { aiur_fn_762(__args, record, io_buffer, __cu)? } }; + let __v_18: G = __r_arr[0]; + let __r_arr: [G; OUT_414] = { let __args: [G; IN_414] = [__v_18, __v_2]; let __cu = unconstrained; if let Some(result) = record.function_queries[414].get_mut(&__args[..]) { if !__cu && *result.multiplicity == G::ZERO { aiur_fn_414(__args, record, io_buffer, false)? } else { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_414] = unsafe { *(result.output.as_ptr() as *const [G; OUT_414]) }; __ret } } else { aiur_fn_414(__args, record, io_buffer, __cu)? } }; + let __v_19: G = __r_arr[0]; + match __v_10.as_canonical_u64() { 1u64 => { - let __v_19: G = G::from_u64(0); - let __v_20: G = G::from_u64(0); - let __v_21: G = G::from_u64(0); - let __v_22: G = G::from_u64(0); - let __v_23: G = { let __values: [G; 4] = [__v_20, __v_21, __v_22, __v_22]; let __mq = record.memory_queries.get_mut(&4).ok_or(ExecError::InvalidMemorySize(4))?; if let Some(result) = __mq.get_mut(&__values[..]) { if !unconstrained { *result.multiplicity += G::ONE; } result.output[0] } else { let __ptr = G::from_usize(__mq.len()); __mq.insert(&__values[..], &[__ptr], G::from_bool(!unconstrained)); __ptr } }; - let __ret: [G; OUT_186] = [__v_19, __v_23]; - if let Some(result) = record.function_queries[186].get_mut(&inp[..]) { debug_assert_eq!(result.output, &__ret[..]); if !unconstrained { *result.multiplicity += G::ONE; } } else { record.function_queries[186].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained)); }; + let __r_arr: [G; OUT_185] = { let __args: [G; IN_185] = [__v_19]; let __cu = unconstrained; if let Some(result) = record.function_queries[185].get_mut(&__args[..]) { if !__cu && *result.multiplicity == G::ZERO { aiur_fn_185(__args, record, io_buffer, false)? } else { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_185] = unsafe { *(result.output.as_ptr() as *const [G; OUT_185]) }; __ret } } else { aiur_fn_185(__args, record, io_buffer, __cu)? } }; + let __v_20: G = __r_arr[0]; + let __v_21: G = __r_arr[1]; + let __ret: [G; OUT_183] = [__v_20, __v_21]; + if let Some(result) = record.function_queries[183].get_mut(&inp[..]) { debug_assert_eq!(result.output, &__ret[..]); if !unconstrained { *result.multiplicity += G::ONE; } } else { record.function_queries[183].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained)); }; return Ok(__ret); }, _ => { - let __v_19: G = G::from_u64(0); - let __r_arr: [G; OUT_766] = { let __args: [G; IN_766] = [__v_1, __v_19]; let __cu = unconstrained; if let Some(result) = record.function_queries[766].get_mut(&__args[..]) { if !__cu && *result.multiplicity == G::ZERO { aiur_fn_766(__args, record, io_buffer, false)? } else { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_766] = unsafe { *(result.output.as_ptr() as *const [G; OUT_766]) }; __ret } } else { aiur_fn_766(__args, record, io_buffer, __cu)? } }; + let __r_arr: [G; OUT_186] = { let __args: [G; IN_186] = [__v_19]; let __cu = unconstrained; if let Some(result) = record.function_queries[186].get_mut(&__args[..]) { if !__cu && *result.multiplicity == G::ZERO { aiur_fn_186(__args, record, io_buffer, false)? } else { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_186] = unsafe { *(result.output.as_ptr() as *const [G; OUT_186]) }; __ret } } else { aiur_fn_186(__args, record, io_buffer, __cu)? } }; let __v_20: G = __r_arr[0]; - let __r_arr: [G; OUT_418] = { let __args: [G; IN_418] = [__v_20, __v_2]; let __cu = unconstrained; if let Some(result) = record.function_queries[418].get_mut(&__args[..]) { if !__cu && *result.multiplicity == G::ZERO { aiur_fn_418(__args, record, io_buffer, false)? } else { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_418] = unsafe { *(result.output.as_ptr() as *const [G; OUT_418]) }; __ret } } else { aiur_fn_418(__args, record, io_buffer, __cu)? } }; - let __v_21: G = __r_arr[0]; - match __v_12.as_canonical_u64() { - 1u64 => { - let __r_arr: [G; OUT_189] = { let __args: [G; IN_189] = [__v_21]; let __cu = unconstrained; if let Some(result) = record.function_queries[189].get_mut(&__args[..]) { if !__cu && *result.multiplicity == G::ZERO { aiur_fn_189(__args, record, io_buffer, false)? } else { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_189] = unsafe { *(result.output.as_ptr() as *const [G; OUT_189]) }; __ret } } else { aiur_fn_189(__args, record, io_buffer, __cu)? } }; - let __v_22: G = __r_arr[0]; - let __v_23: G = __r_arr[1]; - let __ret: [G; OUT_186] = [__v_22, __v_23]; - if let Some(result) = record.function_queries[186].get_mut(&inp[..]) { debug_assert_eq!(result.output, &__ret[..]); if !unconstrained { *result.multiplicity += G::ONE; } } else { record.function_queries[186].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained)); }; - return Ok(__ret); - }, - _ => { - let __r_arr: [G; OUT_190] = { let __args: [G; IN_190] = [__v_21]; let __cu = unconstrained; if let Some(result) = record.function_queries[190].get_mut(&__args[..]) { if !__cu && *result.multiplicity == G::ZERO { aiur_fn_190(__args, record, io_buffer, false)? } else { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_190] = unsafe { *(result.output.as_ptr() as *const [G; OUT_190]) }; __ret } } else { aiur_fn_190(__args, record, io_buffer, __cu)? } }; - let __v_22: G = __r_arr[0]; - let __v_23: G = __r_arr[1]; - let __ret: [G; OUT_186] = [__v_22, __v_23]; - if let Some(result) = record.function_queries[186].get_mut(&inp[..]) { debug_assert_eq!(result.output, &__ret[..]); if !unconstrained { *result.multiplicity += G::ONE; } } else { record.function_queries[186].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained)); }; - return Ok(__ret); - }, - } + let __v_21: G = __r_arr[1]; + let __ret: [G; OUT_183] = [__v_20, __v_21]; + if let Some(result) = record.function_queries[183].get_mut(&inp[..]) { debug_assert_eq!(result.output, &__ret[..]); if !unconstrained { *result.multiplicity += G::ONE; } } else { record.function_queries[183].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained)); }; + return Ok(__ret); }, } }, @@ -18740,18 +18563,18 @@ fn aiur_fn_186( }) } -const INPUT_SIZE_187: usize = 1; -const IN_187: usize = 1; -const OUT_187: usize = 2; -fn aiur_fn_187( - inp: [G; IN_187], +const INPUT_SIZE_184: usize = 1; +const IN_184: usize = 1; +const OUT_184: usize = 2; +fn aiur_fn_184( + inp: [G; IN_184], record: &mut QueryRecord, io_buffer: &mut IOBuffer, unconstrained: bool, -) -> Result<[G; OUT_187], ExecError> { +) -> Result<[G; OUT_184], ExecError> { stacker::maybe_grow(64 * 1024, 4 * 1024 * 1024, || { let __v_0: G = inp[0]; - let __r_arr: [G; OUT_764] = { let __args: [G; IN_764] = [__v_0]; let __cu = unconstrained; if let Some(result) = record.function_queries[764].get_mut(&__args[..]) { if !__cu && *result.multiplicity == G::ZERO { aiur_fn_764(__args, record, io_buffer, false)? } else { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_764] = unsafe { *(result.output.as_ptr() as *const [G; OUT_764]) }; __ret } } else { aiur_fn_764(__args, record, io_buffer, __cu)? } }; + let __r_arr: [G; OUT_760] = { let __args: [G; IN_760] = [__v_0]; let __cu = unconstrained; if let Some(result) = record.function_queries[760].get_mut(&__args[..]) { if !__cu && *result.multiplicity == G::ZERO { aiur_fn_760(__args, record, io_buffer, false)? } else { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_760] = unsafe { *(result.output.as_ptr() as *const [G; OUT_760]) }; __ret } } else { aiur_fn_760(__args, record, io_buffer, __cu)? } }; let __v_1: G = __r_arr[0]; let __v_2: G = G::from_u64(3); let __v_3: G = { let __a_val = __v_1.as_canonical_u64(); let __b_val = __v_2.as_canonical_u64(); let __a_u32 = u32::try_from(__a_val).ok().ok_or(ExecError::U32OutOfRange(__a_val))?; let __b_u32 = u32::try_from(__b_val).ok().ok_or(ExecError::U32OutOfRange(__b_val))?; let __result = G::from_bool(__a_u32 < __b_u32); if !unconstrained { let __x_bytes = __a_u32.to_le_bytes(); let __z_bytes = __b_u32.to_le_bytes(); let __c_u32 = __b_u32.wrapping_sub(__a_u32).wrapping_sub(1); let __y_bytes = __c_u32.to_le_bytes(); record.bytes2_queries.bump_range_check(&G::from_u8(__x_bytes[0]), &G::from_u8(__x_bytes[1])); record.bytes2_queries.bump_range_check(&G::from_u8(__x_bytes[2]), &G::from_u8(__x_bytes[3])); record.bytes2_queries.bump_range_check(&G::from_u8(__y_bytes[0]), &G::from_u8(__y_bytes[1])); record.bytes2_queries.bump_range_check(&G::from_u8(__y_bytes[2]), &G::from_u8(__y_bytes[3])); record.bytes2_queries.bump_range_check(&G::from_u8(__z_bytes[0]), &G::from_u8(__z_bytes[1])); record.bytes2_queries.bump_range_check(&G::from_u8(__z_bytes[2]), &G::from_u8(__z_bytes[3])); } __result }; @@ -18762,13 +18585,13 @@ fn aiur_fn_187( let __v_6: G = G::from_u64(0); let __v_7: G = G::from_u64(0); let __v_8: G = { let __values: [G; 4] = [__v_5, __v_6, __v_7, __v_7]; let __mq = record.memory_queries.get_mut(&4).ok_or(ExecError::InvalidMemorySize(4))?; if let Some(result) = __mq.get_mut(&__values[..]) { if !unconstrained { *result.multiplicity += G::ONE; } result.output[0] } else { let __ptr = G::from_usize(__mq.len()); __mq.insert(&__values[..], &[__ptr], G::from_bool(!unconstrained)); __ptr } }; - let __ret: [G; OUT_187] = [__v_4, __v_8]; - if let Some(result) = record.function_queries[187].get_mut(&inp[..]) { debug_assert_eq!(result.output, &__ret[..]); if !unconstrained { *result.multiplicity += G::ONE; } } else { record.function_queries[187].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained)); }; + let __ret: [G; OUT_184] = [__v_4, __v_8]; + if let Some(result) = record.function_queries[184].get_mut(&inp[..]) { debug_assert_eq!(result.output, &__ret[..]); if !unconstrained { *result.multiplicity += G::ONE; } } else { record.function_queries[184].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained)); }; return Ok(__ret); }, _ => { let __v_4: G = G::from_u64(2); - let __r_arr: [G; OUT_766] = { let __args: [G; IN_766] = [__v_0, __v_4]; let __cu = unconstrained; if let Some(result) = record.function_queries[766].get_mut(&__args[..]) { if !__cu && *result.multiplicity == G::ZERO { aiur_fn_766(__args, record, io_buffer, false)? } else { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_766] = unsafe { *(result.output.as_ptr() as *const [G; OUT_766]) }; __ret } } else { aiur_fn_766(__args, record, io_buffer, __cu)? } }; + let __r_arr: [G; OUT_762] = { let __args: [G; IN_762] = [__v_0, __v_4]; let __cu = unconstrained; if let Some(result) = record.function_queries[762].get_mut(&__args[..]) { if !__cu && *result.multiplicity == G::ZERO { aiur_fn_762(__args, record, io_buffer, false)? } else { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_762] = unsafe { *(result.output.as_ptr() as *const [G; OUT_762]) }; __ret } } else { aiur_fn_762(__args, record, io_buffer, __cu)? } }; let __v_5: G = __r_arr[0]; let __r_arr: [G; OUT_111] = { let __args: [G; IN_111] = [__v_5]; let __cu = unconstrained; if let Some(result) = record.function_queries[111].get_mut(&__args[..]) { if !__cu && *result.multiplicity == G::ZERO { aiur_fn_111(__args, record, io_buffer, false)? } else { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_111] = unsafe { *(result.output.as_ptr() as *const [G; OUT_111]) }; __ret } } else { aiur_fn_111(__args, record, io_buffer, __cu)? } }; let __v_6: G = __r_arr[0]; @@ -18787,10 +18610,10 @@ fn aiur_fn_187( match __v_13.as_canonical_u64() { 1u64 => { let __v_14: G = G::from_u64(1); - let __r_arr: [G; OUT_184] = { let __args: [G; IN_184] = []; let __cu = unconstrained; if let Some(result) = record.function_queries[184].get_mut(&__args[..]) { if !__cu && *result.multiplicity == G::ZERO { aiur_fn_184(__args, record, io_buffer, false)? } else { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_184] = unsafe { *(result.output.as_ptr() as *const [G; OUT_184]) }; __ret } } else { aiur_fn_184(__args, record, io_buffer, __cu)? } }; + let __r_arr: [G; OUT_181] = { let __args: [G; IN_181] = []; let __cu = unconstrained; if let Some(result) = record.function_queries[181].get_mut(&__args[..]) { if !__cu && *result.multiplicity == G::ZERO { aiur_fn_181(__args, record, io_buffer, false)? } else { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_181] = unsafe { *(result.output.as_ptr() as *const [G; OUT_181]) }; __ret } } else { aiur_fn_181(__args, record, io_buffer, __cu)? } }; let __v_15: G = __r_arr[0]; - let __ret: [G; OUT_187] = [__v_14, __v_15]; - if let Some(result) = record.function_queries[187].get_mut(&inp[..]) { debug_assert_eq!(result.output, &__ret[..]); if !unconstrained { *result.multiplicity += G::ONE; } } else { record.function_queries[187].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained)); }; + let __ret: [G; OUT_184] = [__v_14, __v_15]; + if let Some(result) = record.function_queries[184].get_mut(&inp[..]) { debug_assert_eq!(result.output, &__ret[..]); if !unconstrained { *result.multiplicity += G::ONE; } } else { record.function_queries[184].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained)); }; return Ok(__ret); }, _ => { @@ -18799,8 +18622,8 @@ fn aiur_fn_187( let __v_16: G = G::from_u64(0); let __v_17: G = G::from_u64(0); let __v_18: G = { let __values: [G; 4] = [__v_15, __v_16, __v_17, __v_17]; let __mq = record.memory_queries.get_mut(&4).ok_or(ExecError::InvalidMemorySize(4))?; if let Some(result) = __mq.get_mut(&__values[..]) { if !unconstrained { *result.multiplicity += G::ONE; } result.output[0] } else { let __ptr = G::from_usize(__mq.len()); __mq.insert(&__values[..], &[__ptr], G::from_bool(!unconstrained)); __ptr } }; - let __ret: [G; OUT_187] = [__v_14, __v_18]; - if let Some(result) = record.function_queries[187].get_mut(&inp[..]) { debug_assert_eq!(result.output, &__ret[..]); if !unconstrained { *result.multiplicity += G::ONE; } } else { record.function_queries[187].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained)); }; + let __ret: [G; OUT_184] = [__v_14, __v_18]; + if let Some(result) = record.function_queries[184].get_mut(&inp[..]) { debug_assert_eq!(result.output, &__ret[..]); if !unconstrained { *result.multiplicity += G::ONE; } } else { record.function_queries[184].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained)); }; return Ok(__ret); }, } @@ -18811,8 +18634,8 @@ fn aiur_fn_187( let __v_14: G = G::from_u64(0); let __v_15: G = G::from_u64(0); let __v_16: G = { let __values: [G; 4] = [__v_13, __v_14, __v_15, __v_15]; let __mq = record.memory_queries.get_mut(&4).ok_or(ExecError::InvalidMemorySize(4))?; if let Some(result) = __mq.get_mut(&__values[..]) { if !unconstrained { *result.multiplicity += G::ONE; } result.output[0] } else { let __ptr = G::from_usize(__mq.len()); __mq.insert(&__values[..], &[__ptr], G::from_bool(!unconstrained)); __ptr } }; - let __ret: [G; OUT_187] = [__v_12, __v_16]; - if let Some(result) = record.function_queries[187].get_mut(&inp[..]) { debug_assert_eq!(result.output, &__ret[..]); if !unconstrained { *result.multiplicity += G::ONE; } } else { record.function_queries[187].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained)); }; + let __ret: [G; OUT_184] = [__v_12, __v_16]; + if let Some(result) = record.function_queries[184].get_mut(&inp[..]) { debug_assert_eq!(result.output, &__ret[..]); if !unconstrained { *result.multiplicity += G::ONE; } } else { record.function_queries[184].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained)); }; return Ok(__ret); }, } @@ -18821,112 +18644,15 @@ fn aiur_fn_187( }) } -const INPUT_SIZE_188: usize = 1; -const IN_188: usize = 1; -const OUT_188: usize = 2; -fn aiur_fn_188( - inp: [G; IN_188], - record: &mut QueryRecord, - io_buffer: &mut IOBuffer, - unconstrained: bool, -) -> Result<[G; OUT_188], ExecError> { - stacker::maybe_grow(64 * 1024, 4 * 1024 * 1024, || { - let __v_0: G = inp[0]; - let __r_arr: [G; OUT_764] = { let __args: [G; IN_764] = [__v_0]; let __cu = unconstrained; if let Some(result) = record.function_queries[764].get_mut(&__args[..]) { if !__cu && *result.multiplicity == G::ZERO { aiur_fn_764(__args, record, io_buffer, false)? } else { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_764] = unsafe { *(result.output.as_ptr() as *const [G; OUT_764]) }; __ret } } else { aiur_fn_764(__args, record, io_buffer, __cu)? } }; - let __v_1: G = __r_arr[0]; - let __v_2: G = G::from_u64(1); - let __v_3: G = { let __a_val = __v_1.as_canonical_u64(); let __b_val = __v_2.as_canonical_u64(); let __a_u32 = u32::try_from(__a_val).ok().ok_or(ExecError::U32OutOfRange(__a_val))?; let __b_u32 = u32::try_from(__b_val).ok().ok_or(ExecError::U32OutOfRange(__b_val))?; let __result = G::from_bool(__a_u32 < __b_u32); if !unconstrained { let __x_bytes = __a_u32.to_le_bytes(); let __z_bytes = __b_u32.to_le_bytes(); let __c_u32 = __b_u32.wrapping_sub(__a_u32).wrapping_sub(1); let __y_bytes = __c_u32.to_le_bytes(); record.bytes2_queries.bump_range_check(&G::from_u8(__x_bytes[0]), &G::from_u8(__x_bytes[1])); record.bytes2_queries.bump_range_check(&G::from_u8(__x_bytes[2]), &G::from_u8(__x_bytes[3])); record.bytes2_queries.bump_range_check(&G::from_u8(__y_bytes[0]), &G::from_u8(__y_bytes[1])); record.bytes2_queries.bump_range_check(&G::from_u8(__y_bytes[2]), &G::from_u8(__y_bytes[3])); record.bytes2_queries.bump_range_check(&G::from_u8(__z_bytes[0]), &G::from_u8(__z_bytes[1])); record.bytes2_queries.bump_range_check(&G::from_u8(__z_bytes[2]), &G::from_u8(__z_bytes[3])); } __result }; - match __v_3.as_canonical_u64() { - 1u64 => { - let __v_4: G = G::from_u64(0); - let __v_5: G = G::from_u64(0); - let __v_6: G = G::from_u64(0); - let __v_7: G = G::from_u64(0); - let __v_8: G = { let __values: [G; 4] = [__v_5, __v_6, __v_7, __v_7]; let __mq = record.memory_queries.get_mut(&4).ok_or(ExecError::InvalidMemorySize(4))?; if let Some(result) = __mq.get_mut(&__values[..]) { if !unconstrained { *result.multiplicity += G::ONE; } result.output[0] } else { let __ptr = G::from_usize(__mq.len()); __mq.insert(&__values[..], &[__ptr], G::from_bool(!unconstrained)); __ptr } }; - let __ret: [G; OUT_188] = [__v_4, __v_8]; - if let Some(result) = record.function_queries[188].get_mut(&inp[..]) { debug_assert_eq!(result.output, &__ret[..]); if !unconstrained { *result.multiplicity += G::ONE; } } else { record.function_queries[188].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained)); }; - return Ok(__ret); - }, - _ => { - let __v_4: G = G::from_u64(0); - let __r_arr: [G; OUT_766] = { let __args: [G; IN_766] = [__v_0, __v_4]; let __cu = unconstrained; if let Some(result) = record.function_queries[766].get_mut(&__args[..]) { if !__cu && *result.multiplicity == G::ZERO { aiur_fn_766(__args, record, io_buffer, false)? } else { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_766] = unsafe { *(result.output.as_ptr() as *const [G; OUT_766]) }; __ret } } else { aiur_fn_766(__args, record, io_buffer, __cu)? } }; - let __v_5: G = __r_arr[0]; - let __r_arr: [G; OUT_111] = { let __args: [G; IN_111] = [__v_5]; let __cu = unconstrained; if let Some(result) = record.function_queries[111].get_mut(&__args[..]) { if !__cu && *result.multiplicity == G::ZERO { aiur_fn_111(__args, record, io_buffer, false)? } else { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_111] = unsafe { *(result.output.as_ptr() as *const [G; OUT_111]) }; __ret } } else { aiur_fn_111(__args, record, io_buffer, __cu)? } }; - let __v_6: G = __r_arr[0]; - let __v_7: G = __r_arr[1]; - let __loaded: [G; 4] = { let __mq = record.memory_queries.get_mut(&4).ok_or(ExecError::InvalidMemorySize(4))?; let __ptr_u64 = __v_6.as_canonical_u64(); let __ptr_usize = usize::try_from(__ptr_u64).ok().ok_or(ExecError::PointerTooLarge(__ptr_u64))?; let (__args, __mult) = __mq.get_index_mut(__ptr_usize).ok_or(ExecError::UnboundPointer { ptr: __ptr_u64, size: 4 })?; if !unconstrained { *__mult += G::ONE; } let __arr: [G; 4] = __args[..4].try_into().unwrap(); __arr }; - let __v_8: G = __loaded[0]; - let __v_9: G = __loaded[1]; - let __v_10: G = __loaded[2]; - let __v_11: G = __loaded[3]; - match __v_8.as_canonical_u64() { - 2u64 => { - let __r_arr: [G; OUT_182] = { let __args: [G; IN_182] = []; let __cu = unconstrained; if let Some(result) = record.function_queries[182].get_mut(&__args[..]) { if !__cu && *result.multiplicity == G::ZERO { aiur_fn_182(__args, record, io_buffer, false)? } else { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_182] = unsafe { *(result.output.as_ptr() as *const [G; OUT_182]) }; __ret } } else { aiur_fn_182(__args, record, io_buffer, __cu)? } }; - let __v_12: G = __r_arr[0]; - let __r_arr: [G; OUT_1] = { let __args: [G; IN_1] = [__v_9, __v_12]; let __cu = unconstrained; if let Some(result) = record.function_queries[1].get_mut(&__args[..]) { if !__cu && *result.multiplicity == G::ZERO { aiur_fn_1(__args, record, io_buffer, false)? } else { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_1] = unsafe { *(result.output.as_ptr() as *const [G; OUT_1]) }; __ret } } else { aiur_fn_1(__args, record, io_buffer, __cu)? } }; - let __v_13: G = __r_arr[0]; - match __v_13.as_canonical_u64() { - 1u64 => { - let __v_14: G = G::from_u64(1); - let __r_arr: [G; OUT_185] = { let __args: [G; IN_185] = []; let __cu = unconstrained; if let Some(result) = record.function_queries[185].get_mut(&__args[..]) { if !__cu && *result.multiplicity == G::ZERO { aiur_fn_185(__args, record, io_buffer, false)? } else { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_185] = unsafe { *(result.output.as_ptr() as *const [G; OUT_185]) }; __ret } } else { aiur_fn_185(__args, record, io_buffer, __cu)? } }; - let __v_15: G = __r_arr[0]; - let __ret: [G; OUT_188] = [__v_14, __v_15]; - if let Some(result) = record.function_queries[188].get_mut(&inp[..]) { debug_assert_eq!(result.output, &__ret[..]); if !unconstrained { *result.multiplicity += G::ONE; } } else { record.function_queries[188].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained)); }; - return Ok(__ret); - }, - _ => { - let __r_arr: [G; OUT_181] = { let __args: [G; IN_181] = []; let __cu = unconstrained; if let Some(result) = record.function_queries[181].get_mut(&__args[..]) { if !__cu && *result.multiplicity == G::ZERO { aiur_fn_181(__args, record, io_buffer, false)? } else { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_181] = unsafe { *(result.output.as_ptr() as *const [G; OUT_181]) }; __ret } } else { aiur_fn_181(__args, record, io_buffer, __cu)? } }; - let __v_14: G = __r_arr[0]; - let __r_arr: [G; OUT_1] = { let __args: [G; IN_1] = [__v_9, __v_14]; let __cu = unconstrained; if let Some(result) = record.function_queries[1].get_mut(&__args[..]) { if !__cu && *result.multiplicity == G::ZERO { aiur_fn_1(__args, record, io_buffer, false)? } else { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_1] = unsafe { *(result.output.as_ptr() as *const [G; OUT_1]) }; __ret } } else { aiur_fn_1(__args, record, io_buffer, __cu)? } }; - let __v_15: G = __r_arr[0]; - match __v_15.as_canonical_u64() { - 1u64 => { - let __v_16: G = G::from_u64(1); - let __r_arr: [G; OUT_185] = { let __args: [G; IN_185] = []; let __cu = unconstrained; if let Some(result) = record.function_queries[185].get_mut(&__args[..]) { if !__cu && *result.multiplicity == G::ZERO { aiur_fn_185(__args, record, io_buffer, false)? } else { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_185] = unsafe { *(result.output.as_ptr() as *const [G; OUT_185]) }; __ret } } else { aiur_fn_185(__args, record, io_buffer, __cu)? } }; - let __v_17: G = __r_arr[0]; - let __ret: [G; OUT_188] = [__v_16, __v_17]; - if let Some(result) = record.function_queries[188].get_mut(&inp[..]) { debug_assert_eq!(result.output, &__ret[..]); if !unconstrained { *result.multiplicity += G::ONE; } } else { record.function_queries[188].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained)); }; - return Ok(__ret); - }, - _ => { - let __v_16: G = G::from_u64(0); - let __v_17: G = G::from_u64(0); - let __v_18: G = G::from_u64(0); - let __v_19: G = G::from_u64(0); - let __v_20: G = { let __values: [G; 4] = [__v_17, __v_18, __v_19, __v_19]; let __mq = record.memory_queries.get_mut(&4).ok_or(ExecError::InvalidMemorySize(4))?; if let Some(result) = __mq.get_mut(&__values[..]) { if !unconstrained { *result.multiplicity += G::ONE; } result.output[0] } else { let __ptr = G::from_usize(__mq.len()); __mq.insert(&__values[..], &[__ptr], G::from_bool(!unconstrained)); __ptr } }; - let __ret: [G; OUT_188] = [__v_16, __v_20]; - if let Some(result) = record.function_queries[188].get_mut(&inp[..]) { debug_assert_eq!(result.output, &__ret[..]); if !unconstrained { *result.multiplicity += G::ONE; } } else { record.function_queries[188].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained)); }; - return Ok(__ret); - }, - } - }, - } - }, - _ => { - let __v_12: G = G::from_u64(0); - let __v_13: G = G::from_u64(0); - let __v_14: G = G::from_u64(0); - let __v_15: G = G::from_u64(0); - let __v_16: G = { let __values: [G; 4] = [__v_13, __v_14, __v_15, __v_15]; let __mq = record.memory_queries.get_mut(&4).ok_or(ExecError::InvalidMemorySize(4))?; if let Some(result) = __mq.get_mut(&__values[..]) { if !unconstrained { *result.multiplicity += G::ONE; } result.output[0] } else { let __ptr = G::from_usize(__mq.len()); __mq.insert(&__values[..], &[__ptr], G::from_bool(!unconstrained)); __ptr } }; - let __ret: [G; OUT_188] = [__v_12, __v_16]; - if let Some(result) = record.function_queries[188].get_mut(&inp[..]) { debug_assert_eq!(result.output, &__ret[..]); if !unconstrained { *result.multiplicity += G::ONE; } } else { record.function_queries[188].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained)); }; - return Ok(__ret); - }, - } - }, - } - }) -} - -const INPUT_SIZE_189: usize = 1; -const IN_189: usize = 1; -const OUT_189: usize = 2; -fn aiur_fn_189( - inp: [G; IN_189], +const INPUT_SIZE_185: usize = 1; +const IN_185: usize = 1; +const OUT_185: usize = 2; +fn aiur_fn_185( + inp: [G; IN_185], record: &mut QueryRecord, io_buffer: &mut IOBuffer, unconstrained: bool, -) -> Result<[G; OUT_189], ExecError> { +) -> Result<[G; OUT_185], ExecError> { stacker::maybe_grow(64 * 1024, 4 * 1024 * 1024, || { let __v_0: G = inp[0]; let __loaded: [G; 4] = { let __mq = record.memory_queries.get_mut(&4).ok_or(ExecError::InvalidMemorySize(4))?; let __ptr_u64 = __v_0.as_canonical_u64(); let __ptr_usize = usize::try_from(__ptr_u64).ok().ok_or(ExecError::PointerTooLarge(__ptr_u64))?; let (__args, __mult) = __mq.get_index_mut(__ptr_usize).ok_or(ExecError::UnboundPointer { ptr: __ptr_u64, size: 4 })?; if !unconstrained { *__mult += G::ONE; } let __arr: [G; 4] = __args[..4].try_into().unwrap(); __arr }; @@ -18952,14 +18678,14 @@ fn aiur_fn_189( let __v_12: G = G::from_u64(0); let __v_13: G = G::from_u64(0); let __v_14: G = { let __values: [G; 4] = [__v_11, __v_12, __v_13, __v_13]; let __mq = record.memory_queries.get_mut(&4).ok_or(ExecError::InvalidMemorySize(4))?; if let Some(result) = __mq.get_mut(&__values[..]) { if !unconstrained { *result.multiplicity += G::ONE; } result.output[0] } else { let __ptr = G::from_usize(__mq.len()); __mq.insert(&__values[..], &[__ptr], G::from_bool(!unconstrained)); __ptr } }; - let __ret: [G; OUT_189] = [__v_10, __v_14]; - if let Some(result) = record.function_queries[189].get_mut(&inp[..]) { debug_assert_eq!(result.output, &__ret[..]); if !unconstrained { *result.multiplicity += G::ONE; } } else { record.function_queries[189].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained)); }; + let __ret: [G; OUT_185] = [__v_10, __v_14]; + if let Some(result) = record.function_queries[185].get_mut(&inp[..]) { debug_assert_eq!(result.output, &__ret[..]); if !unconstrained { *result.multiplicity += G::ONE; } } else { record.function_queries[185].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained)); }; return Ok(__ret); }, _ => { let __v_10: G = G::from_u64(1); - let __ret: [G; OUT_189] = [__v_10, __v_0]; - if let Some(result) = record.function_queries[189].get_mut(&inp[..]) { debug_assert_eq!(result.output, &__ret[..]); if !unconstrained { *result.multiplicity += G::ONE; } } else { record.function_queries[189].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained)); }; + let __ret: [G; OUT_185] = [__v_10, __v_0]; + if let Some(result) = record.function_queries[185].get_mut(&inp[..]) { debug_assert_eq!(result.output, &__ret[..]); if !unconstrained { *result.multiplicity += G::ONE; } } else { record.function_queries[185].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained)); }; return Ok(__ret); }, } @@ -18970,23 +18696,23 @@ fn aiur_fn_189( let __v_7: G = G::from_u64(0); let __v_8: G = G::from_u64(0); let __v_9: G = { let __values: [G; 4] = [__v_6, __v_7, __v_8, __v_8]; let __mq = record.memory_queries.get_mut(&4).ok_or(ExecError::InvalidMemorySize(4))?; if let Some(result) = __mq.get_mut(&__values[..]) { if !unconstrained { *result.multiplicity += G::ONE; } result.output[0] } else { let __ptr = G::from_usize(__mq.len()); __mq.insert(&__values[..], &[__ptr], G::from_bool(!unconstrained)); __ptr } }; - let __ret: [G; OUT_189] = [__v_5, __v_9]; - if let Some(result) = record.function_queries[189].get_mut(&inp[..]) { debug_assert_eq!(result.output, &__ret[..]); if !unconstrained { *result.multiplicity += G::ONE; } } else { record.function_queries[189].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained)); }; + let __ret: [G; OUT_185] = [__v_5, __v_9]; + if let Some(result) = record.function_queries[185].get_mut(&inp[..]) { debug_assert_eq!(result.output, &__ret[..]); if !unconstrained { *result.multiplicity += G::ONE; } } else { record.function_queries[185].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained)); }; return Ok(__ret); }, } }) } -const INPUT_SIZE_190: usize = 1; -const IN_190: usize = 1; -const OUT_190: usize = 2; -fn aiur_fn_190( - inp: [G; IN_190], +const INPUT_SIZE_186: usize = 1; +const IN_186: usize = 1; +const OUT_186: usize = 2; +fn aiur_fn_186( + inp: [G; IN_186], record: &mut QueryRecord, io_buffer: &mut IOBuffer, unconstrained: bool, -) -> Result<[G; OUT_190], ExecError> { +) -> Result<[G; OUT_186], ExecError> { stacker::maybe_grow(64 * 1024, 4 * 1024 * 1024, || { let __v_0: G = inp[0]; let __loaded: [G; 4] = { let __mq = record.memory_queries.get_mut(&4).ok_or(ExecError::InvalidMemorySize(4))?; let __ptr_u64 = __v_0.as_canonical_u64(); let __ptr_usize = usize::try_from(__ptr_u64).ok().ok_or(ExecError::PointerTooLarge(__ptr_u64))?; let (__args, __mult) = __mq.get_index_mut(__ptr_usize).ok_or(ExecError::UnboundPointer { ptr: __ptr_u64, size: 4 })?; if !unconstrained { *__mult += G::ONE; } let __arr: [G; 4] = __args[..4].try_into().unwrap(); __arr }; @@ -18999,8 +18725,8 @@ fn aiur_fn_190( match __v_2.as_canonical_u64() { 0u64 => { let __v_5: G = G::from_u64(1); - let __ret: [G; OUT_190] = [__v_5, __v_0]; - if let Some(result) = record.function_queries[190].get_mut(&inp[..]) { debug_assert_eq!(result.output, &__ret[..]); if !unconstrained { *result.multiplicity += G::ONE; } } else { record.function_queries[190].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained)); }; + let __ret: [G; OUT_186] = [__v_5, __v_0]; + if let Some(result) = record.function_queries[186].get_mut(&inp[..]) { debug_assert_eq!(result.output, &__ret[..]); if !unconstrained { *result.multiplicity += G::ONE; } } else { record.function_queries[186].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained)); }; return Ok(__ret); }, _ => { @@ -19009,8 +18735,8 @@ fn aiur_fn_190( let __v_7: G = G::from_u64(0); let __v_8: G = G::from_u64(0); let __v_9: G = { let __values: [G; 4] = [__v_6, __v_7, __v_8, __v_8]; let __mq = record.memory_queries.get_mut(&4).ok_or(ExecError::InvalidMemorySize(4))?; if let Some(result) = __mq.get_mut(&__values[..]) { if !unconstrained { *result.multiplicity += G::ONE; } result.output[0] } else { let __ptr = G::from_usize(__mq.len()); __mq.insert(&__values[..], &[__ptr], G::from_bool(!unconstrained)); __ptr } }; - let __ret: [G; OUT_190] = [__v_5, __v_9]; - if let Some(result) = record.function_queries[190].get_mut(&inp[..]) { debug_assert_eq!(result.output, &__ret[..]); if !unconstrained { *result.multiplicity += G::ONE; } } else { record.function_queries[190].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained)); }; + let __ret: [G; OUT_186] = [__v_5, __v_9]; + if let Some(result) = record.function_queries[186].get_mut(&inp[..]) { debug_assert_eq!(result.output, &__ret[..]); if !unconstrained { *result.multiplicity += G::ONE; } } else { record.function_queries[186].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained)); }; return Ok(__ret); }, } @@ -19021,23 +18747,23 @@ fn aiur_fn_190( let __v_7: G = G::from_u64(0); let __v_8: G = G::from_u64(0); let __v_9: G = { let __values: [G; 4] = [__v_6, __v_7, __v_8, __v_8]; let __mq = record.memory_queries.get_mut(&4).ok_or(ExecError::InvalidMemorySize(4))?; if let Some(result) = __mq.get_mut(&__values[..]) { if !unconstrained { *result.multiplicity += G::ONE; } result.output[0] } else { let __ptr = G::from_usize(__mq.len()); __mq.insert(&__values[..], &[__ptr], G::from_bool(!unconstrained)); __ptr } }; - let __ret: [G; OUT_190] = [__v_5, __v_9]; - if let Some(result) = record.function_queries[190].get_mut(&inp[..]) { debug_assert_eq!(result.output, &__ret[..]); if !unconstrained { *result.multiplicity += G::ONE; } } else { record.function_queries[190].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained)); }; + let __ret: [G; OUT_186] = [__v_5, __v_9]; + if let Some(result) = record.function_queries[186].get_mut(&inp[..]) { debug_assert_eq!(result.output, &__ret[..]); if !unconstrained { *result.multiplicity += G::ONE; } } else { record.function_queries[186].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained)); }; return Ok(__ret); }, } }) } -const INPUT_SIZE_191: usize = 0; -const IN_191: usize = 0; -const OUT_191: usize = 1; -fn aiur_fn_191( - inp: [G; IN_191], +const INPUT_SIZE_187: usize = 0; +const IN_187: usize = 0; +const OUT_187: usize = 1; +fn aiur_fn_187( + inp: [G; IN_187], record: &mut QueryRecord, io_buffer: &mut IOBuffer, unconstrained: bool, -) -> Result<[G; OUT_191], ExecError> { +) -> Result<[G; OUT_187], ExecError> { stacker::maybe_grow(64 * 1024, 4 * 1024 * 1024, || { let __v_0: G = G::from_u64(227); let __v_1: G = G::from_u64(42); @@ -19072,21 +18798,21 @@ fn aiur_fn_191( let __v_30: G = G::from_u64(3); let __v_31: G = G::from_u64(116); let __v_32: G = { let __values: [G; 32] = [__v_0, __v_1, __v_2, __v_3, __v_4, __v_5, __v_6, __v_7, __v_8, __v_9, __v_10, __v_11, __v_12, __v_13, __v_14, __v_15, __v_16, __v_17, __v_18, __v_19, __v_20, __v_21, __v_22, __v_23, __v_24, __v_25, __v_26, __v_27, __v_28, __v_29, __v_30, __v_31]; let __mq = record.memory_queries.get_mut(&32).ok_or(ExecError::InvalidMemorySize(32))?; if let Some(result) = __mq.get_mut(&__values[..]) { if !unconstrained { *result.multiplicity += G::ONE; } result.output[0] } else { let __ptr = G::from_usize(__mq.len()); __mq.insert(&__values[..], &[__ptr], G::from_bool(!unconstrained)); __ptr } }; - let __ret: [G; OUT_191] = [__v_32]; - if let Some(result) = record.function_queries[191].get_mut(&inp[..]) { debug_assert_eq!(result.output, &__ret[..]); if !unconstrained { *result.multiplicity += G::ONE; } } else { record.function_queries[191].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained)); }; + let __ret: [G; OUT_187] = [__v_32]; + if let Some(result) = record.function_queries[187].get_mut(&inp[..]) { debug_assert_eq!(result.output, &__ret[..]); if !unconstrained { *result.multiplicity += G::ONE; } } else { record.function_queries[187].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained)); }; return Ok(__ret); }) } -const INPUT_SIZE_192: usize = 0; -const IN_192: usize = 0; -const OUT_192: usize = 1; -fn aiur_fn_192( - inp: [G; IN_192], +const INPUT_SIZE_188: usize = 0; +const IN_188: usize = 0; +const OUT_188: usize = 1; +fn aiur_fn_188( + inp: [G; IN_188], record: &mut QueryRecord, io_buffer: &mut IOBuffer, unconstrained: bool, -) -> Result<[G; OUT_192], ExecError> { +) -> Result<[G; OUT_188], ExecError> { stacker::maybe_grow(64 * 1024, 4 * 1024 * 1024, || { let __v_0: G = G::from_u64(59); let __v_1: G = G::from_u64(51); @@ -19121,21 +18847,21 @@ fn aiur_fn_192( let __v_30: G = G::from_u64(191); let __v_31: G = G::from_u64(110); let __v_32: G = { let __values: [G; 32] = [__v_0, __v_1, __v_2, __v_3, __v_4, __v_5, __v_6, __v_7, __v_8, __v_9, __v_10, __v_11, __v_12, __v_13, __v_14, __v_15, __v_16, __v_17, __v_18, __v_19, __v_20, __v_21, __v_22, __v_23, __v_24, __v_25, __v_26, __v_27, __v_28, __v_29, __v_30, __v_31]; let __mq = record.memory_queries.get_mut(&32).ok_or(ExecError::InvalidMemorySize(32))?; if let Some(result) = __mq.get_mut(&__values[..]) { if !unconstrained { *result.multiplicity += G::ONE; } result.output[0] } else { let __ptr = G::from_usize(__mq.len()); __mq.insert(&__values[..], &[__ptr], G::from_bool(!unconstrained)); __ptr } }; - let __ret: [G; OUT_192] = [__v_32]; - if let Some(result) = record.function_queries[192].get_mut(&inp[..]) { debug_assert_eq!(result.output, &__ret[..]); if !unconstrained { *result.multiplicity += G::ONE; } } else { record.function_queries[192].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained)); }; + let __ret: [G; OUT_188] = [__v_32]; + if let Some(result) = record.function_queries[188].get_mut(&inp[..]) { debug_assert_eq!(result.output, &__ret[..]); if !unconstrained { *result.multiplicity += G::ONE; } } else { record.function_queries[188].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained)); }; return Ok(__ret); }) } -const INPUT_SIZE_193: usize = 0; -const IN_193: usize = 0; -const OUT_193: usize = 1; -fn aiur_fn_193( - inp: [G; IN_193], +const INPUT_SIZE_189: usize = 0; +const IN_189: usize = 0; +const OUT_189: usize = 1; +fn aiur_fn_189( + inp: [G; IN_189], record: &mut QueryRecord, io_buffer: &mut IOBuffer, unconstrained: bool, -) -> Result<[G; OUT_193], ExecError> { +) -> Result<[G; OUT_189], ExecError> { stacker::maybe_grow(64 * 1024, 4 * 1024 * 1024, || { let __v_0: G = G::from_u64(103); let __v_1: G = G::from_u64(244); @@ -19170,21 +18896,21 @@ fn aiur_fn_193( let __v_30: G = G::from_u64(43); let __v_31: G = G::from_u64(164); let __v_32: G = { let __values: [G; 32] = [__v_0, __v_1, __v_2, __v_3, __v_4, __v_5, __v_6, __v_7, __v_8, __v_9, __v_10, __v_11, __v_12, __v_13, __v_14, __v_15, __v_16, __v_17, __v_18, __v_19, __v_20, __v_21, __v_22, __v_23, __v_24, __v_25, __v_26, __v_27, __v_28, __v_29, __v_30, __v_31]; let __mq = record.memory_queries.get_mut(&32).ok_or(ExecError::InvalidMemorySize(32))?; if let Some(result) = __mq.get_mut(&__values[..]) { if !unconstrained { *result.multiplicity += G::ONE; } result.output[0] } else { let __ptr = G::from_usize(__mq.len()); __mq.insert(&__values[..], &[__ptr], G::from_bool(!unconstrained)); __ptr } }; - let __ret: [G; OUT_193] = [__v_32]; - if let Some(result) = record.function_queries[193].get_mut(&inp[..]) { debug_assert_eq!(result.output, &__ret[..]); if !unconstrained { *result.multiplicity += G::ONE; } } else { record.function_queries[193].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained)); }; + let __ret: [G; OUT_189] = [__v_32]; + if let Some(result) = record.function_queries[189].get_mut(&inp[..]) { debug_assert_eq!(result.output, &__ret[..]); if !unconstrained { *result.multiplicity += G::ONE; } } else { record.function_queries[189].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained)); }; return Ok(__ret); }) } -const INPUT_SIZE_194: usize = 0; -const IN_194: usize = 0; -const OUT_194: usize = 1; -fn aiur_fn_194( - inp: [G; IN_194], +const INPUT_SIZE_190: usize = 0; +const IN_190: usize = 0; +const OUT_190: usize = 1; +fn aiur_fn_190( + inp: [G; IN_190], record: &mut QueryRecord, io_buffer: &mut IOBuffer, unconstrained: bool, -) -> Result<[G; OUT_194], ExecError> { +) -> Result<[G; OUT_190], ExecError> { stacker::maybe_grow(64 * 1024, 4 * 1024 * 1024, || { let __v_0: G = G::from_u64(79); let __v_1: G = G::from_u64(157); @@ -19219,21 +18945,21 @@ fn aiur_fn_194( let __v_30: G = G::from_u64(87); let __v_31: G = G::from_u64(204); let __v_32: G = { let __values: [G; 32] = [__v_0, __v_1, __v_2, __v_3, __v_4, __v_5, __v_6, __v_7, __v_8, __v_9, __v_10, __v_11, __v_12, __v_13, __v_14, __v_15, __v_16, __v_17, __v_18, __v_19, __v_20, __v_21, __v_22, __v_23, __v_24, __v_25, __v_26, __v_27, __v_28, __v_29, __v_30, __v_31]; let __mq = record.memory_queries.get_mut(&32).ok_or(ExecError::InvalidMemorySize(32))?; if let Some(result) = __mq.get_mut(&__values[..]) { if !unconstrained { *result.multiplicity += G::ONE; } result.output[0] } else { let __ptr = G::from_usize(__mq.len()); __mq.insert(&__values[..], &[__ptr], G::from_bool(!unconstrained)); __ptr } }; - let __ret: [G; OUT_194] = [__v_32]; - if let Some(result) = record.function_queries[194].get_mut(&inp[..]) { debug_assert_eq!(result.output, &__ret[..]); if !unconstrained { *result.multiplicity += G::ONE; } } else { record.function_queries[194].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained)); }; + let __ret: [G; OUT_190] = [__v_32]; + if let Some(result) = record.function_queries[190].get_mut(&inp[..]) { debug_assert_eq!(result.output, &__ret[..]); if !unconstrained { *result.multiplicity += G::ONE; } } else { record.function_queries[190].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained)); }; return Ok(__ret); }) } -const INPUT_SIZE_195: usize = 0; -const IN_195: usize = 0; -const OUT_195: usize = 1; -fn aiur_fn_195( - inp: [G; IN_195], +const INPUT_SIZE_191: usize = 0; +const IN_191: usize = 0; +const OUT_191: usize = 1; +fn aiur_fn_191( + inp: [G; IN_191], record: &mut QueryRecord, io_buffer: &mut IOBuffer, unconstrained: bool, -) -> Result<[G; OUT_195], ExecError> { +) -> Result<[G; OUT_191], ExecError> { stacker::maybe_grow(64 * 1024, 4 * 1024 * 1024, || { let __v_0: G = G::from_u64(197); let __v_1: G = G::from_u64(247); @@ -19268,21 +18994,21 @@ fn aiur_fn_195( let __v_30: G = G::from_u64(55); let __v_31: G = G::from_u64(35); let __v_32: G = { let __values: [G; 32] = [__v_0, __v_1, __v_2, __v_3, __v_4, __v_5, __v_6, __v_7, __v_8, __v_9, __v_10, __v_11, __v_12, __v_13, __v_14, __v_15, __v_16, __v_17, __v_18, __v_19, __v_20, __v_21, __v_22, __v_23, __v_24, __v_25, __v_26, __v_27, __v_28, __v_29, __v_30, __v_31]; let __mq = record.memory_queries.get_mut(&32).ok_or(ExecError::InvalidMemorySize(32))?; if let Some(result) = __mq.get_mut(&__values[..]) { if !unconstrained { *result.multiplicity += G::ONE; } result.output[0] } else { let __ptr = G::from_usize(__mq.len()); __mq.insert(&__values[..], &[__ptr], G::from_bool(!unconstrained)); __ptr } }; - let __ret: [G; OUT_195] = [__v_32]; - if let Some(result) = record.function_queries[195].get_mut(&inp[..]) { debug_assert_eq!(result.output, &__ret[..]); if !unconstrained { *result.multiplicity += G::ONE; } } else { record.function_queries[195].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained)); }; + let __ret: [G; OUT_191] = [__v_32]; + if let Some(result) = record.function_queries[191].get_mut(&inp[..]) { debug_assert_eq!(result.output, &__ret[..]); if !unconstrained { *result.multiplicity += G::ONE; } } else { record.function_queries[191].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained)); }; return Ok(__ret); }) } -const INPUT_SIZE_196: usize = 0; -const IN_196: usize = 0; -const OUT_196: usize = 1; -fn aiur_fn_196( - inp: [G; IN_196], +const INPUT_SIZE_192: usize = 0; +const IN_192: usize = 0; +const OUT_192: usize = 1; +fn aiur_fn_192( + inp: [G; IN_192], record: &mut QueryRecord, io_buffer: &mut IOBuffer, unconstrained: bool, -) -> Result<[G; OUT_196], ExecError> { +) -> Result<[G; OUT_192], ExecError> { stacker::maybe_grow(64 * 1024, 4 * 1024 * 1024, || { let __v_0: G = G::from_u64(202); let __v_1: G = G::from_u64(202); @@ -19317,62 +19043,62 @@ fn aiur_fn_196( let __v_30: G = G::from_u64(51); let __v_31: G = G::from_u64(18); let __v_32: G = { let __values: [G; 32] = [__v_0, __v_1, __v_2, __v_3, __v_4, __v_5, __v_6, __v_7, __v_8, __v_9, __v_10, __v_11, __v_12, __v_13, __v_14, __v_15, __v_16, __v_17, __v_18, __v_19, __v_20, __v_21, __v_22, __v_23, __v_24, __v_25, __v_26, __v_27, __v_28, __v_29, __v_30, __v_31]; let __mq = record.memory_queries.get_mut(&32).ok_or(ExecError::InvalidMemorySize(32))?; if let Some(result) = __mq.get_mut(&__values[..]) { if !unconstrained { *result.multiplicity += G::ONE; } result.output[0] } else { let __ptr = G::from_usize(__mq.len()); __mq.insert(&__values[..], &[__ptr], G::from_bool(!unconstrained)); __ptr } }; - let __ret: [G; OUT_196] = [__v_32]; - if let Some(result) = record.function_queries[196].get_mut(&inp[..]) { debug_assert_eq!(result.output, &__ret[..]); if !unconstrained { *result.multiplicity += G::ONE; } } else { record.function_queries[196].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained)); }; + let __ret: [G; OUT_192] = [__v_32]; + if let Some(result) = record.function_queries[192].get_mut(&inp[..]) { debug_assert_eq!(result.output, &__ret[..]); if !unconstrained { *result.multiplicity += G::ONE; } } else { record.function_queries[192].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained)); }; return Ok(__ret); }) } -const INPUT_SIZE_197: usize = 1; -const IN_197: usize = 1; -const OUT_197: usize = 1; -fn aiur_fn_197( - inp: [G; IN_197], +const INPUT_SIZE_193: usize = 1; +const IN_193: usize = 1; +const OUT_193: usize = 1; +fn aiur_fn_193( + inp: [G; IN_193], record: &mut QueryRecord, io_buffer: &mut IOBuffer, unconstrained: bool, -) -> Result<[G; OUT_197], ExecError> { +) -> Result<[G; OUT_193], ExecError> { stacker::maybe_grow(64 * 1024, 4 * 1024 * 1024, || { let __v_0: G = inp[0]; - let __r_arr: [G; OUT_191] = { let __args: [G; IN_191] = []; let __cu = unconstrained; if let Some(result) = record.function_queries[191].get_mut(&__args[..]) { if !__cu && *result.multiplicity == G::ZERO { aiur_fn_191(__args, record, io_buffer, false)? } else { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_191] = unsafe { *(result.output.as_ptr() as *const [G; OUT_191]) }; __ret } } else { aiur_fn_191(__args, record, io_buffer, __cu)? } }; + let __r_arr: [G; OUT_187] = { let __args: [G; IN_187] = []; let __cu = unconstrained; if let Some(result) = record.function_queries[187].get_mut(&__args[..]) { if !__cu && *result.multiplicity == G::ZERO { aiur_fn_187(__args, record, io_buffer, false)? } else { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_187] = unsafe { *(result.output.as_ptr() as *const [G; OUT_187]) }; __ret } } else { aiur_fn_187(__args, record, io_buffer, __cu)? } }; let __v_1: G = __r_arr[0]; let __r_arr: [G; OUT_1] = { let __args: [G; IN_1] = [__v_0, __v_1]; let __cu = unconstrained; if let Some(result) = record.function_queries[1].get_mut(&__args[..]) { if !__cu && *result.multiplicity == G::ZERO { aiur_fn_1(__args, record, io_buffer, false)? } else { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_1] = unsafe { *(result.output.as_ptr() as *const [G; OUT_1]) }; __ret } } else { aiur_fn_1(__args, record, io_buffer, __cu)? } }; let __v_2: G = __r_arr[0]; match __v_2.as_canonical_u64() { 1u64 => { let __v_3: G = G::from_u64(1); - let __ret: [G; OUT_197] = [__v_3]; - if let Some(result) = record.function_queries[197].get_mut(&inp[..]) { debug_assert_eq!(result.output, &__ret[..]); if !unconstrained { *result.multiplicity += G::ONE; } } else { record.function_queries[197].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained)); }; + let __ret: [G; OUT_193] = [__v_3]; + if let Some(result) = record.function_queries[193].get_mut(&inp[..]) { debug_assert_eq!(result.output, &__ret[..]); if !unconstrained { *result.multiplicity += G::ONE; } } else { record.function_queries[193].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained)); }; return Ok(__ret); }, _ => { - let __r_arr: [G; OUT_194] = { let __args: [G; IN_194] = []; let __cu = unconstrained; if let Some(result) = record.function_queries[194].get_mut(&__args[..]) { if !__cu && *result.multiplicity == G::ZERO { aiur_fn_194(__args, record, io_buffer, false)? } else { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_194] = unsafe { *(result.output.as_ptr() as *const [G; OUT_194]) }; __ret } } else { aiur_fn_194(__args, record, io_buffer, __cu)? } }; + let __r_arr: [G; OUT_190] = { let __args: [G; IN_190] = []; let __cu = unconstrained; if let Some(result) = record.function_queries[190].get_mut(&__args[..]) { if !__cu && *result.multiplicity == G::ZERO { aiur_fn_190(__args, record, io_buffer, false)? } else { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_190] = unsafe { *(result.output.as_ptr() as *const [G; OUT_190]) }; __ret } } else { aiur_fn_190(__args, record, io_buffer, __cu)? } }; let __v_3: G = __r_arr[0]; let __r_arr: [G; OUT_1] = { let __args: [G; IN_1] = [__v_0, __v_3]; let __cu = unconstrained; if let Some(result) = record.function_queries[1].get_mut(&__args[..]) { if !__cu && *result.multiplicity == G::ZERO { aiur_fn_1(__args, record, io_buffer, false)? } else { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_1] = unsafe { *(result.output.as_ptr() as *const [G; OUT_1]) }; __ret } } else { aiur_fn_1(__args, record, io_buffer, __cu)? } }; let __v_4: G = __r_arr[0]; match __v_4.as_canonical_u64() { 1u64 => { let __v_5: G = G::from_u64(1); - let __ret: [G; OUT_197] = [__v_5]; - if let Some(result) = record.function_queries[197].get_mut(&inp[..]) { debug_assert_eq!(result.output, &__ret[..]); if !unconstrained { *result.multiplicity += G::ONE; } } else { record.function_queries[197].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained)); }; + let __ret: [G; OUT_193] = [__v_5]; + if let Some(result) = record.function_queries[193].get_mut(&inp[..]) { debug_assert_eq!(result.output, &__ret[..]); if !unconstrained { *result.multiplicity += G::ONE; } } else { record.function_queries[193].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained)); }; return Ok(__ret); }, _ => { - let __r_arr: [G; OUT_195] = { let __args: [G; IN_195] = []; let __cu = unconstrained; if let Some(result) = record.function_queries[195].get_mut(&__args[..]) { if !__cu && *result.multiplicity == G::ZERO { aiur_fn_195(__args, record, io_buffer, false)? } else { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_195] = unsafe { *(result.output.as_ptr() as *const [G; OUT_195]) }; __ret } } else { aiur_fn_195(__args, record, io_buffer, __cu)? } }; + let __r_arr: [G; OUT_191] = { let __args: [G; IN_191] = []; let __cu = unconstrained; if let Some(result) = record.function_queries[191].get_mut(&__args[..]) { if !__cu && *result.multiplicity == G::ZERO { aiur_fn_191(__args, record, io_buffer, false)? } else { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_191] = unsafe { *(result.output.as_ptr() as *const [G; OUT_191]) }; __ret } } else { aiur_fn_191(__args, record, io_buffer, __cu)? } }; let __v_5: G = __r_arr[0]; let __r_arr: [G; OUT_1] = { let __args: [G; IN_1] = [__v_0, __v_5]; let __cu = unconstrained; if let Some(result) = record.function_queries[1].get_mut(&__args[..]) { if !__cu && *result.multiplicity == G::ZERO { aiur_fn_1(__args, record, io_buffer, false)? } else { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_1] = unsafe { *(result.output.as_ptr() as *const [G; OUT_1]) }; __ret } } else { aiur_fn_1(__args, record, io_buffer, __cu)? } }; let __v_6: G = __r_arr[0]; match __v_6.as_canonical_u64() { 1u64 => { let __v_7: G = G::from_u64(1); - let __ret: [G; OUT_197] = [__v_7]; - if let Some(result) = record.function_queries[197].get_mut(&inp[..]) { debug_assert_eq!(result.output, &__ret[..]); if !unconstrained { *result.multiplicity += G::ONE; } } else { record.function_queries[197].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained)); }; + let __ret: [G; OUT_193] = [__v_7]; + if let Some(result) = record.function_queries[193].get_mut(&inp[..]) { debug_assert_eq!(result.output, &__ret[..]); if !unconstrained { *result.multiplicity += G::ONE; } } else { record.function_queries[193].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained)); }; return Ok(__ret); }, _ => { let __v_7: G = G::from_u64(0); - let __ret: [G; OUT_197] = [__v_7]; - if let Some(result) = record.function_queries[197].get_mut(&inp[..]) { debug_assert_eq!(result.output, &__ret[..]); if !unconstrained { *result.multiplicity += G::ONE; } } else { record.function_queries[197].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained)); }; + let __ret: [G; OUT_193] = [__v_7]; + if let Some(result) = record.function_queries[193].get_mut(&inp[..]) { debug_assert_eq!(result.output, &__ret[..]); if !unconstrained { *result.multiplicity += G::ONE; } } else { record.function_queries[193].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained)); }; return Ok(__ret); }, } @@ -19383,15 +19109,15 @@ fn aiur_fn_197( }) } -const INPUT_SIZE_198: usize = 1; -const IN_198: usize = 1; -const OUT_198: usize = 1; -fn aiur_fn_198( - inp: [G; IN_198], +const INPUT_SIZE_194: usize = 1; +const IN_194: usize = 1; +const OUT_194: usize = 1; +fn aiur_fn_194( + inp: [G; IN_194], record: &mut QueryRecord, io_buffer: &mut IOBuffer, unconstrained: bool, -) -> Result<[G; OUT_198], ExecError> { +) -> Result<[G; OUT_194], ExecError> { stacker::maybe_grow(64 * 1024, 4 * 1024 * 1024, || { let __v_0: G = inp[0]; match __v_0.as_canonical_u64() { @@ -19404,8 +19130,8 @@ fn aiur_fn_198( let __v_5: G = { let __values: [G; 3] = [__v_3, __v_4, __v_4]; let __mq = record.memory_queries.get_mut(&3).ok_or(ExecError::InvalidMemorySize(3))?; if let Some(result) = __mq.get_mut(&__values[..]) { if !unconstrained { *result.multiplicity += G::ONE; } result.output[0] } else { let __ptr = G::from_usize(__mq.len()); __mq.insert(&__values[..], &[__ptr], G::from_bool(!unconstrained)); __ptr } }; let __v_6: G = G::from_u64(0); let __v_7: G = { let __values: [G; 4] = [__v_1, __v_2, __v_5, __v_6]; let __mq = record.memory_queries.get_mut(&4).ok_or(ExecError::InvalidMemorySize(4))?; if let Some(result) = __mq.get_mut(&__values[..]) { if !unconstrained { *result.multiplicity += G::ONE; } result.output[0] } else { let __ptr = G::from_usize(__mq.len()); __mq.insert(&__values[..], &[__ptr], G::from_bool(!unconstrained)); __ptr } }; - let __ret: [G; OUT_198] = [__v_7]; - if let Some(result) = record.function_queries[198].get_mut(&inp[..]) { debug_assert_eq!(result.output, &__ret[..]); if !unconstrained { *result.multiplicity += G::ONE; } } else { record.function_queries[198].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained)); }; + let __ret: [G; OUT_194] = [__v_7]; + if let Some(result) = record.function_queries[194].get_mut(&inp[..]) { debug_assert_eq!(result.output, &__ret[..]); if !unconstrained { *result.multiplicity += G::ONE; } } else { record.function_queries[194].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained)); }; return Ok(__ret); }, _ => { @@ -19417,27 +19143,27 @@ fn aiur_fn_198( let __v_5: G = { let __values: [G; 3] = [__v_3, __v_4, __v_4]; let __mq = record.memory_queries.get_mut(&3).ok_or(ExecError::InvalidMemorySize(3))?; if let Some(result) = __mq.get_mut(&__values[..]) { if !unconstrained { *result.multiplicity += G::ONE; } result.output[0] } else { let __ptr = G::from_usize(__mq.len()); __mq.insert(&__values[..], &[__ptr], G::from_bool(!unconstrained)); __ptr } }; let __v_6: G = G::from_u64(0); let __v_7: G = { let __values: [G; 4] = [__v_1, __v_2, __v_5, __v_6]; let __mq = record.memory_queries.get_mut(&4).ok_or(ExecError::InvalidMemorySize(4))?; if let Some(result) = __mq.get_mut(&__values[..]) { if !unconstrained { *result.multiplicity += G::ONE; } result.output[0] } else { let __ptr = G::from_usize(__mq.len()); __mq.insert(&__values[..], &[__ptr], G::from_bool(!unconstrained)); __ptr } }; - let __ret: [G; OUT_198] = [__v_7]; - if let Some(result) = record.function_queries[198].get_mut(&inp[..]) { debug_assert_eq!(result.output, &__ret[..]); if !unconstrained { *result.multiplicity += G::ONE; } } else { record.function_queries[198].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained)); }; + let __ret: [G; OUT_194] = [__v_7]; + if let Some(result) = record.function_queries[194].get_mut(&inp[..]) { debug_assert_eq!(result.output, &__ret[..]); if !unconstrained { *result.multiplicity += G::ONE; } } else { record.function_queries[194].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained)); }; return Ok(__ret); }, } }) } -const INPUT_SIZE_199: usize = 2; -const IN_199: usize = 2; -const OUT_199: usize = 2; -fn aiur_fn_199( - inp: [G; IN_199], +const INPUT_SIZE_195: usize = 2; +const IN_195: usize = 2; +const OUT_195: usize = 2; +fn aiur_fn_195( + inp: [G; IN_195], record: &mut QueryRecord, io_buffer: &mut IOBuffer, unconstrained: bool, -) -> Result<[G; OUT_199], ExecError> { +) -> Result<[G; OUT_195], ExecError> { stacker::maybe_grow(64 * 1024, 4 * 1024 * 1024, || { let __v_0: G = inp[0]; let __v_1: G = inp[1]; - let __r_arr: [G; OUT_202] = { let __args: [G; IN_202] = [__v_1]; let __cu = unconstrained; if let Some(result) = record.function_queries[202].get_mut(&__args[..]) { if !__cu && *result.multiplicity == G::ZERO { aiur_fn_202(__args, record, io_buffer, false)? } else { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_202] = unsafe { *(result.output.as_ptr() as *const [G; OUT_202]) }; __ret } } else { aiur_fn_202(__args, record, io_buffer, __cu)? } }; + let __r_arr: [G; OUT_198] = { let __args: [G; IN_198] = [__v_1]; let __cu = unconstrained; if let Some(result) = record.function_queries[198].get_mut(&__args[..]) { if !__cu && *result.multiplicity == G::ZERO { aiur_fn_198(__args, record, io_buffer, false)? } else { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_198] = unsafe { *(result.output.as_ptr() as *const [G; OUT_198]) }; __ret } } else { aiur_fn_198(__args, record, io_buffer, __cu)? } }; let __v_2: G = __r_arr[0]; let __v_3: G = __r_arr[1]; let __v_4: G = __r_arr[2]; @@ -19447,12 +19173,12 @@ fn aiur_fn_199( let __v_6: G = G::from_u64(1); let __v_7: G = G::from_u64(1); let __v_8: G = { let __values: [G; 10] = [__v_6, __v_7, __v_7, __v_7, __v_7, __v_7, __v_7, __v_7, __v_7, __v_7]; let __mq = record.memory_queries.get_mut(&10).ok_or(ExecError::InvalidMemorySize(10))?; if let Some(result) = __mq.get_mut(&__values[..]) { if !unconstrained { *result.multiplicity += G::ONE; } result.output[0] } else { let __ptr = G::from_usize(__mq.len()); __mq.insert(&__values[..], &[__ptr], G::from_bool(!unconstrained)); __ptr } }; - let __ret: [G; OUT_199] = [__v_5, __v_8]; - if let Some(result) = record.function_queries[199].get_mut(&inp[..]) { debug_assert_eq!(result.output, &__ret[..]); if !unconstrained { *result.multiplicity += G::ONE; } } else { record.function_queries[199].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained)); }; + let __ret: [G; OUT_195] = [__v_5, __v_8]; + if let Some(result) = record.function_queries[195].get_mut(&inp[..]) { debug_assert_eq!(result.output, &__ret[..]); if !unconstrained { *result.multiplicity += G::ONE; } } else { record.function_queries[195].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained)); }; return Ok(__ret); }, 1u64 => { - let __r_arr: [G; OUT_243] = { let __args: [G; IN_243] = [__v_4]; let __cu = unconstrained; if let Some(result) = record.function_queries[243].get_mut(&__args[..]) { if !__cu && *result.multiplicity == G::ZERO { aiur_fn_243(__args, record, io_buffer, false)? } else { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_243] = unsafe { *(result.output.as_ptr() as *const [G; OUT_243]) }; __ret } } else { aiur_fn_243(__args, record, io_buffer, __cu)? } }; + let __r_arr: [G; OUT_239] = { let __args: [G; IN_239] = [__v_4]; let __cu = unconstrained; if let Some(result) = record.function_queries[239].get_mut(&__args[..]) { if !__cu && *result.multiplicity == G::ZERO { aiur_fn_239(__args, record, io_buffer, false)? } else { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_239] = unsafe { *(result.output.as_ptr() as *const [G; OUT_239]) }; __ret } } else { aiur_fn_239(__args, record, io_buffer, __cu)? } }; let __v_5: G = __r_arr[0]; let __v_6: G = __r_arr[1]; match __v_5.as_canonical_u64() { @@ -19461,12 +19187,12 @@ fn aiur_fn_199( let __v_8: G = G::from_u64(1); let __v_9: G = G::from_u64(1); let __v_10: G = { let __values: [G; 10] = [__v_8, __v_9, __v_9, __v_9, __v_9, __v_9, __v_9, __v_9, __v_9, __v_9]; let __mq = record.memory_queries.get_mut(&10).ok_or(ExecError::InvalidMemorySize(10))?; if let Some(result) = __mq.get_mut(&__values[..]) { if !unconstrained { *result.multiplicity += G::ONE; } result.output[0] } else { let __ptr = G::from_usize(__mq.len()); __mq.insert(&__values[..], &[__ptr], G::from_bool(!unconstrained)); __ptr } }; - let __ret: [G; OUT_199] = [__v_7, __v_10]; - if let Some(result) = record.function_queries[199].get_mut(&inp[..]) { debug_assert_eq!(result.output, &__ret[..]); if !unconstrained { *result.multiplicity += G::ONE; } } else { record.function_queries[199].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained)); }; + let __ret: [G; OUT_195] = [__v_7, __v_10]; + if let Some(result) = record.function_queries[195].get_mut(&inp[..]) { debug_assert_eq!(result.output, &__ret[..]); if !unconstrained { *result.multiplicity += G::ONE; } } else { record.function_queries[195].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained)); }; return Ok(__ret); }, 1u64 => { - let __r_arr: [G; OUT_243] = { let __args: [G; IN_243] = [__v_3]; let __cu = unconstrained; if let Some(result) = record.function_queries[243].get_mut(&__args[..]) { if !__cu && *result.multiplicity == G::ZERO { aiur_fn_243(__args, record, io_buffer, false)? } else { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_243] = unsafe { *(result.output.as_ptr() as *const [G; OUT_243]) }; __ret } } else { aiur_fn_243(__args, record, io_buffer, __cu)? } }; + let __r_arr: [G; OUT_239] = { let __args: [G; IN_239] = [__v_3]; let __cu = unconstrained; if let Some(result) = record.function_queries[239].get_mut(&__args[..]) { if !__cu && *result.multiplicity == G::ZERO { aiur_fn_239(__args, record, io_buffer, false)? } else { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_239] = unsafe { *(result.output.as_ptr() as *const [G; OUT_239]) }; __ret } } else { aiur_fn_239(__args, record, io_buffer, __cu)? } }; let __v_7: G = __r_arr[0]; let __v_8: G = __r_arr[1]; match __v_7.as_canonical_u64() { @@ -19475,8 +19201,8 @@ fn aiur_fn_199( let __v_10: G = G::from_u64(1); let __v_11: G = G::from_u64(1); let __v_12: G = { let __values: [G; 10] = [__v_10, __v_11, __v_11, __v_11, __v_11, __v_11, __v_11, __v_11, __v_11, __v_11]; let __mq = record.memory_queries.get_mut(&10).ok_or(ExecError::InvalidMemorySize(10))?; if let Some(result) = __mq.get_mut(&__values[..]) { if !unconstrained { *result.multiplicity += G::ONE; } result.output[0] } else { let __ptr = G::from_usize(__mq.len()); __mq.insert(&__values[..], &[__ptr], G::from_bool(!unconstrained)); __ptr } }; - let __ret: [G; OUT_199] = [__v_9, __v_12]; - if let Some(result) = record.function_queries[199].get_mut(&inp[..]) { debug_assert_eq!(result.output, &__ret[..]); if !unconstrained { *result.multiplicity += G::ONE; } } else { record.function_queries[199].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained)); }; + let __ret: [G; OUT_195] = [__v_9, __v_12]; + if let Some(result) = record.function_queries[195].get_mut(&inp[..]) { debug_assert_eq!(result.output, &__ret[..]); if !unconstrained { *result.multiplicity += G::ONE; } } else { record.function_queries[195].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained)); }; return Ok(__ret); }, 1u64 => { @@ -19500,8 +19226,8 @@ fn aiur_fn_199( let __v_24: G = __r_arr[0]; let __r_arr: [G; OUT_118] = { let __args: [G; IN_118] = [__v_24]; let __cu = unconstrained; if let Some(result) = record.function_queries[118].get_mut(&__args[..]) { if !__cu && *result.multiplicity == G::ZERO { aiur_fn_118(__args, record, io_buffer, false)? } else { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_118] = unsafe { *(result.output.as_ptr() as *const [G; OUT_118]) }; __ret } } else { aiur_fn_118(__args, record, io_buffer, __cu)? } }; let __v_25: G = __r_arr[0]; - let __ret: [G; OUT_199] = [__v_23, __v_25]; - if let Some(result) = record.function_queries[199].get_mut(&inp[..]) { debug_assert_eq!(result.output, &__ret[..]); if !unconstrained { *result.multiplicity += G::ONE; } } else { record.function_queries[199].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained)); }; + let __ret: [G; OUT_195] = [__v_23, __v_25]; + if let Some(result) = record.function_queries[195].get_mut(&inp[..]) { debug_assert_eq!(result.output, &__ret[..]); if !unconstrained { *result.multiplicity += G::ONE; } } else { record.function_queries[195].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained)); }; return Ok(__ret); }, _ => { @@ -19521,18 +19247,18 @@ fn aiur_fn_199( }) } -const INPUT_SIZE_200: usize = 1; -const IN_200: usize = 1; -const OUT_200: usize = 2; -fn aiur_fn_200( - inp: [G; IN_200], +const INPUT_SIZE_196: usize = 1; +const IN_196: usize = 1; +const OUT_196: usize = 2; +fn aiur_fn_196( + inp: [G; IN_196], record: &mut QueryRecord, io_buffer: &mut IOBuffer, unconstrained: bool, -) -> Result<[G; OUT_200], ExecError> { +) -> Result<[G; OUT_196], ExecError> { stacker::maybe_grow(64 * 1024, 4 * 1024 * 1024, || { let __v_0: G = inp[0]; - let __r_arr: [G; OUT_764] = { let __args: [G; IN_764] = [__v_0]; let __cu = unconstrained; if let Some(result) = record.function_queries[764].get_mut(&__args[..]) { if !__cu && *result.multiplicity == G::ZERO { aiur_fn_764(__args, record, io_buffer, false)? } else { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_764] = unsafe { *(result.output.as_ptr() as *const [G; OUT_764]) }; __ret } } else { aiur_fn_764(__args, record, io_buffer, __cu)? } }; + let __r_arr: [G; OUT_760] = { let __args: [G; IN_760] = [__v_0]; let __cu = unconstrained; if let Some(result) = record.function_queries[760].get_mut(&__args[..]) { if !__cu && *result.multiplicity == G::ZERO { aiur_fn_760(__args, record, io_buffer, false)? } else { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_760] = unsafe { *(result.output.as_ptr() as *const [G; OUT_760]) }; __ret } } else { aiur_fn_760(__args, record, io_buffer, __cu)? } }; let __v_1: G = __r_arr[0]; let __v_2: G = G::from_u64(3); let __v_3: G = { let __a_val = __v_1.as_canonical_u64(); let __b_val = __v_2.as_canonical_u64(); let __a_u32 = u32::try_from(__a_val).ok().ok_or(ExecError::U32OutOfRange(__a_val))?; let __b_u32 = u32::try_from(__b_val).ok().ok_or(ExecError::U32OutOfRange(__b_val))?; let __result = G::from_bool(__a_u32 < __b_u32); if !unconstrained { let __x_bytes = __a_u32.to_le_bytes(); let __z_bytes = __b_u32.to_le_bytes(); let __c_u32 = __b_u32.wrapping_sub(__a_u32).wrapping_sub(1); let __y_bytes = __c_u32.to_le_bytes(); record.bytes2_queries.bump_range_check(&G::from_u8(__x_bytes[0]), &G::from_u8(__x_bytes[1])); record.bytes2_queries.bump_range_check(&G::from_u8(__x_bytes[2]), &G::from_u8(__x_bytes[3])); record.bytes2_queries.bump_range_check(&G::from_u8(__y_bytes[0]), &G::from_u8(__y_bytes[1])); record.bytes2_queries.bump_range_check(&G::from_u8(__y_bytes[2]), &G::from_u8(__y_bytes[3])); record.bytes2_queries.bump_range_check(&G::from_u8(__z_bytes[0]), &G::from_u8(__z_bytes[1])); record.bytes2_queries.bump_range_check(&G::from_u8(__z_bytes[2]), &G::from_u8(__z_bytes[3])); } __result }; @@ -19543,21 +19269,21 @@ fn aiur_fn_200( let __v_6: G = G::from_u64(0); let __v_7: G = G::from_u64(0); let __v_8: G = { let __values: [G; 4] = [__v_5, __v_6, __v_7, __v_7]; let __mq = record.memory_queries.get_mut(&4).ok_or(ExecError::InvalidMemorySize(4))?; if let Some(result) = __mq.get_mut(&__values[..]) { if !unconstrained { *result.multiplicity += G::ONE; } result.output[0] } else { let __ptr = G::from_usize(__mq.len()); __mq.insert(&__values[..], &[__ptr], G::from_bool(!unconstrained)); __ptr } }; - let __ret: [G; OUT_200] = [__v_4, __v_8]; - if let Some(result) = record.function_queries[200].get_mut(&inp[..]) { debug_assert_eq!(result.output, &__ret[..]); if !unconstrained { *result.multiplicity += G::ONE; } } else { record.function_queries[200].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained)); }; + let __ret: [G; OUT_196] = [__v_4, __v_8]; + if let Some(result) = record.function_queries[196].get_mut(&inp[..]) { debug_assert_eq!(result.output, &__ret[..]); if !unconstrained { *result.multiplicity += G::ONE; } } else { record.function_queries[196].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained)); }; return Ok(__ret); }, _ => { let __v_4: G = G::from_u64(0); - let __r_arr: [G; OUT_766] = { let __args: [G; IN_766] = [__v_0, __v_4]; let __cu = unconstrained; if let Some(result) = record.function_queries[766].get_mut(&__args[..]) { if !__cu && *result.multiplicity == G::ZERO { aiur_fn_766(__args, record, io_buffer, false)? } else { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_766] = unsafe { *(result.output.as_ptr() as *const [G; OUT_766]) }; __ret } } else { aiur_fn_766(__args, record, io_buffer, __cu)? } }; + let __r_arr: [G; OUT_762] = { let __args: [G; IN_762] = [__v_0, __v_4]; let __cu = unconstrained; if let Some(result) = record.function_queries[762].get_mut(&__args[..]) { if !__cu && *result.multiplicity == G::ZERO { aiur_fn_762(__args, record, io_buffer, false)? } else { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_762] = unsafe { *(result.output.as_ptr() as *const [G; OUT_762]) }; __ret } } else { aiur_fn_762(__args, record, io_buffer, __cu)? } }; let __v_5: G = __r_arr[0]; let __v_6: G = G::from_u64(1); - let __r_arr: [G; OUT_766] = { let __args: [G; IN_766] = [__v_0, __v_6]; let __cu = unconstrained; if let Some(result) = record.function_queries[766].get_mut(&__args[..]) { if !__cu && *result.multiplicity == G::ZERO { aiur_fn_766(__args, record, io_buffer, false)? } else { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_766] = unsafe { *(result.output.as_ptr() as *const [G; OUT_766]) }; __ret } } else { aiur_fn_766(__args, record, io_buffer, __cu)? } }; + let __r_arr: [G; OUT_762] = { let __args: [G; IN_762] = [__v_0, __v_6]; let __cu = unconstrained; if let Some(result) = record.function_queries[762].get_mut(&__args[..]) { if !__cu && *result.multiplicity == G::ZERO { aiur_fn_762(__args, record, io_buffer, false)? } else { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_762] = unsafe { *(result.output.as_ptr() as *const [G; OUT_762]) }; __ret } } else { aiur_fn_762(__args, record, io_buffer, __cu)? } }; let __v_7: G = __r_arr[0]; let __v_8: G = G::from_u64(2); - let __r_arr: [G; OUT_766] = { let __args: [G; IN_766] = [__v_0, __v_8]; let __cu = unconstrained; if let Some(result) = record.function_queries[766].get_mut(&__args[..]) { if !__cu && *result.multiplicity == G::ZERO { aiur_fn_766(__args, record, io_buffer, false)? } else { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_766] = unsafe { *(result.output.as_ptr() as *const [G; OUT_766]) }; __ret } } else { aiur_fn_766(__args, record, io_buffer, __cu)? } }; + let __r_arr: [G; OUT_762] = { let __args: [G; IN_762] = [__v_0, __v_8]; let __cu = unconstrained; if let Some(result) = record.function_queries[762].get_mut(&__args[..]) { if !__cu && *result.multiplicity == G::ZERO { aiur_fn_762(__args, record, io_buffer, false)? } else { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_762] = unsafe { *(result.output.as_ptr() as *const [G; OUT_762]) }; __ret } } else { aiur_fn_762(__args, record, io_buffer, __cu)? } }; let __v_9: G = __r_arr[0]; - let __r_arr: [G; OUT_199] = { let __args: [G; IN_199] = [__v_5, __v_7]; let __cu = unconstrained; if let Some(result) = record.function_queries[199].get_mut(&__args[..]) { if !__cu && *result.multiplicity == G::ZERO { aiur_fn_199(__args, record, io_buffer, false)? } else { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_199] = unsafe { *(result.output.as_ptr() as *const [G; OUT_199]) }; __ret } } else { aiur_fn_199(__args, record, io_buffer, __cu)? } }; + let __r_arr: [G; OUT_195] = { let __args: [G; IN_195] = [__v_5, __v_7]; let __cu = unconstrained; if let Some(result) = record.function_queries[195].get_mut(&__args[..]) { if !__cu && *result.multiplicity == G::ZERO { aiur_fn_195(__args, record, io_buffer, false)? } else { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_195] = unsafe { *(result.output.as_ptr() as *const [G; OUT_195]) }; __ret } } else { aiur_fn_195(__args, record, io_buffer, __cu)? } }; let __v_10: G = __r_arr[0]; let __v_11: G = __r_arr[1]; match __v_10.as_canonical_u64() { @@ -19567,12 +19293,12 @@ fn aiur_fn_200( let __v_14: G = G::from_u64(0); let __v_15: G = G::from_u64(0); let __v_16: G = { let __values: [G; 4] = [__v_13, __v_14, __v_15, __v_15]; let __mq = record.memory_queries.get_mut(&4).ok_or(ExecError::InvalidMemorySize(4))?; if let Some(result) = __mq.get_mut(&__values[..]) { if !unconstrained { *result.multiplicity += G::ONE; } result.output[0] } else { let __ptr = G::from_usize(__mq.len()); __mq.insert(&__values[..], &[__ptr], G::from_bool(!unconstrained)); __ptr } }; - let __ret: [G; OUT_200] = [__v_12, __v_16]; - if let Some(result) = record.function_queries[200].get_mut(&inp[..]) { debug_assert_eq!(result.output, &__ret[..]); if !unconstrained { *result.multiplicity += G::ONE; } } else { record.function_queries[200].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained)); }; + let __ret: [G; OUT_196] = [__v_12, __v_16]; + if let Some(result) = record.function_queries[196].get_mut(&inp[..]) { debug_assert_eq!(result.output, &__ret[..]); if !unconstrained { *result.multiplicity += G::ONE; } } else { record.function_queries[196].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained)); }; return Ok(__ret); }, 1u64 => { - let __r_arr: [G; OUT_199] = { let __args: [G; IN_199] = [__v_5, __v_9]; let __cu = unconstrained; if let Some(result) = record.function_queries[199].get_mut(&__args[..]) { if !__cu && *result.multiplicity == G::ZERO { aiur_fn_199(__args, record, io_buffer, false)? } else { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_199] = unsafe { *(result.output.as_ptr() as *const [G; OUT_199]) }; __ret } } else { aiur_fn_199(__args, record, io_buffer, __cu)? } }; + let __r_arr: [G; OUT_195] = { let __args: [G; IN_195] = [__v_5, __v_9]; let __cu = unconstrained; if let Some(result) = record.function_queries[195].get_mut(&__args[..]) { if !__cu && *result.multiplicity == G::ZERO { aiur_fn_195(__args, record, io_buffer, false)? } else { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_195] = unsafe { *(result.output.as_ptr() as *const [G; OUT_195]) }; __ret } } else { aiur_fn_195(__args, record, io_buffer, __cu)? } }; let __v_12: G = __r_arr[0]; let __v_13: G = __r_arr[1]; match __v_12.as_canonical_u64() { @@ -19582,8 +19308,8 @@ fn aiur_fn_200( let __v_16: G = G::from_u64(0); let __v_17: G = G::from_u64(0); let __v_18: G = { let __values: [G; 4] = [__v_15, __v_16, __v_17, __v_17]; let __mq = record.memory_queries.get_mut(&4).ok_or(ExecError::InvalidMemorySize(4))?; if let Some(result) = __mq.get_mut(&__values[..]) { if !unconstrained { *result.multiplicity += G::ONE; } result.output[0] } else { let __ptr = G::from_usize(__mq.len()); __mq.insert(&__values[..], &[__ptr], G::from_bool(!unconstrained)); __ptr } }; - let __ret: [G; OUT_200] = [__v_14, __v_18]; - if let Some(result) = record.function_queries[200].get_mut(&inp[..]) { debug_assert_eq!(result.output, &__ret[..]); if !unconstrained { *result.multiplicity += G::ONE; } } else { record.function_queries[200].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained)); }; + let __ret: [G; OUT_196] = [__v_14, __v_18]; + if let Some(result) = record.function_queries[196].get_mut(&inp[..]) { debug_assert_eq!(result.output, &__ret[..]); if !unconstrained { *result.multiplicity += G::ONE; } } else { record.function_queries[196].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained)); }; return Ok(__ret); }, 1u64 => { @@ -19592,10 +19318,10 @@ fn aiur_fn_200( let __v_15: G = __r_arr[0]; let __v_16: G = (__v_14 - __v_15); let __v_17: G = G::from_u64(1); - let __r_arr: [G; OUT_198] = { let __args: [G; IN_198] = [__v_16]; let __cu = unconstrained; if let Some(result) = record.function_queries[198].get_mut(&__args[..]) { if !__cu && *result.multiplicity == G::ZERO { aiur_fn_198(__args, record, io_buffer, false)? } else { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_198] = unsafe { *(result.output.as_ptr() as *const [G; OUT_198]) }; __ret } } else { aiur_fn_198(__args, record, io_buffer, __cu)? } }; + let __r_arr: [G; OUT_194] = { let __args: [G; IN_194] = [__v_16]; let __cu = unconstrained; if let Some(result) = record.function_queries[194].get_mut(&__args[..]) { if !__cu && *result.multiplicity == G::ZERO { aiur_fn_194(__args, record, io_buffer, false)? } else { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_194] = unsafe { *(result.output.as_ptr() as *const [G; OUT_194]) }; __ret } } else { aiur_fn_194(__args, record, io_buffer, __cu)? } }; let __v_18: G = __r_arr[0]; - let __ret: [G; OUT_200] = [__v_17, __v_18]; - if let Some(result) = record.function_queries[200].get_mut(&inp[..]) { debug_assert_eq!(result.output, &__ret[..]); if !unconstrained { *result.multiplicity += G::ONE; } } else { record.function_queries[200].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained)); }; + let __ret: [G; OUT_196] = [__v_17, __v_18]; + if let Some(result) = record.function_queries[196].get_mut(&inp[..]) { debug_assert_eq!(result.output, &__ret[..]); if !unconstrained { *result.multiplicity += G::ONE; } } else { record.function_queries[196].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained)); }; return Ok(__ret); }, _ => { @@ -19612,18 +19338,18 @@ fn aiur_fn_200( }) } -const INPUT_SIZE_201: usize = 1; -const IN_201: usize = 1; -const OUT_201: usize = 2; -fn aiur_fn_201( - inp: [G; IN_201], +const INPUT_SIZE_197: usize = 1; +const IN_197: usize = 1; +const OUT_197: usize = 2; +fn aiur_fn_197( + inp: [G; IN_197], record: &mut QueryRecord, io_buffer: &mut IOBuffer, unconstrained: bool, -) -> Result<[G; OUT_201], ExecError> { +) -> Result<[G; OUT_197], ExecError> { stacker::maybe_grow(64 * 1024, 4 * 1024 * 1024, || { let __v_0: G = inp[0]; - let __r_arr: [G; OUT_764] = { let __args: [G; IN_764] = [__v_0]; let __cu = unconstrained; if let Some(result) = record.function_queries[764].get_mut(&__args[..]) { if !__cu && *result.multiplicity == G::ZERO { aiur_fn_764(__args, record, io_buffer, false)? } else { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_764] = unsafe { *(result.output.as_ptr() as *const [G; OUT_764]) }; __ret } } else { aiur_fn_764(__args, record, io_buffer, __cu)? } }; + let __r_arr: [G; OUT_760] = { let __args: [G; IN_760] = [__v_0]; let __cu = unconstrained; if let Some(result) = record.function_queries[760].get_mut(&__args[..]) { if !__cu && *result.multiplicity == G::ZERO { aiur_fn_760(__args, record, io_buffer, false)? } else { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_760] = unsafe { *(result.output.as_ptr() as *const [G; OUT_760]) }; __ret } } else { aiur_fn_760(__args, record, io_buffer, __cu)? } }; let __v_1: G = __r_arr[0]; let __v_2: G = G::from_u64(2); let __v_3: G = { let __a_val = __v_1.as_canonical_u64(); let __b_val = __v_2.as_canonical_u64(); let __a_u32 = u32::try_from(__a_val).ok().ok_or(ExecError::U32OutOfRange(__a_val))?; let __b_u32 = u32::try_from(__b_val).ok().ok_or(ExecError::U32OutOfRange(__b_val))?; let __result = G::from_bool(__a_u32 < __b_u32); if !unconstrained { let __x_bytes = __a_u32.to_le_bytes(); let __z_bytes = __b_u32.to_le_bytes(); let __c_u32 = __b_u32.wrapping_sub(__a_u32).wrapping_sub(1); let __y_bytes = __c_u32.to_le_bytes(); record.bytes2_queries.bump_range_check(&G::from_u8(__x_bytes[0]), &G::from_u8(__x_bytes[1])); record.bytes2_queries.bump_range_check(&G::from_u8(__x_bytes[2]), &G::from_u8(__x_bytes[3])); record.bytes2_queries.bump_range_check(&G::from_u8(__y_bytes[0]), &G::from_u8(__y_bytes[1])); record.bytes2_queries.bump_range_check(&G::from_u8(__y_bytes[2]), &G::from_u8(__y_bytes[3])); record.bytes2_queries.bump_range_check(&G::from_u8(__z_bytes[0]), &G::from_u8(__z_bytes[1])); record.bytes2_queries.bump_range_check(&G::from_u8(__z_bytes[2]), &G::from_u8(__z_bytes[3])); } __result }; @@ -19634,13 +19360,13 @@ fn aiur_fn_201( let __v_6: G = G::from_u64(0); let __v_7: G = G::from_u64(0); let __v_8: G = { let __values: [G; 4] = [__v_5, __v_6, __v_7, __v_7]; let __mq = record.memory_queries.get_mut(&4).ok_or(ExecError::InvalidMemorySize(4))?; if let Some(result) = __mq.get_mut(&__values[..]) { if !unconstrained { *result.multiplicity += G::ONE; } result.output[0] } else { let __ptr = G::from_usize(__mq.len()); __mq.insert(&__values[..], &[__ptr], G::from_bool(!unconstrained)); __ptr } }; - let __ret: [G; OUT_201] = [__v_4, __v_8]; - if let Some(result) = record.function_queries[201].get_mut(&inp[..]) { debug_assert_eq!(result.output, &__ret[..]); if !unconstrained { *result.multiplicity += G::ONE; } } else { record.function_queries[201].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained)); }; + let __ret: [G; OUT_197] = [__v_4, __v_8]; + if let Some(result) = record.function_queries[197].get_mut(&inp[..]) { debug_assert_eq!(result.output, &__ret[..]); if !unconstrained { *result.multiplicity += G::ONE; } } else { record.function_queries[197].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained)); }; return Ok(__ret); }, _ => { let __v_4: G = G::from_u64(0); - let __r_arr: [G; OUT_766] = { let __args: [G; IN_766] = [__v_0, __v_4]; let __cu = unconstrained; if let Some(result) = record.function_queries[766].get_mut(&__args[..]) { if !__cu && *result.multiplicity == G::ZERO { aiur_fn_766(__args, record, io_buffer, false)? } else { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_766] = unsafe { *(result.output.as_ptr() as *const [G; OUT_766]) }; __ret } } else { aiur_fn_766(__args, record, io_buffer, __cu)? } }; + let __r_arr: [G; OUT_762] = { let __args: [G; IN_762] = [__v_0, __v_4]; let __cu = unconstrained; if let Some(result) = record.function_queries[762].get_mut(&__args[..]) { if !__cu && *result.multiplicity == G::ZERO { aiur_fn_762(__args, record, io_buffer, false)? } else { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_762] = unsafe { *(result.output.as_ptr() as *const [G; OUT_762]) }; __ret } } else { aiur_fn_762(__args, record, io_buffer, __cu)? } }; let __v_5: G = __r_arr[0]; let __r_arr: [G; OUT_111] = { let __args: [G; IN_111] = [__v_5]; let __cu = unconstrained; if let Some(result) = record.function_queries[111].get_mut(&__args[..]) { if !__cu && *result.multiplicity == G::ZERO { aiur_fn_111(__args, record, io_buffer, false)? } else { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_111] = unsafe { *(result.output.as_ptr() as *const [G; OUT_111]) }; __ret } } else { aiur_fn_111(__args, record, io_buffer, __cu)? } }; let __v_6: G = __r_arr[0]; @@ -19652,7 +19378,7 @@ fn aiur_fn_201( let __v_11: G = __loaded[3]; match __v_8.as_canonical_u64() { 2u64 => { - let __r_arr: [G; OUT_196] = { let __args: [G; IN_196] = []; let __cu = unconstrained; if let Some(result) = record.function_queries[196].get_mut(&__args[..]) { if !__cu && *result.multiplicity == G::ZERO { aiur_fn_196(__args, record, io_buffer, false)? } else { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_196] = unsafe { *(result.output.as_ptr() as *const [G; OUT_196]) }; __ret } } else { aiur_fn_196(__args, record, io_buffer, __cu)? } }; + let __r_arr: [G; OUT_192] = { let __args: [G; IN_192] = []; let __cu = unconstrained; if let Some(result) = record.function_queries[192].get_mut(&__args[..]) { if !__cu && *result.multiplicity == G::ZERO { aiur_fn_192(__args, record, io_buffer, false)? } else { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_192] = unsafe { *(result.output.as_ptr() as *const [G; OUT_192]) }; __ret } } else { aiur_fn_192(__args, record, io_buffer, __cu)? } }; let __v_12: G = __r_arr[0]; let __r_arr: [G; OUT_1] = { let __args: [G; IN_1] = [__v_9, __v_12]; let __cu = unconstrained; if let Some(result) = record.function_queries[1].get_mut(&__args[..]) { if !__cu && *result.multiplicity == G::ZERO { aiur_fn_1(__args, record, io_buffer, false)? } else { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_1] = unsafe { *(result.output.as_ptr() as *const [G; OUT_1]) }; __ret } } else { aiur_fn_1(__args, record, io_buffer, __cu)? } }; let __v_13: G = __r_arr[0]; @@ -19663,12 +19389,12 @@ fn aiur_fn_201( let __v_16: G = G::from_u64(0); let __v_17: G = G::from_u64(0); let __v_18: G = { let __values: [G; 4] = [__v_15, __v_16, __v_17, __v_17]; let __mq = record.memory_queries.get_mut(&4).ok_or(ExecError::InvalidMemorySize(4))?; if let Some(result) = __mq.get_mut(&__values[..]) { if !unconstrained { *result.multiplicity += G::ONE; } result.output[0] } else { let __ptr = G::from_usize(__mq.len()); __mq.insert(&__values[..], &[__ptr], G::from_bool(!unconstrained)); __ptr } }; - let __ret: [G; OUT_201] = [__v_14, __v_18]; - if let Some(result) = record.function_queries[201].get_mut(&inp[..]) { debug_assert_eq!(result.output, &__ret[..]); if !unconstrained { *result.multiplicity += G::ONE; } } else { record.function_queries[201].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained)); }; + let __ret: [G; OUT_197] = [__v_14, __v_18]; + if let Some(result) = record.function_queries[197].get_mut(&inp[..]) { debug_assert_eq!(result.output, &__ret[..]); if !unconstrained { *result.multiplicity += G::ONE; } } else { record.function_queries[197].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained)); }; return Ok(__ret); }, _ => { - let __r_arr: [G; OUT_764] = { let __args: [G; IN_764] = [__v_7]; let __cu = unconstrained; if let Some(result) = record.function_queries[764].get_mut(&__args[..]) { if !__cu && *result.multiplicity == G::ZERO { aiur_fn_764(__args, record, io_buffer, false)? } else { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_764] = unsafe { *(result.output.as_ptr() as *const [G; OUT_764]) }; __ret } } else { aiur_fn_764(__args, record, io_buffer, __cu)? } }; + let __r_arr: [G; OUT_760] = { let __args: [G; IN_760] = [__v_7]; let __cu = unconstrained; if let Some(result) = record.function_queries[760].get_mut(&__args[..]) { if !__cu && *result.multiplicity == G::ZERO { aiur_fn_760(__args, record, io_buffer, false)? } else { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_760] = unsafe { *(result.output.as_ptr() as *const [G; OUT_760]) }; __ret } } else { aiur_fn_760(__args, record, io_buffer, __cu)? } }; let __v_14: G = __r_arr[0]; let __v_15: G = G::from_u64(4); let __v_16: G = { let __a_val = __v_14.as_canonical_u64(); let __b_val = __v_15.as_canonical_u64(); let __a_u32 = u32::try_from(__a_val).ok().ok_or(ExecError::U32OutOfRange(__a_val))?; let __b_u32 = u32::try_from(__b_val).ok().ok_or(ExecError::U32OutOfRange(__b_val))?; let __result = G::from_bool(__a_u32 < __b_u32); if !unconstrained { let __x_bytes = __a_u32.to_le_bytes(); let __z_bytes = __b_u32.to_le_bytes(); let __c_u32 = __b_u32.wrapping_sub(__a_u32).wrapping_sub(1); let __y_bytes = __c_u32.to_le_bytes(); record.bytes2_queries.bump_range_check(&G::from_u8(__x_bytes[0]), &G::from_u8(__x_bytes[1])); record.bytes2_queries.bump_range_check(&G::from_u8(__x_bytes[2]), &G::from_u8(__x_bytes[3])); record.bytes2_queries.bump_range_check(&G::from_u8(__y_bytes[0]), &G::from_u8(__y_bytes[1])); record.bytes2_queries.bump_range_check(&G::from_u8(__y_bytes[2]), &G::from_u8(__y_bytes[3])); record.bytes2_queries.bump_range_check(&G::from_u8(__z_bytes[0]), &G::from_u8(__z_bytes[1])); record.bytes2_queries.bump_range_check(&G::from_u8(__z_bytes[2]), &G::from_u8(__z_bytes[3])); } __result }; @@ -19679,13 +19405,13 @@ fn aiur_fn_201( let __v_19: G = G::from_u64(0); let __v_20: G = G::from_u64(0); let __v_21: G = { let __values: [G; 4] = [__v_18, __v_19, __v_20, __v_20]; let __mq = record.memory_queries.get_mut(&4).ok_or(ExecError::InvalidMemorySize(4))?; if let Some(result) = __mq.get_mut(&__values[..]) { if !unconstrained { *result.multiplicity += G::ONE; } result.output[0] } else { let __ptr = G::from_usize(__mq.len()); __mq.insert(&__values[..], &[__ptr], G::from_bool(!unconstrained)); __ptr } }; - let __ret: [G; OUT_201] = [__v_17, __v_21]; - if let Some(result) = record.function_queries[201].get_mut(&inp[..]) { debug_assert_eq!(result.output, &__ret[..]); if !unconstrained { *result.multiplicity += G::ONE; } } else { record.function_queries[201].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained)); }; + let __ret: [G; OUT_197] = [__v_17, __v_21]; + if let Some(result) = record.function_queries[197].get_mut(&inp[..]) { debug_assert_eq!(result.output, &__ret[..]); if !unconstrained { *result.multiplicity += G::ONE; } } else { record.function_queries[197].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained)); }; return Ok(__ret); }, _ => { let __v_17: G = G::from_u64(0); - let __r_arr: [G; OUT_766] = { let __args: [G; IN_766] = [__v_7, __v_17]; let __cu = unconstrained; if let Some(result) = record.function_queries[766].get_mut(&__args[..]) { if !__cu && *result.multiplicity == G::ZERO { aiur_fn_766(__args, record, io_buffer, false)? } else { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_766] = unsafe { *(result.output.as_ptr() as *const [G; OUT_766]) }; __ret } } else { aiur_fn_766(__args, record, io_buffer, __cu)? } }; + let __r_arr: [G; OUT_762] = { let __args: [G; IN_762] = [__v_7, __v_17]; let __cu = unconstrained; if let Some(result) = record.function_queries[762].get_mut(&__args[..]) { if !__cu && *result.multiplicity == G::ZERO { aiur_fn_762(__args, record, io_buffer, false)? } else { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_762] = unsafe { *(result.output.as_ptr() as *const [G; OUT_762]) }; __ret } } else { aiur_fn_762(__args, record, io_buffer, __cu)? } }; let __v_18: G = __r_arr[0]; let __r_arr: [G; OUT_111] = { let __args: [G; IN_111] = [__v_18]; let __cu = unconstrained; if let Some(result) = record.function_queries[111].get_mut(&__args[..]) { if !__cu && *result.multiplicity == G::ZERO { aiur_fn_111(__args, record, io_buffer, false)? } else { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_111] = unsafe { *(result.output.as_ptr() as *const [G; OUT_111]) }; __ret } } else { aiur_fn_111(__args, record, io_buffer, __cu)? } }; let __v_19: G = __r_arr[0]; @@ -19697,7 +19423,7 @@ fn aiur_fn_201( let __v_24: G = __loaded[3]; match __v_21.as_canonical_u64() { 2u64 => { - let __r_arr: [G; OUT_193] = { let __args: [G; IN_193] = []; let __cu = unconstrained; if let Some(result) = record.function_queries[193].get_mut(&__args[..]) { if !__cu && *result.multiplicity == G::ZERO { aiur_fn_193(__args, record, io_buffer, false)? } else { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_193] = unsafe { *(result.output.as_ptr() as *const [G; OUT_193]) }; __ret } } else { aiur_fn_193(__args, record, io_buffer, __cu)? } }; + let __r_arr: [G; OUT_189] = { let __args: [G; IN_189] = []; let __cu = unconstrained; if let Some(result) = record.function_queries[189].get_mut(&__args[..]) { if !__cu && *result.multiplicity == G::ZERO { aiur_fn_189(__args, record, io_buffer, false)? } else { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_189] = unsafe { *(result.output.as_ptr() as *const [G; OUT_189]) }; __ret } } else { aiur_fn_189(__args, record, io_buffer, __cu)? } }; let __v_25: G = __r_arr[0]; let __r_arr: [G; OUT_1] = { let __args: [G; IN_1] = [__v_22, __v_25]; let __cu = unconstrained; if let Some(result) = record.function_queries[1].get_mut(&__args[..]) { if !__cu && *result.multiplicity == G::ZERO { aiur_fn_1(__args, record, io_buffer, false)? } else { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_1] = unsafe { *(result.output.as_ptr() as *const [G; OUT_1]) }; __ret } } else { aiur_fn_1(__args, record, io_buffer, __cu)? } }; let __v_26: G = __r_arr[0]; @@ -19708,12 +19434,12 @@ fn aiur_fn_201( let __v_29: G = G::from_u64(0); let __v_30: G = G::from_u64(0); let __v_31: G = { let __values: [G; 4] = [__v_28, __v_29, __v_30, __v_30]; let __mq = record.memory_queries.get_mut(&4).ok_or(ExecError::InvalidMemorySize(4))?; if let Some(result) = __mq.get_mut(&__values[..]) { if !unconstrained { *result.multiplicity += G::ONE; } result.output[0] } else { let __ptr = G::from_usize(__mq.len()); __mq.insert(&__values[..], &[__ptr], G::from_bool(!unconstrained)); __ptr } }; - let __ret: [G; OUT_201] = [__v_27, __v_31]; - if let Some(result) = record.function_queries[201].get_mut(&inp[..]) { debug_assert_eq!(result.output, &__ret[..]); if !unconstrained { *result.multiplicity += G::ONE; } } else { record.function_queries[201].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained)); }; + let __ret: [G; OUT_197] = [__v_27, __v_31]; + if let Some(result) = record.function_queries[197].get_mut(&inp[..]) { debug_assert_eq!(result.output, &__ret[..]); if !unconstrained { *result.multiplicity += G::ONE; } } else { record.function_queries[197].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained)); }; return Ok(__ret); }, _ => { - let __r_arr: [G; OUT_764] = { let __args: [G; IN_764] = [__v_20]; let __cu = unconstrained; if let Some(result) = record.function_queries[764].get_mut(&__args[..]) { if !__cu && *result.multiplicity == G::ZERO { aiur_fn_764(__args, record, io_buffer, false)? } else { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_764] = unsafe { *(result.output.as_ptr() as *const [G; OUT_764]) }; __ret } } else { aiur_fn_764(__args, record, io_buffer, __cu)? } }; + let __r_arr: [G; OUT_760] = { let __args: [G; IN_760] = [__v_20]; let __cu = unconstrained; if let Some(result) = record.function_queries[760].get_mut(&__args[..]) { if !__cu && *result.multiplicity == G::ZERO { aiur_fn_760(__args, record, io_buffer, false)? } else { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_760] = unsafe { *(result.output.as_ptr() as *const [G; OUT_760]) }; __ret } } else { aiur_fn_760(__args, record, io_buffer, __cu)? } }; let __v_27: G = __r_arr[0]; let __v_28: G = G::from_u64(1); let __v_29: G = { let __a_val = __v_27.as_canonical_u64(); let __b_val = __v_28.as_canonical_u64(); let __a_u32 = u32::try_from(__a_val).ok().ok_or(ExecError::U32OutOfRange(__a_val))?; let __b_u32 = u32::try_from(__b_val).ok().ok_or(ExecError::U32OutOfRange(__b_val))?; let __result = G::from_bool(__a_u32 < __b_u32); if !unconstrained { let __x_bytes = __a_u32.to_le_bytes(); let __z_bytes = __b_u32.to_le_bytes(); let __c_u32 = __b_u32.wrapping_sub(__a_u32).wrapping_sub(1); let __y_bytes = __c_u32.to_le_bytes(); record.bytes2_queries.bump_range_check(&G::from_u8(__x_bytes[0]), &G::from_u8(__x_bytes[1])); record.bytes2_queries.bump_range_check(&G::from_u8(__x_bytes[2]), &G::from_u8(__x_bytes[3])); record.bytes2_queries.bump_range_check(&G::from_u8(__y_bytes[0]), &G::from_u8(__y_bytes[1])); record.bytes2_queries.bump_range_check(&G::from_u8(__y_bytes[2]), &G::from_u8(__y_bytes[3])); record.bytes2_queries.bump_range_check(&G::from_u8(__z_bytes[0]), &G::from_u8(__z_bytes[1])); record.bytes2_queries.bump_range_check(&G::from_u8(__z_bytes[2]), &G::from_u8(__z_bytes[3])); } __result }; @@ -19724,19 +19450,19 @@ fn aiur_fn_201( let __v_32: G = G::from_u64(0); let __v_33: G = G::from_u64(0); let __v_34: G = { let __values: [G; 4] = [__v_31, __v_32, __v_33, __v_33]; let __mq = record.memory_queries.get_mut(&4).ok_or(ExecError::InvalidMemorySize(4))?; if let Some(result) = __mq.get_mut(&__values[..]) { if !unconstrained { *result.multiplicity += G::ONE; } result.output[0] } else { let __ptr = G::from_usize(__mq.len()); __mq.insert(&__values[..], &[__ptr], G::from_bool(!unconstrained)); __ptr } }; - let __ret: [G; OUT_201] = [__v_30, __v_34]; - if let Some(result) = record.function_queries[201].get_mut(&inp[..]) { debug_assert_eq!(result.output, &__ret[..]); if !unconstrained { *result.multiplicity += G::ONE; } } else { record.function_queries[201].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained)); }; + let __ret: [G; OUT_197] = [__v_30, __v_34]; + if let Some(result) = record.function_queries[197].get_mut(&inp[..]) { debug_assert_eq!(result.output, &__ret[..]); if !unconstrained { *result.multiplicity += G::ONE; } } else { record.function_queries[197].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained)); }; return Ok(__ret); }, _ => { let __v_30: G = G::from_u64(0); - let __r_arr: [G; OUT_766] = { let __args: [G; IN_766] = [__v_20, __v_30]; let __cu = unconstrained; if let Some(result) = record.function_queries[766].get_mut(&__args[..]) { if !__cu && *result.multiplicity == G::ZERO { aiur_fn_766(__args, record, io_buffer, false)? } else { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_766] = unsafe { *(result.output.as_ptr() as *const [G; OUT_766]) }; __ret } } else { aiur_fn_766(__args, record, io_buffer, __cu)? } }; + let __r_arr: [G; OUT_762] = { let __args: [G; IN_762] = [__v_20, __v_30]; let __cu = unconstrained; if let Some(result) = record.function_queries[762].get_mut(&__args[..]) { if !__cu && *result.multiplicity == G::ZERO { aiur_fn_762(__args, record, io_buffer, false)? } else { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_762] = unsafe { *(result.output.as_ptr() as *const [G; OUT_762]) }; __ret } } else { aiur_fn_762(__args, record, io_buffer, __cu)? } }; let __v_31: G = __r_arr[0]; let __v_32: G = G::from_u64(2); - let __r_arr: [G; OUT_766] = { let __args: [G; IN_766] = [__v_7, __v_32]; let __cu = unconstrained; if let Some(result) = record.function_queries[766].get_mut(&__args[..]) { if !__cu && *result.multiplicity == G::ZERO { aiur_fn_766(__args, record, io_buffer, false)? } else { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_766] = unsafe { *(result.output.as_ptr() as *const [G; OUT_766]) }; __ret } } else { aiur_fn_766(__args, record, io_buffer, __cu)? } }; + let __r_arr: [G; OUT_762] = { let __args: [G; IN_762] = [__v_7, __v_32]; let __cu = unconstrained; if let Some(result) = record.function_queries[762].get_mut(&__args[..]) { if !__cu && *result.multiplicity == G::ZERO { aiur_fn_762(__args, record, io_buffer, false)? } else { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_762] = unsafe { *(result.output.as_ptr() as *const [G; OUT_762]) }; __ret } } else { aiur_fn_762(__args, record, io_buffer, __cu)? } }; let __v_33: G = __r_arr[0]; let __v_34: G = G::from_u64(3); - let __r_arr: [G; OUT_766] = { let __args: [G; IN_766] = [__v_7, __v_34]; let __cu = unconstrained; if let Some(result) = record.function_queries[766].get_mut(&__args[..]) { if !__cu && *result.multiplicity == G::ZERO { aiur_fn_766(__args, record, io_buffer, false)? } else { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_766] = unsafe { *(result.output.as_ptr() as *const [G; OUT_766]) }; __ret } } else { aiur_fn_766(__args, record, io_buffer, __cu)? } }; + let __r_arr: [G; OUT_762] = { let __args: [G; IN_762] = [__v_7, __v_34]; let __cu = unconstrained; if let Some(result) = record.function_queries[762].get_mut(&__args[..]) { if !__cu && *result.multiplicity == G::ZERO { aiur_fn_762(__args, record, io_buffer, false)? } else { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_762] = unsafe { *(result.output.as_ptr() as *const [G; OUT_762]) }; __ret } } else { aiur_fn_762(__args, record, io_buffer, __cu)? } }; let __v_35: G = __r_arr[0]; let __v_36: G = G::from_u64(0); let __v_37: G = G::from_u64(0); @@ -19747,11 +19473,11 @@ fn aiur_fn_201( let __v_42: G = { let __values: [G; 3] = [__v_38, __v_35, __v_41]; let __mq = record.memory_queries.get_mut(&3).ok_or(ExecError::InvalidMemorySize(3))?; if let Some(result) = __mq.get_mut(&__values[..]) { if !unconstrained { *result.multiplicity += G::ONE; } result.output[0] } else { let __ptr = G::from_usize(__mq.len()); __mq.insert(&__values[..], &[__ptr], G::from_bool(!unconstrained)); __ptr } }; let __v_43: G = { let __values: [G; 3] = [__v_37, __v_33, __v_42]; let __mq = record.memory_queries.get_mut(&3).ok_or(ExecError::InvalidMemorySize(3))?; if let Some(result) = __mq.get_mut(&__values[..]) { if !unconstrained { *result.multiplicity += G::ONE; } result.output[0] } else { let __ptr = G::from_usize(__mq.len()); __mq.insert(&__values[..], &[__ptr], G::from_bool(!unconstrained)); __ptr } }; let __v_44: G = { let __values: [G; 3] = [__v_36, __v_31, __v_43]; let __mq = record.memory_queries.get_mut(&3).ok_or(ExecError::InvalidMemorySize(3))?; if let Some(result) = __mq.get_mut(&__values[..]) { if !unconstrained { *result.multiplicity += G::ONE; } result.output[0] } else { let __ptr = G::from_usize(__mq.len()); __mq.insert(&__values[..], &[__ptr], G::from_bool(!unconstrained)); __ptr } }; - let __r_arr: [G; OUT_200] = { let __args: [G; IN_200] = [__v_44]; let __cu = unconstrained; if let Some(result) = record.function_queries[200].get_mut(&__args[..]) { if !__cu && *result.multiplicity == G::ZERO { aiur_fn_200(__args, record, io_buffer, false)? } else { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_200] = unsafe { *(result.output.as_ptr() as *const [G; OUT_200]) }; __ret } } else { aiur_fn_200(__args, record, io_buffer, __cu)? } }; + let __r_arr: [G; OUT_196] = { let __args: [G; IN_196] = [__v_44]; let __cu = unconstrained; if let Some(result) = record.function_queries[196].get_mut(&__args[..]) { if !__cu && *result.multiplicity == G::ZERO { aiur_fn_196(__args, record, io_buffer, false)? } else { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_196] = unsafe { *(result.output.as_ptr() as *const [G; OUT_196]) }; __ret } } else { aiur_fn_196(__args, record, io_buffer, __cu)? } }; let __v_45: G = __r_arr[0]; let __v_46: G = __r_arr[1]; - let __ret: [G; OUT_201] = [__v_45, __v_46]; - if let Some(result) = record.function_queries[201].get_mut(&inp[..]) { debug_assert_eq!(result.output, &__ret[..]); if !unconstrained { *result.multiplicity += G::ONE; } } else { record.function_queries[201].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained)); }; + let __ret: [G; OUT_197] = [__v_45, __v_46]; + if let Some(result) = record.function_queries[197].get_mut(&inp[..]) { debug_assert_eq!(result.output, &__ret[..]); if !unconstrained { *result.multiplicity += G::ONE; } } else { record.function_queries[197].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained)); }; return Ok(__ret); }, } @@ -19764,8 +19490,8 @@ fn aiur_fn_201( let __v_27: G = G::from_u64(0); let __v_28: G = G::from_u64(0); let __v_29: G = { let __values: [G; 4] = [__v_26, __v_27, __v_28, __v_28]; let __mq = record.memory_queries.get_mut(&4).ok_or(ExecError::InvalidMemorySize(4))?; if let Some(result) = __mq.get_mut(&__values[..]) { if !unconstrained { *result.multiplicity += G::ONE; } result.output[0] } else { let __ptr = G::from_usize(__mq.len()); __mq.insert(&__values[..], &[__ptr], G::from_bool(!unconstrained)); __ptr } }; - let __ret: [G; OUT_201] = [__v_25, __v_29]; - if let Some(result) = record.function_queries[201].get_mut(&inp[..]) { debug_assert_eq!(result.output, &__ret[..]); if !unconstrained { *result.multiplicity += G::ONE; } } else { record.function_queries[201].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained)); }; + let __ret: [G; OUT_197] = [__v_25, __v_29]; + if let Some(result) = record.function_queries[197].get_mut(&inp[..]) { debug_assert_eq!(result.output, &__ret[..]); if !unconstrained { *result.multiplicity += G::ONE; } } else { record.function_queries[197].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained)); }; return Ok(__ret); }, } @@ -19780,8 +19506,8 @@ fn aiur_fn_201( let __v_14: G = G::from_u64(0); let __v_15: G = G::from_u64(0); let __v_16: G = { let __values: [G; 4] = [__v_13, __v_14, __v_15, __v_15]; let __mq = record.memory_queries.get_mut(&4).ok_or(ExecError::InvalidMemorySize(4))?; if let Some(result) = __mq.get_mut(&__values[..]) { if !unconstrained { *result.multiplicity += G::ONE; } result.output[0] } else { let __ptr = G::from_usize(__mq.len()); __mq.insert(&__values[..], &[__ptr], G::from_bool(!unconstrained)); __ptr } }; - let __ret: [G; OUT_201] = [__v_12, __v_16]; - if let Some(result) = record.function_queries[201].get_mut(&inp[..]) { debug_assert_eq!(result.output, &__ret[..]); if !unconstrained { *result.multiplicity += G::ONE; } } else { record.function_queries[201].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained)); }; + let __ret: [G; OUT_197] = [__v_12, __v_16]; + if let Some(result) = record.function_queries[197].get_mut(&inp[..]) { debug_assert_eq!(result.output, &__ret[..]); if !unconstrained { *result.multiplicity += G::ONE; } } else { record.function_queries[197].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained)); }; return Ok(__ret); }, } @@ -19790,15 +19516,15 @@ fn aiur_fn_201( }) } -const INPUT_SIZE_202: usize = 1; -const IN_202: usize = 1; -const OUT_202: usize = 3; -fn aiur_fn_202( - inp: [G; IN_202], +const INPUT_SIZE_198: usize = 1; +const IN_198: usize = 1; +const OUT_198: usize = 3; +fn aiur_fn_198( + inp: [G; IN_198], record: &mut QueryRecord, io_buffer: &mut IOBuffer, unconstrained: bool, -) -> Result<[G; OUT_202], ExecError> { +) -> Result<[G; OUT_198], ExecError> { stacker::maybe_grow(64 * 1024, 4 * 1024 * 1024, || { let __v_0: G = inp[0]; let __r_arr: [G; OUT_111] = { let __args: [G; IN_111] = [__v_0]; let __cu = unconstrained; if let Some(result) = record.function_queries[111].get_mut(&__args[..]) { if !__cu && *result.multiplicity == G::ZERO { aiur_fn_111(__args, record, io_buffer, false)? } else { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_111] = unsafe { *(result.output.as_ptr() as *const [G; OUT_111]) }; __ret } } else { aiur_fn_111(__args, record, io_buffer, __cu)? } }; @@ -19811,13 +19537,13 @@ fn aiur_fn_202( let __v_6: G = __loaded[3]; match __v_3.as_canonical_u64() { 2u64 => { - let __r_arr: [G; OUT_192] = { let __args: [G; IN_192] = []; let __cu = unconstrained; if let Some(result) = record.function_queries[192].get_mut(&__args[..]) { if !__cu && *result.multiplicity == G::ZERO { aiur_fn_192(__args, record, io_buffer, false)? } else { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_192] = unsafe { *(result.output.as_ptr() as *const [G; OUT_192]) }; __ret } } else { aiur_fn_192(__args, record, io_buffer, __cu)? } }; + let __r_arr: [G; OUT_188] = { let __args: [G; IN_188] = []; let __cu = unconstrained; if let Some(result) = record.function_queries[188].get_mut(&__args[..]) { if !__cu && *result.multiplicity == G::ZERO { aiur_fn_188(__args, record, io_buffer, false)? } else { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_188] = unsafe { *(result.output.as_ptr() as *const [G; OUT_188]) }; __ret } } else { aiur_fn_188(__args, record, io_buffer, __cu)? } }; let __v_7: G = __r_arr[0]; let __r_arr: [G; OUT_1] = { let __args: [G; IN_1] = [__v_4, __v_7]; let __cu = unconstrained; if let Some(result) = record.function_queries[1].get_mut(&__args[..]) { if !__cu && *result.multiplicity == G::ZERO { aiur_fn_1(__args, record, io_buffer, false)? } else { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_1] = unsafe { *(result.output.as_ptr() as *const [G; OUT_1]) }; __ret } } else { aiur_fn_1(__args, record, io_buffer, __cu)? } }; let __v_8: G = __r_arr[0]; match __v_8.as_canonical_u64() { 1u64 => { - let __r_arr: [G; OUT_764] = { let __args: [G; IN_764] = [__v_2]; let __cu = unconstrained; if let Some(result) = record.function_queries[764].get_mut(&__args[..]) { if !__cu && *result.multiplicity == G::ZERO { aiur_fn_764(__args, record, io_buffer, false)? } else { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_764] = unsafe { *(result.output.as_ptr() as *const [G; OUT_764]) }; __ret } } else { aiur_fn_764(__args, record, io_buffer, __cu)? } }; + let __r_arr: [G; OUT_760] = { let __args: [G; IN_760] = [__v_2]; let __cu = unconstrained; if let Some(result) = record.function_queries[760].get_mut(&__args[..]) { if !__cu && *result.multiplicity == G::ZERO { aiur_fn_760(__args, record, io_buffer, false)? } else { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_760] = unsafe { *(result.output.as_ptr() as *const [G; OUT_760]) }; __ret } } else { aiur_fn_760(__args, record, io_buffer, __cu)? } }; let __v_9: G = __r_arr[0]; let __v_10: G = G::from_u64(2); let __v_11: G = (__v_9 - __v_10); @@ -19825,13 +19551,13 @@ fn aiur_fn_202( 0u64 => { let __v_12: G = G::from_u64(1); let __v_13: G = G::from_u64(0); - let __r_arr: [G; OUT_766] = { let __args: [G; IN_766] = [__v_2, __v_13]; let __cu = unconstrained; if let Some(result) = record.function_queries[766].get_mut(&__args[..]) { if !__cu && *result.multiplicity == G::ZERO { aiur_fn_766(__args, record, io_buffer, false)? } else { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_766] = unsafe { *(result.output.as_ptr() as *const [G; OUT_766]) }; __ret } } else { aiur_fn_766(__args, record, io_buffer, __cu)? } }; + let __r_arr: [G; OUT_762] = { let __args: [G; IN_762] = [__v_2, __v_13]; let __cu = unconstrained; if let Some(result) = record.function_queries[762].get_mut(&__args[..]) { if !__cu && *result.multiplicity == G::ZERO { aiur_fn_762(__args, record, io_buffer, false)? } else { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_762] = unsafe { *(result.output.as_ptr() as *const [G; OUT_762]) }; __ret } } else { aiur_fn_762(__args, record, io_buffer, __cu)? } }; let __v_14: G = __r_arr[0]; let __v_15: G = G::from_u64(1); - let __r_arr: [G; OUT_766] = { let __args: [G; IN_766] = [__v_2, __v_15]; let __cu = unconstrained; if let Some(result) = record.function_queries[766].get_mut(&__args[..]) { if !__cu && *result.multiplicity == G::ZERO { aiur_fn_766(__args, record, io_buffer, false)? } else { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_766] = unsafe { *(result.output.as_ptr() as *const [G; OUT_766]) }; __ret } } else { aiur_fn_766(__args, record, io_buffer, __cu)? } }; + let __r_arr: [G; OUT_762] = { let __args: [G; IN_762] = [__v_2, __v_15]; let __cu = unconstrained; if let Some(result) = record.function_queries[762].get_mut(&__args[..]) { if !__cu && *result.multiplicity == G::ZERO { aiur_fn_762(__args, record, io_buffer, false)? } else { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_762] = unsafe { *(result.output.as_ptr() as *const [G; OUT_762]) }; __ret } } else { aiur_fn_762(__args, record, io_buffer, __cu)? } }; let __v_16: G = __r_arr[0]; - let __ret: [G; OUT_202] = [__v_12, __v_14, __v_16]; - if let Some(result) = record.function_queries[202].get_mut(&inp[..]) { debug_assert_eq!(result.output, &__ret[..]); if !unconstrained { *result.multiplicity += G::ONE; } } else { record.function_queries[202].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained)); }; + let __ret: [G; OUT_198] = [__v_12, __v_14, __v_16]; + if let Some(result) = record.function_queries[198].get_mut(&inp[..]) { debug_assert_eq!(result.output, &__ret[..]); if !unconstrained { *result.multiplicity += G::ONE; } } else { record.function_queries[198].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained)); }; return Ok(__ret); }, _ => { @@ -19844,8 +19570,8 @@ fn aiur_fn_202( let __v_18: G = G::from_u64(0); let __v_19: G = G::from_u64(0); let __v_20: G = { let __values: [G; 4] = [__v_17, __v_18, __v_19, __v_19]; let __mq = record.memory_queries.get_mut(&4).ok_or(ExecError::InvalidMemorySize(4))?; if let Some(result) = __mq.get_mut(&__values[..]) { if !unconstrained { *result.multiplicity += G::ONE; } result.output[0] } else { let __ptr = G::from_usize(__mq.len()); __mq.insert(&__values[..], &[__ptr], G::from_bool(!unconstrained)); __ptr } }; - let __ret: [G; OUT_202] = [__v_12, __v_16, __v_20]; - if let Some(result) = record.function_queries[202].get_mut(&inp[..]) { debug_assert_eq!(result.output, &__ret[..]); if !unconstrained { *result.multiplicity += G::ONE; } } else { record.function_queries[202].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained)); }; + let __ret: [G; OUT_198] = [__v_12, __v_16, __v_20]; + if let Some(result) = record.function_queries[198].get_mut(&inp[..]) { debug_assert_eq!(result.output, &__ret[..]); if !unconstrained { *result.multiplicity += G::ONE; } } else { record.function_queries[198].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained)); }; return Ok(__ret); }, } @@ -19860,8 +19586,8 @@ fn aiur_fn_202( let __v_15: G = G::from_u64(0); let __v_16: G = G::from_u64(0); let __v_17: G = { let __values: [G; 4] = [__v_14, __v_15, __v_16, __v_16]; let __mq = record.memory_queries.get_mut(&4).ok_or(ExecError::InvalidMemorySize(4))?; if let Some(result) = __mq.get_mut(&__values[..]) { if !unconstrained { *result.multiplicity += G::ONE; } result.output[0] } else { let __ptr = G::from_usize(__mq.len()); __mq.insert(&__values[..], &[__ptr], G::from_bool(!unconstrained)); __ptr } }; - let __ret: [G; OUT_202] = [__v_9, __v_13, __v_17]; - if let Some(result) = record.function_queries[202].get_mut(&inp[..]) { debug_assert_eq!(result.output, &__ret[..]); if !unconstrained { *result.multiplicity += G::ONE; } } else { record.function_queries[202].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained)); }; + let __ret: [G; OUT_198] = [__v_9, __v_13, __v_17]; + if let Some(result) = record.function_queries[198].get_mut(&inp[..]) { debug_assert_eq!(result.output, &__ret[..]); if !unconstrained { *result.multiplicity += G::ONE; } } else { record.function_queries[198].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained)); }; return Ok(__ret); }, } @@ -19876,34 +19602,34 @@ fn aiur_fn_202( let __v_13: G = G::from_u64(0); let __v_14: G = G::from_u64(0); let __v_15: G = { let __values: [G; 4] = [__v_12, __v_13, __v_14, __v_14]; let __mq = record.memory_queries.get_mut(&4).ok_or(ExecError::InvalidMemorySize(4))?; if let Some(result) = __mq.get_mut(&__values[..]) { if !unconstrained { *result.multiplicity += G::ONE; } result.output[0] } else { let __ptr = G::from_usize(__mq.len()); __mq.insert(&__values[..], &[__ptr], G::from_bool(!unconstrained)); __ptr } }; - let __ret: [G; OUT_202] = [__v_7, __v_11, __v_15]; - if let Some(result) = record.function_queries[202].get_mut(&inp[..]) { debug_assert_eq!(result.output, &__ret[..]); if !unconstrained { *result.multiplicity += G::ONE; } } else { record.function_queries[202].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained)); }; + let __ret: [G; OUT_198] = [__v_7, __v_11, __v_15]; + if let Some(result) = record.function_queries[198].get_mut(&inp[..]) { debug_assert_eq!(result.output, &__ret[..]); if !unconstrained { *result.multiplicity += G::ONE; } } else { record.function_queries[198].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained)); }; return Ok(__ret); }, } }) } -const INPUT_SIZE_203: usize = 3; -const IN_203: usize = 3; -const OUT_203: usize = 2; -fn aiur_fn_203( - inp: [G; IN_203], +const INPUT_SIZE_199: usize = 3; +const IN_199: usize = 3; +const OUT_199: usize = 2; +fn aiur_fn_199( + inp: [G; IN_199], record: &mut QueryRecord, io_buffer: &mut IOBuffer, unconstrained: bool, -) -> Result<[G; OUT_203], ExecError> { +) -> Result<[G; OUT_199], ExecError> { stacker::maybe_grow(64 * 1024, 4 * 1024 * 1024, || { let __v_0: G = inp[0]; let __v_1: G = inp[1]; let __v_2: G = inp[2]; - let __r_arr: [G; OUT_191] = { let __args: [G; IN_191] = []; let __cu = unconstrained; if let Some(result) = record.function_queries[191].get_mut(&__args[..]) { if !__cu && *result.multiplicity == G::ZERO { aiur_fn_191(__args, record, io_buffer, false)? } else { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_191] = unsafe { *(result.output.as_ptr() as *const [G; OUT_191]) }; __ret } } else { aiur_fn_191(__args, record, io_buffer, __cu)? } }; + let __r_arr: [G; OUT_187] = { let __args: [G; IN_187] = []; let __cu = unconstrained; if let Some(result) = record.function_queries[187].get_mut(&__args[..]) { if !__cu && *result.multiplicity == G::ZERO { aiur_fn_187(__args, record, io_buffer, false)? } else { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_187] = unsafe { *(result.output.as_ptr() as *const [G; OUT_187]) }; __ret } } else { aiur_fn_187(__args, record, io_buffer, __cu)? } }; let __v_3: G = __r_arr[0]; let __r_arr: [G; OUT_1] = { let __args: [G; IN_1] = [__v_0, __v_3]; let __cu = unconstrained; if let Some(result) = record.function_queries[1].get_mut(&__args[..]) { if !__cu && *result.multiplicity == G::ZERO { aiur_fn_1(__args, record, io_buffer, false)? } else { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_1] = unsafe { *(result.output.as_ptr() as *const [G; OUT_1]) }; __ret } } else { aiur_fn_1(__args, record, io_buffer, __cu)? } }; let __v_4: G = __r_arr[0]; match __v_4.as_canonical_u64() { 1u64 => { - let __r_arr: [G; OUT_764] = { let __args: [G; IN_764] = [__v_1]; let __cu = unconstrained; if let Some(result) = record.function_queries[764].get_mut(&__args[..]) { if !__cu && *result.multiplicity == G::ZERO { aiur_fn_764(__args, record, io_buffer, false)? } else { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_764] = unsafe { *(result.output.as_ptr() as *const [G; OUT_764]) }; __ret } } else { aiur_fn_764(__args, record, io_buffer, __cu)? } }; + let __r_arr: [G; OUT_760] = { let __args: [G; IN_760] = [__v_1]; let __cu = unconstrained; if let Some(result) = record.function_queries[760].get_mut(&__args[..]) { if !__cu && *result.multiplicity == G::ZERO { aiur_fn_760(__args, record, io_buffer, false)? } else { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_760] = unsafe { *(result.output.as_ptr() as *const [G; OUT_760]) }; __ret } } else { aiur_fn_760(__args, record, io_buffer, __cu)? } }; let __v_5: G = __r_arr[0]; let __v_6: G = G::from_u64(2); let __v_7: G = { let __a_val = __v_5.as_canonical_u64(); let __b_val = __v_6.as_canonical_u64(); let __a_u32 = u32::try_from(__a_val).ok().ok_or(ExecError::U32OutOfRange(__a_val))?; let __b_u32 = u32::try_from(__b_val).ok().ok_or(ExecError::U32OutOfRange(__b_val))?; let __result = G::from_bool(__a_u32 < __b_u32); if !unconstrained { let __x_bytes = __a_u32.to_le_bytes(); let __z_bytes = __b_u32.to_le_bytes(); let __c_u32 = __b_u32.wrapping_sub(__a_u32).wrapping_sub(1); let __y_bytes = __c_u32.to_le_bytes(); record.bytes2_queries.bump_range_check(&G::from_u8(__x_bytes[0]), &G::from_u8(__x_bytes[1])); record.bytes2_queries.bump_range_check(&G::from_u8(__x_bytes[2]), &G::from_u8(__x_bytes[3])); record.bytes2_queries.bump_range_check(&G::from_u8(__y_bytes[0]), &G::from_u8(__y_bytes[1])); record.bytes2_queries.bump_range_check(&G::from_u8(__y_bytes[2]), &G::from_u8(__y_bytes[3])); record.bytes2_queries.bump_range_check(&G::from_u8(__z_bytes[0]), &G::from_u8(__z_bytes[1])); record.bytes2_queries.bump_range_check(&G::from_u8(__z_bytes[2]), &G::from_u8(__z_bytes[3])); } __result }; @@ -19914,20 +19640,20 @@ fn aiur_fn_203( let __v_10: G = G::from_u64(0); let __v_11: G = G::from_u64(0); let __v_12: G = { let __values: [G; 4] = [__v_9, __v_10, __v_11, __v_11]; let __mq = record.memory_queries.get_mut(&4).ok_or(ExecError::InvalidMemorySize(4))?; if let Some(result) = __mq.get_mut(&__values[..]) { if !unconstrained { *result.multiplicity += G::ONE; } result.output[0] } else { let __ptr = G::from_usize(__mq.len()); __mq.insert(&__values[..], &[__ptr], G::from_bool(!unconstrained)); __ptr } }; - let __ret: [G; OUT_203] = [__v_8, __v_12]; - if let Some(result) = record.function_queries[203].get_mut(&inp[..]) { debug_assert_eq!(result.output, &__ret[..]); if !unconstrained { *result.multiplicity += G::ONE; } } else { record.function_queries[203].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained)); }; + let __ret: [G; OUT_199] = [__v_8, __v_12]; + if let Some(result) = record.function_queries[199].get_mut(&inp[..]) { debug_assert_eq!(result.output, &__ret[..]); if !unconstrained { *result.multiplicity += G::ONE; } } else { record.function_queries[199].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained)); }; return Ok(__ret); }, _ => { - let __r_arr: [G; OUT_390] = { let __args: [G; IN_390] = [__v_1, __v_2]; let __cu = unconstrained; if let Some(result) = record.function_queries[390].get_mut(&__args[..]) { if !__cu && *result.multiplicity == G::ZERO { aiur_fn_390(__args, record, io_buffer, false)? } else { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_390] = unsafe { *(result.output.as_ptr() as *const [G; OUT_390]) }; __ret } } else { aiur_fn_390(__args, record, io_buffer, __cu)? } }; + let __r_arr: [G; OUT_386] = { let __args: [G; IN_386] = [__v_1, __v_2]; let __cu = unconstrained; if let Some(result) = record.function_queries[386].get_mut(&__args[..]) { if !__cu && *result.multiplicity == G::ZERO { aiur_fn_386(__args, record, io_buffer, false)? } else { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_386] = unsafe { *(result.output.as_ptr() as *const [G; OUT_386]) }; __ret } } else { aiur_fn_386(__args, record, io_buffer, __cu)? } }; let __v_8: G = __r_arr[0]; let __v_9: G = G::from_u64(0); - let __r_arr: [G; OUT_766] = { let __args: [G; IN_766] = [__v_8, __v_9]; let __cu = unconstrained; if let Some(result) = record.function_queries[766].get_mut(&__args[..]) { if !__cu && *result.multiplicity == G::ZERO { aiur_fn_766(__args, record, io_buffer, false)? } else { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_766] = unsafe { *(result.output.as_ptr() as *const [G; OUT_766]) }; __ret } } else { aiur_fn_766(__args, record, io_buffer, __cu)? } }; + let __r_arr: [G; OUT_762] = { let __args: [G; IN_762] = [__v_8, __v_9]; let __cu = unconstrained; if let Some(result) = record.function_queries[762].get_mut(&__args[..]) { if !__cu && *result.multiplicity == G::ZERO { aiur_fn_762(__args, record, io_buffer, false)? } else { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_762] = unsafe { *(result.output.as_ptr() as *const [G; OUT_762]) }; __ret } } else { aiur_fn_762(__args, record, io_buffer, __cu)? } }; let __v_10: G = __r_arr[0]; let __v_11: G = G::from_u64(1); - let __r_arr: [G; OUT_766] = { let __args: [G; IN_766] = [__v_8, __v_11]; let __cu = unconstrained; if let Some(result) = record.function_queries[766].get_mut(&__args[..]) { if !__cu && *result.multiplicity == G::ZERO { aiur_fn_766(__args, record, io_buffer, false)? } else { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_766] = unsafe { *(result.output.as_ptr() as *const [G; OUT_766]) }; __ret } } else { aiur_fn_766(__args, record, io_buffer, __cu)? } }; + let __r_arr: [G; OUT_762] = { let __args: [G; IN_762] = [__v_8, __v_11]; let __cu = unconstrained; if let Some(result) = record.function_queries[762].get_mut(&__args[..]) { if !__cu && *result.multiplicity == G::ZERO { aiur_fn_762(__args, record, io_buffer, false)? } else { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_762] = unsafe { *(result.output.as_ptr() as *const [G; OUT_762]) }; __ret } } else { aiur_fn_762(__args, record, io_buffer, __cu)? } }; let __v_12: G = __r_arr[0]; - let __r_arr: [G; OUT_199] = { let __args: [G; IN_199] = [__v_10, __v_12]; let __cu = unconstrained; if let Some(result) = record.function_queries[199].get_mut(&__args[..]) { if !__cu && *result.multiplicity == G::ZERO { aiur_fn_199(__args, record, io_buffer, false)? } else { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_199] = unsafe { *(result.output.as_ptr() as *const [G; OUT_199]) }; __ret } } else { aiur_fn_199(__args, record, io_buffer, __cu)? } }; + let __r_arr: [G; OUT_195] = { let __args: [G; IN_195] = [__v_10, __v_12]; let __cu = unconstrained; if let Some(result) = record.function_queries[195].get_mut(&__args[..]) { if !__cu && *result.multiplicity == G::ZERO { aiur_fn_195(__args, record, io_buffer, false)? } else { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_195] = unsafe { *(result.output.as_ptr() as *const [G; OUT_195]) }; __ret } } else { aiur_fn_195(__args, record, io_buffer, __cu)? } }; let __v_13: G = __r_arr[0]; let __v_14: G = __r_arr[1]; match __v_13.as_canonical_u64() { @@ -19937,16 +19663,16 @@ fn aiur_fn_203( let __v_17: G = G::from_u64(0); let __v_18: G = G::from_u64(0); let __v_19: G = { let __values: [G; 4] = [__v_16, __v_17, __v_18, __v_18]; let __mq = record.memory_queries.get_mut(&4).ok_or(ExecError::InvalidMemorySize(4))?; if let Some(result) = __mq.get_mut(&__values[..]) { if !unconstrained { *result.multiplicity += G::ONE; } result.output[0] } else { let __ptr = G::from_usize(__mq.len()); __mq.insert(&__values[..], &[__ptr], G::from_bool(!unconstrained)); __ptr } }; - let __ret: [G; OUT_203] = [__v_15, __v_19]; - if let Some(result) = record.function_queries[203].get_mut(&inp[..]) { debug_assert_eq!(result.output, &__ret[..]); if !unconstrained { *result.multiplicity += G::ONE; } } else { record.function_queries[203].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained)); }; + let __ret: [G; OUT_199] = [__v_15, __v_19]; + if let Some(result) = record.function_queries[199].get_mut(&inp[..]) { debug_assert_eq!(result.output, &__ret[..]); if !unconstrained { *result.multiplicity += G::ONE; } } else { record.function_queries[199].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained)); }; return Ok(__ret); }, 1u64 => { let __v_15: G = G::from_u64(1); - let __r_arr: [G; OUT_245] = { let __args: [G; IN_245] = [__v_14]; let __cu = unconstrained; if let Some(result) = record.function_queries[245].get_mut(&__args[..]) { if !__cu && *result.multiplicity == G::ZERO { aiur_fn_245(__args, record, io_buffer, false)? } else { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_245] = unsafe { *(result.output.as_ptr() as *const [G; OUT_245]) }; __ret } } else { aiur_fn_245(__args, record, io_buffer, __cu)? } }; + let __r_arr: [G; OUT_241] = { let __args: [G; IN_241] = [__v_14]; let __cu = unconstrained; if let Some(result) = record.function_queries[241].get_mut(&__args[..]) { if !__cu && *result.multiplicity == G::ZERO { aiur_fn_241(__args, record, io_buffer, false)? } else { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_241] = unsafe { *(result.output.as_ptr() as *const [G; OUT_241]) }; __ret } } else { aiur_fn_241(__args, record, io_buffer, __cu)? } }; let __v_16: G = __r_arr[0]; - let __ret: [G; OUT_203] = [__v_15, __v_16]; - if let Some(result) = record.function_queries[203].get_mut(&inp[..]) { debug_assert_eq!(result.output, &__ret[..]); if !unconstrained { *result.multiplicity += G::ONE; } } else { record.function_queries[203].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained)); }; + let __ret: [G; OUT_199] = [__v_15, __v_16]; + if let Some(result) = record.function_queries[199].get_mut(&inp[..]) { debug_assert_eq!(result.output, &__ret[..]); if !unconstrained { *result.multiplicity += G::ONE; } } else { record.function_queries[199].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained)); }; return Ok(__ret); }, _ => { @@ -19957,33 +19683,33 @@ fn aiur_fn_203( } }, _ => { - let __r_arr: [G; OUT_194] = { let __args: [G; IN_194] = []; let __cu = unconstrained; if let Some(result) = record.function_queries[194].get_mut(&__args[..]) { if !__cu && *result.multiplicity == G::ZERO { aiur_fn_194(__args, record, io_buffer, false)? } else { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_194] = unsafe { *(result.output.as_ptr() as *const [G; OUT_194]) }; __ret } } else { aiur_fn_194(__args, record, io_buffer, __cu)? } }; + let __r_arr: [G; OUT_190] = { let __args: [G; IN_190] = []; let __cu = unconstrained; if let Some(result) = record.function_queries[190].get_mut(&__args[..]) { if !__cu && *result.multiplicity == G::ZERO { aiur_fn_190(__args, record, io_buffer, false)? } else { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_190] = unsafe { *(result.output.as_ptr() as *const [G; OUT_190]) }; __ret } } else { aiur_fn_190(__args, record, io_buffer, __cu)? } }; let __v_5: G = __r_arr[0]; let __r_arr: [G; OUT_1] = { let __args: [G; IN_1] = [__v_0, __v_5]; let __cu = unconstrained; if let Some(result) = record.function_queries[1].get_mut(&__args[..]) { if !__cu && *result.multiplicity == G::ZERO { aiur_fn_1(__args, record, io_buffer, false)? } else { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_1] = unsafe { *(result.output.as_ptr() as *const [G; OUT_1]) }; __ret } } else { aiur_fn_1(__args, record, io_buffer, __cu)? } }; let __v_6: G = __r_arr[0]; match __v_6.as_canonical_u64() { 1u64 => { - let __r_arr: [G; OUT_204] = { let __args: [G; IN_204] = [__v_1, __v_2]; let __cu = unconstrained; if let Some(result) = record.function_queries[204].get_mut(&__args[..]) { if !__cu && *result.multiplicity == G::ZERO { aiur_fn_204(__args, record, io_buffer, false)? } else { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_204] = unsafe { *(result.output.as_ptr() as *const [G; OUT_204]) }; __ret } } else { aiur_fn_204(__args, record, io_buffer, __cu)? } }; + let __r_arr: [G; OUT_200] = { let __args: [G; IN_200] = [__v_1, __v_2]; let __cu = unconstrained; if let Some(result) = record.function_queries[200].get_mut(&__args[..]) { if !__cu && *result.multiplicity == G::ZERO { aiur_fn_200(__args, record, io_buffer, false)? } else { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_200] = unsafe { *(result.output.as_ptr() as *const [G; OUT_200]) }; __ret } } else { aiur_fn_200(__args, record, io_buffer, __cu)? } }; let __v_7: G = __r_arr[0]; - let __r_arr: [G; OUT_200] = { let __args: [G; IN_200] = [__v_7]; let __cu = unconstrained; if let Some(result) = record.function_queries[200].get_mut(&__args[..]) { if !__cu && *result.multiplicity == G::ZERO { aiur_fn_200(__args, record, io_buffer, false)? } else { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_200] = unsafe { *(result.output.as_ptr() as *const [G; OUT_200]) }; __ret } } else { aiur_fn_200(__args, record, io_buffer, __cu)? } }; + let __r_arr: [G; OUT_196] = { let __args: [G; IN_196] = [__v_7]; let __cu = unconstrained; if let Some(result) = record.function_queries[196].get_mut(&__args[..]) { if !__cu && *result.multiplicity == G::ZERO { aiur_fn_196(__args, record, io_buffer, false)? } else { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_196] = unsafe { *(result.output.as_ptr() as *const [G; OUT_196]) }; __ret } } else { aiur_fn_196(__args, record, io_buffer, __cu)? } }; let __v_8: G = __r_arr[0]; let __v_9: G = __r_arr[1]; - let __ret: [G; OUT_203] = [__v_8, __v_9]; - if let Some(result) = record.function_queries[203].get_mut(&inp[..]) { debug_assert_eq!(result.output, &__ret[..]); if !unconstrained { *result.multiplicity += G::ONE; } } else { record.function_queries[203].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained)); }; + let __ret: [G; OUT_199] = [__v_8, __v_9]; + if let Some(result) = record.function_queries[199].get_mut(&inp[..]) { debug_assert_eq!(result.output, &__ret[..]); if !unconstrained { *result.multiplicity += G::ONE; } } else { record.function_queries[199].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained)); }; return Ok(__ret); }, _ => { - let __r_arr: [G; OUT_195] = { let __args: [G; IN_195] = []; let __cu = unconstrained; if let Some(result) = record.function_queries[195].get_mut(&__args[..]) { if !__cu && *result.multiplicity == G::ZERO { aiur_fn_195(__args, record, io_buffer, false)? } else { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_195] = unsafe { *(result.output.as_ptr() as *const [G; OUT_195]) }; __ret } } else { aiur_fn_195(__args, record, io_buffer, __cu)? } }; + let __r_arr: [G; OUT_191] = { let __args: [G; IN_191] = []; let __cu = unconstrained; if let Some(result) = record.function_queries[191].get_mut(&__args[..]) { if !__cu && *result.multiplicity == G::ZERO { aiur_fn_191(__args, record, io_buffer, false)? } else { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_191] = unsafe { *(result.output.as_ptr() as *const [G; OUT_191]) }; __ret } } else { aiur_fn_191(__args, record, io_buffer, __cu)? } }; let __v_7: G = __r_arr[0]; let __r_arr: [G; OUT_1] = { let __args: [G; IN_1] = [__v_0, __v_7]; let __cu = unconstrained; if let Some(result) = record.function_queries[1].get_mut(&__args[..]) { if !__cu && *result.multiplicity == G::ZERO { aiur_fn_1(__args, record, io_buffer, false)? } else { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_1] = unsafe { *(result.output.as_ptr() as *const [G; OUT_1]) }; __ret } } else { aiur_fn_1(__args, record, io_buffer, __cu)? } }; let __v_8: G = __r_arr[0]; match __v_8.as_canonical_u64() { 1u64 => { - let __r_arr: [G; OUT_201] = { let __args: [G; IN_201] = [__v_1]; let __cu = unconstrained; if let Some(result) = record.function_queries[201].get_mut(&__args[..]) { if !__cu && *result.multiplicity == G::ZERO { aiur_fn_201(__args, record, io_buffer, false)? } else { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_201] = unsafe { *(result.output.as_ptr() as *const [G; OUT_201]) }; __ret } } else { aiur_fn_201(__args, record, io_buffer, __cu)? } }; + let __r_arr: [G; OUT_197] = { let __args: [G; IN_197] = [__v_1]; let __cu = unconstrained; if let Some(result) = record.function_queries[197].get_mut(&__args[..]) { if !__cu && *result.multiplicity == G::ZERO { aiur_fn_197(__args, record, io_buffer, false)? } else { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_197] = unsafe { *(result.output.as_ptr() as *const [G; OUT_197]) }; __ret } } else { aiur_fn_197(__args, record, io_buffer, __cu)? } }; let __v_9: G = __r_arr[0]; let __v_10: G = __r_arr[1]; - let __ret: [G; OUT_203] = [__v_9, __v_10]; - if let Some(result) = record.function_queries[203].get_mut(&inp[..]) { debug_assert_eq!(result.output, &__ret[..]); if !unconstrained { *result.multiplicity += G::ONE; } } else { record.function_queries[203].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained)); }; + let __ret: [G; OUT_199] = [__v_9, __v_10]; + if let Some(result) = record.function_queries[199].get_mut(&inp[..]) { debug_assert_eq!(result.output, &__ret[..]); if !unconstrained { *result.multiplicity += G::ONE; } } else { record.function_queries[199].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained)); }; return Ok(__ret); }, _ => { @@ -19992,8 +19718,8 @@ fn aiur_fn_203( let __v_11: G = G::from_u64(0); let __v_12: G = G::from_u64(0); let __v_13: G = { let __values: [G; 4] = [__v_10, __v_11, __v_12, __v_12]; let __mq = record.memory_queries.get_mut(&4).ok_or(ExecError::InvalidMemorySize(4))?; if let Some(result) = __mq.get_mut(&__values[..]) { if !unconstrained { *result.multiplicity += G::ONE; } result.output[0] } else { let __ptr = G::from_usize(__mq.len()); __mq.insert(&__values[..], &[__ptr], G::from_bool(!unconstrained)); __ptr } }; - let __ret: [G; OUT_203] = [__v_9, __v_13]; - if let Some(result) = record.function_queries[203].get_mut(&inp[..]) { debug_assert_eq!(result.output, &__ret[..]); if !unconstrained { *result.multiplicity += G::ONE; } } else { record.function_queries[203].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained)); }; + let __ret: [G; OUT_199] = [__v_9, __v_13]; + if let Some(result) = record.function_queries[199].get_mut(&inp[..]) { debug_assert_eq!(result.output, &__ret[..]); if !unconstrained { *result.multiplicity += G::ONE; } } else { record.function_queries[199].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained)); }; return Ok(__ret); }, } @@ -20004,19 +19730,19 @@ fn aiur_fn_203( }) } -const INPUT_SIZE_204: usize = 2; -const IN_204: usize = 2; -const OUT_204: usize = 1; -fn aiur_fn_204( - inp: [G; IN_204], +const INPUT_SIZE_200: usize = 2; +const IN_200: usize = 2; +const OUT_200: usize = 1; +fn aiur_fn_200( + inp: [G; IN_200], record: &mut QueryRecord, io_buffer: &mut IOBuffer, unconstrained: bool, -) -> Result<[G; OUT_204], ExecError> { +) -> Result<[G; OUT_200], ExecError> { stacker::maybe_grow(64 * 1024, 4 * 1024 * 1024, || { let __v_0: G = inp[0]; let __v_1: G = inp[1]; - let __r_arr: [G; OUT_388] = { let __args: [G; IN_388] = [__v_0, __v_1]; let __cu = unconstrained; if let Some(result) = record.function_queries[388].get_mut(&__args[..]) { if !__cu && *result.multiplicity == G::ZERO { aiur_fn_388(__args, record, io_buffer, false)? } else { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_388] = unsafe { *(result.output.as_ptr() as *const [G; OUT_388]) }; __ret } } else { aiur_fn_388(__args, record, io_buffer, __cu)? } }; + let __r_arr: [G; OUT_384] = { let __args: [G; IN_384] = [__v_0, __v_1]; let __cu = unconstrained; if let Some(result) = record.function_queries[384].get_mut(&__args[..]) { if !__cu && *result.multiplicity == G::ZERO { aiur_fn_384(__args, record, io_buffer, false)? } else { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_384] = unsafe { *(result.output.as_ptr() as *const [G; OUT_384]) }; __ret } } else { aiur_fn_384(__args, record, io_buffer, __cu)? } }; let __v_2: G = __r_arr[0]; let __loaded: [G; 3] = { let __mq = record.memory_queries.get_mut(&3).ok_or(ExecError::InvalidMemorySize(3))?; let __ptr_u64 = __v_2.as_canonical_u64(); let __ptr_usize = usize::try_from(__ptr_u64).ok().ok_or(ExecError::PointerTooLarge(__ptr_u64))?; let (__args, __mult) = __mq.get_index_mut(__ptr_usize).ok_or(ExecError::UnboundPointer { ptr: __ptr_u64, size: 3 })?; if !unconstrained { *__mult += G::ONE; } let __arr: [G; 3] = __args[..3].try_into().unwrap(); __arr }; let __v_3: G = __loaded[0]; @@ -20024,8 +19750,8 @@ fn aiur_fn_204( let __v_5: G = __loaded[2]; match __v_3.as_canonical_u64() { 1u64 => { - let __ret: [G; OUT_204] = [__v_2]; - if let Some(result) = record.function_queries[204].get_mut(&inp[..]) { debug_assert_eq!(result.output, &__ret[..]); if !unconstrained { *result.multiplicity += G::ONE; } } else { record.function_queries[204].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained)); }; + let __ret: [G; OUT_200] = [__v_2]; + if let Some(result) = record.function_queries[200].get_mut(&inp[..]) { debug_assert_eq!(result.output, &__ret[..]); if !unconstrained { *result.multiplicity += G::ONE; } } else { record.function_queries[200].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained)); }; return Ok(__ret); }, 0u64 => { @@ -20035,8 +19761,8 @@ fn aiur_fn_204( let __v_8: G = __loaded[2]; match __v_6.as_canonical_u64() { 1u64 => { - let __ret: [G; OUT_204] = [__v_2]; - if let Some(result) = record.function_queries[204].get_mut(&inp[..]) { debug_assert_eq!(result.output, &__ret[..]); if !unconstrained { *result.multiplicity += G::ONE; } } else { record.function_queries[204].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained)); }; + let __ret: [G; OUT_200] = [__v_2]; + if let Some(result) = record.function_queries[200].get_mut(&inp[..]) { debug_assert_eq!(result.output, &__ret[..]); if !unconstrained { *result.multiplicity += G::ONE; } } else { record.function_queries[200].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained)); }; return Ok(__ret); }, 0u64 => { @@ -20046,14 +19772,14 @@ fn aiur_fn_204( let __v_11: G = __loaded[2]; match __v_9.as_canonical_u64() { 1u64 => { - let __ret: [G; OUT_204] = [__v_2]; - if let Some(result) = record.function_queries[204].get_mut(&inp[..]) { debug_assert_eq!(result.output, &__ret[..]); if !unconstrained { *result.multiplicity += G::ONE; } } else { record.function_queries[204].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained)); }; + let __ret: [G; OUT_200] = [__v_2]; + if let Some(result) = record.function_queries[200].get_mut(&inp[..]) { debug_assert_eq!(result.output, &__ret[..]); if !unconstrained { *result.multiplicity += G::ONE; } } else { record.function_queries[200].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained)); }; return Ok(__ret); }, 0u64 => { - let __r_arr: [G; OUT_205] = { let __args: [G; IN_205] = [__v_7, __v_1]; let __cu = unconstrained; if let Some(result) = record.function_queries[205].get_mut(&__args[..]) { if !__cu && *result.multiplicity == G::ZERO { aiur_fn_205(__args, record, io_buffer, false)? } else { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_205] = unsafe { *(result.output.as_ptr() as *const [G; OUT_205]) }; __ret } } else { aiur_fn_205(__args, record, io_buffer, __cu)? } }; + let __r_arr: [G; OUT_201] = { let __args: [G; IN_201] = [__v_7, __v_1]; let __cu = unconstrained; if let Some(result) = record.function_queries[201].get_mut(&__args[..]) { if !__cu && *result.multiplicity == G::ZERO { aiur_fn_201(__args, record, io_buffer, false)? } else { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_201] = unsafe { *(result.output.as_ptr() as *const [G; OUT_201]) }; __ret } } else { aiur_fn_201(__args, record, io_buffer, __cu)? } }; let __v_12: G = __r_arr[0]; - let __r_arr: [G; OUT_205] = { let __args: [G; IN_205] = [__v_10, __v_1]; let __cu = unconstrained; if let Some(result) = record.function_queries[205].get_mut(&__args[..]) { if !__cu && *result.multiplicity == G::ZERO { aiur_fn_205(__args, record, io_buffer, false)? } else { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_205] = unsafe { *(result.output.as_ptr() as *const [G; OUT_205]) }; __ret } } else { aiur_fn_205(__args, record, io_buffer, __cu)? } }; + let __r_arr: [G; OUT_201] = { let __args: [G; IN_201] = [__v_10, __v_1]; let __cu = unconstrained; if let Some(result) = record.function_queries[201].get_mut(&__args[..]) { if !__cu && *result.multiplicity == G::ZERO { aiur_fn_201(__args, record, io_buffer, false)? } else { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_201] = unsafe { *(result.output.as_ptr() as *const [G; OUT_201]) }; __ret } } else { aiur_fn_201(__args, record, io_buffer, __cu)? } }; let __v_13: G = __r_arr[0]; let __v_14: G = G::from_u64(0); let __v_15: G = G::from_u64(0); @@ -20061,8 +19787,8 @@ fn aiur_fn_204( let __v_17: G = { let __values: [G; 3] = [__v_16, __v_13, __v_11]; let __mq = record.memory_queries.get_mut(&3).ok_or(ExecError::InvalidMemorySize(3))?; if let Some(result) = __mq.get_mut(&__values[..]) { if !unconstrained { *result.multiplicity += G::ONE; } result.output[0] } else { let __ptr = G::from_usize(__mq.len()); __mq.insert(&__values[..], &[__ptr], G::from_bool(!unconstrained)); __ptr } }; let __v_18: G = { let __values: [G; 3] = [__v_15, __v_12, __v_17]; let __mq = record.memory_queries.get_mut(&3).ok_or(ExecError::InvalidMemorySize(3))?; if let Some(result) = __mq.get_mut(&__values[..]) { if !unconstrained { *result.multiplicity += G::ONE; } result.output[0] } else { let __ptr = G::from_usize(__mq.len()); __mq.insert(&__values[..], &[__ptr], G::from_bool(!unconstrained)); __ptr } }; let __v_19: G = { let __values: [G; 3] = [__v_14, __v_4, __v_18]; let __mq = record.memory_queries.get_mut(&3).ok_or(ExecError::InvalidMemorySize(3))?; if let Some(result) = __mq.get_mut(&__values[..]) { if !unconstrained { *result.multiplicity += G::ONE; } result.output[0] } else { let __ptr = G::from_usize(__mq.len()); __mq.insert(&__values[..], &[__ptr], G::from_bool(!unconstrained)); __ptr } }; - let __ret: [G; OUT_204] = [__v_19]; - if let Some(result) = record.function_queries[204].get_mut(&inp[..]) { debug_assert_eq!(result.output, &__ret[..]); if !unconstrained { *result.multiplicity += G::ONE; } } else { record.function_queries[204].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained)); }; + let __ret: [G; OUT_200] = [__v_19]; + if let Some(result) = record.function_queries[200].get_mut(&inp[..]) { debug_assert_eq!(result.output, &__ret[..]); if !unconstrained { *result.multiplicity += G::ONE; } } else { record.function_queries[200].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained)); }; return Ok(__ret); }, _ => { @@ -20082,40 +19808,40 @@ fn aiur_fn_204( }) } -const INPUT_SIZE_205: usize = 2; -const IN_205: usize = 2; -const OUT_205: usize = 1; -fn aiur_fn_205( - inp: [G; IN_205], +const INPUT_SIZE_201: usize = 2; +const IN_201: usize = 2; +const OUT_201: usize = 1; +fn aiur_fn_201( + inp: [G; IN_201], record: &mut QueryRecord, io_buffer: &mut IOBuffer, unconstrained: bool, -) -> Result<[G; OUT_205], ExecError> { +) -> Result<[G; OUT_201], ExecError> { stacker::maybe_grow(64 * 1024, 4 * 1024 * 1024, || { let __v_0: G = inp[0]; let __v_1: G = inp[1]; let __r_arr: [G; OUT_111] = { let __args: [G; IN_111] = [__v_0]; let __cu = unconstrained; if let Some(result) = record.function_queries[111].get_mut(&__args[..]) { if !__cu && *result.multiplicity == G::ZERO { aiur_fn_111(__args, record, io_buffer, false)? } else { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_111] = unsafe { *(result.output.as_ptr() as *const [G; OUT_111]) }; __ret } } else { aiur_fn_111(__args, record, io_buffer, __cu)? } }; let __v_2: G = __r_arr[0]; let __v_3: G = __r_arr[1]; - let __r_arr: [G; OUT_388] = { let __args: [G; IN_388] = [__v_3, __v_1]; let __cu = unconstrained; if let Some(result) = record.function_queries[388].get_mut(&__args[..]) { if !__cu && *result.multiplicity == G::ZERO { aiur_fn_388(__args, record, io_buffer, false)? } else { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_388] = unsafe { *(result.output.as_ptr() as *const [G; OUT_388]) }; __ret } } else { aiur_fn_388(__args, record, io_buffer, __cu)? } }; + let __r_arr: [G; OUT_384] = { let __args: [G; IN_384] = [__v_3, __v_1]; let __cu = unconstrained; if let Some(result) = record.function_queries[384].get_mut(&__args[..]) { if !__cu && *result.multiplicity == G::ZERO { aiur_fn_384(__args, record, io_buffer, false)? } else { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_384] = unsafe { *(result.output.as_ptr() as *const [G; OUT_384]) }; __ret } } else { aiur_fn_384(__args, record, io_buffer, __cu)? } }; let __v_4: G = __r_arr[0]; - let __r_arr: [G; OUT_255] = { let __args: [G; IN_255] = [__v_2, __v_4]; let __cu = unconstrained; if let Some(result) = record.function_queries[255].get_mut(&__args[..]) { if !__cu && *result.multiplicity == G::ZERO { aiur_fn_255(__args, record, io_buffer, false)? } else { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_255] = unsafe { *(result.output.as_ptr() as *const [G; OUT_255]) }; __ret } } else { aiur_fn_255(__args, record, io_buffer, __cu)? } }; + let __r_arr: [G; OUT_251] = { let __args: [G; IN_251] = [__v_2, __v_4]; let __cu = unconstrained; if let Some(result) = record.function_queries[251].get_mut(&__args[..]) { if !__cu && *result.multiplicity == G::ZERO { aiur_fn_251(__args, record, io_buffer, false)? } else { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_251] = unsafe { *(result.output.as_ptr() as *const [G; OUT_251]) }; __ret } } else { aiur_fn_251(__args, record, io_buffer, __cu)? } }; let __v_5: G = __r_arr[0]; - let __ret: [G; OUT_205] = [__v_5]; - if let Some(result) = record.function_queries[205].get_mut(&inp[..]) { debug_assert_eq!(result.output, &__ret[..]); if !unconstrained { *result.multiplicity += G::ONE; } } else { record.function_queries[205].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained)); }; + let __ret: [G; OUT_201] = [__v_5]; + if let Some(result) = record.function_queries[201].get_mut(&inp[..]) { debug_assert_eq!(result.output, &__ret[..]); if !unconstrained { *result.multiplicity += G::ONE; } } else { record.function_queries[201].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained)); }; return Ok(__ret); }) } -const INPUT_SIZE_206: usize = 0; -const IN_206: usize = 0; -const OUT_206: usize = 1; -fn aiur_fn_206( - inp: [G; IN_206], +const INPUT_SIZE_202: usize = 0; +const IN_202: usize = 0; +const OUT_202: usize = 1; +fn aiur_fn_202( + inp: [G; IN_202], record: &mut QueryRecord, io_buffer: &mut IOBuffer, unconstrained: bool, -) -> Result<[G; OUT_206], ExecError> { +) -> Result<[G; OUT_202], ExecError> { stacker::maybe_grow(64 * 1024, 4 * 1024 * 1024, || { let __v_0: G = G::from_u64(81); let __v_1: G = G::from_u64(134); @@ -20150,21 +19876,21 @@ fn aiur_fn_206( let __v_30: G = G::from_u64(90); let __v_31: G = G::from_u64(110); let __v_32: G = { let __values: [G; 32] = [__v_0, __v_1, __v_2, __v_3, __v_4, __v_5, __v_6, __v_7, __v_8, __v_9, __v_10, __v_11, __v_12, __v_13, __v_14, __v_15, __v_16, __v_17, __v_18, __v_19, __v_20, __v_21, __v_22, __v_23, __v_24, __v_25, __v_26, __v_27, __v_28, __v_29, __v_30, __v_31]; let __mq = record.memory_queries.get_mut(&32).ok_or(ExecError::InvalidMemorySize(32))?; if let Some(result) = __mq.get_mut(&__values[..]) { if !unconstrained { *result.multiplicity += G::ONE; } result.output[0] } else { let __ptr = G::from_usize(__mq.len()); __mq.insert(&__values[..], &[__ptr], G::from_bool(!unconstrained)); __ptr } }; - let __ret: [G; OUT_206] = [__v_32]; - if let Some(result) = record.function_queries[206].get_mut(&inp[..]) { debug_assert_eq!(result.output, &__ret[..]); if !unconstrained { *result.multiplicity += G::ONE; } } else { record.function_queries[206].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained)); }; + let __ret: [G; OUT_202] = [__v_32]; + if let Some(result) = record.function_queries[202].get_mut(&inp[..]) { debug_assert_eq!(result.output, &__ret[..]); if !unconstrained { *result.multiplicity += G::ONE; } } else { record.function_queries[202].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained)); }; return Ok(__ret); }) } -const INPUT_SIZE_207: usize = 0; -const IN_207: usize = 0; -const OUT_207: usize = 1; -fn aiur_fn_207( - inp: [G; IN_207], +const INPUT_SIZE_203: usize = 0; +const IN_203: usize = 0; +const OUT_203: usize = 1; +fn aiur_fn_203( + inp: [G; IN_203], record: &mut QueryRecord, io_buffer: &mut IOBuffer, unconstrained: bool, -) -> Result<[G; OUT_207], ExecError> { +) -> Result<[G; OUT_203], ExecError> { stacker::maybe_grow(64 * 1024, 4 * 1024 * 1024, || { let __v_0: G = G::from_u64(255); let __v_1: G = G::from_u64(69); @@ -20199,21 +19925,21 @@ fn aiur_fn_207( let __v_30: G = G::from_u64(3); let __v_31: G = G::from_u64(158); let __v_32: G = { let __values: [G; 32] = [__v_0, __v_1, __v_2, __v_3, __v_4, __v_5, __v_6, __v_7, __v_8, __v_9, __v_10, __v_11, __v_12, __v_13, __v_14, __v_15, __v_16, __v_17, __v_18, __v_19, __v_20, __v_21, __v_22, __v_23, __v_24, __v_25, __v_26, __v_27, __v_28, __v_29, __v_30, __v_31]; let __mq = record.memory_queries.get_mut(&32).ok_or(ExecError::InvalidMemorySize(32))?; if let Some(result) = __mq.get_mut(&__values[..]) { if !unconstrained { *result.multiplicity += G::ONE; } result.output[0] } else { let __ptr = G::from_usize(__mq.len()); __mq.insert(&__values[..], &[__ptr], G::from_bool(!unconstrained)); __ptr } }; - let __ret: [G; OUT_207] = [__v_32]; - if let Some(result) = record.function_queries[207].get_mut(&inp[..]) { debug_assert_eq!(result.output, &__ret[..]); if !unconstrained { *result.multiplicity += G::ONE; } } else { record.function_queries[207].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained)); }; + let __ret: [G; OUT_203] = [__v_32]; + if let Some(result) = record.function_queries[203].get_mut(&inp[..]) { debug_assert_eq!(result.output, &__ret[..]); if !unconstrained { *result.multiplicity += G::ONE; } } else { record.function_queries[203].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained)); }; return Ok(__ret); }) } -const INPUT_SIZE_208: usize = 0; -const IN_208: usize = 0; -const OUT_208: usize = 1; -fn aiur_fn_208( - inp: [G; IN_208], +const INPUT_SIZE_204: usize = 0; +const IN_204: usize = 0; +const OUT_204: usize = 1; +fn aiur_fn_204( + inp: [G; IN_204], record: &mut QueryRecord, io_buffer: &mut IOBuffer, unconstrained: bool, -) -> Result<[G; OUT_208], ExecError> { +) -> Result<[G; OUT_204], ExecError> { stacker::maybe_grow(64 * 1024, 4 * 1024 * 1024, || { let __v_0: G = G::from_u64(15); let __v_1: G = G::from_u64(2); @@ -20248,21 +19974,21 @@ fn aiur_fn_208( let __v_30: G = G::from_u64(40); let __v_31: G = G::from_u64(217); let __v_32: G = { let __values: [G; 32] = [__v_0, __v_1, __v_2, __v_3, __v_4, __v_5, __v_6, __v_7, __v_8, __v_9, __v_10, __v_11, __v_12, __v_13, __v_14, __v_15, __v_16, __v_17, __v_18, __v_19, __v_20, __v_21, __v_22, __v_23, __v_24, __v_25, __v_26, __v_27, __v_28, __v_29, __v_30, __v_31]; let __mq = record.memory_queries.get_mut(&32).ok_or(ExecError::InvalidMemorySize(32))?; if let Some(result) = __mq.get_mut(&__values[..]) { if !unconstrained { *result.multiplicity += G::ONE; } result.output[0] } else { let __ptr = G::from_usize(__mq.len()); __mq.insert(&__values[..], &[__ptr], G::from_bool(!unconstrained)); __ptr } }; - let __ret: [G; OUT_208] = [__v_32]; - if let Some(result) = record.function_queries[208].get_mut(&inp[..]) { debug_assert_eq!(result.output, &__ret[..]); if !unconstrained { *result.multiplicity += G::ONE; } } else { record.function_queries[208].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained)); }; + let __ret: [G; OUT_204] = [__v_32]; + if let Some(result) = record.function_queries[204].get_mut(&inp[..]) { debug_assert_eq!(result.output, &__ret[..]); if !unconstrained { *result.multiplicity += G::ONE; } } else { record.function_queries[204].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained)); }; return Ok(__ret); }) } -const INPUT_SIZE_209: usize = 0; -const IN_209: usize = 0; -const OUT_209: usize = 1; -fn aiur_fn_209( - inp: [G; IN_209], +const INPUT_SIZE_205: usize = 0; +const IN_205: usize = 0; +const OUT_205: usize = 1; +fn aiur_fn_205( + inp: [G; IN_205], record: &mut QueryRecord, io_buffer: &mut IOBuffer, unconstrained: bool, -) -> Result<[G; OUT_209], ExecError> { +) -> Result<[G; OUT_205], ExecError> { stacker::maybe_grow(64 * 1024, 4 * 1024 * 1024, || { let __v_0: G = G::from_u64(9); let __v_1: G = G::from_u64(238); @@ -20297,21 +20023,21 @@ fn aiur_fn_209( let __v_30: G = G::from_u64(141); let __v_31: G = G::from_u64(52); let __v_32: G = { let __values: [G; 32] = [__v_0, __v_1, __v_2, __v_3, __v_4, __v_5, __v_6, __v_7, __v_8, __v_9, __v_10, __v_11, __v_12, __v_13, __v_14, __v_15, __v_16, __v_17, __v_18, __v_19, __v_20, __v_21, __v_22, __v_23, __v_24, __v_25, __v_26, __v_27, __v_28, __v_29, __v_30, __v_31]; let __mq = record.memory_queries.get_mut(&32).ok_or(ExecError::InvalidMemorySize(32))?; if let Some(result) = __mq.get_mut(&__values[..]) { if !unconstrained { *result.multiplicity += G::ONE; } result.output[0] } else { let __ptr = G::from_usize(__mq.len()); __mq.insert(&__values[..], &[__ptr], G::from_bool(!unconstrained)); __ptr } }; - let __ret: [G; OUT_209] = [__v_32]; - if let Some(result) = record.function_queries[209].get_mut(&inp[..]) { debug_assert_eq!(result.output, &__ret[..]); if !unconstrained { *result.multiplicity += G::ONE; } } else { record.function_queries[209].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained)); }; + let __ret: [G; OUT_205] = [__v_32]; + if let Some(result) = record.function_queries[205].get_mut(&inp[..]) { debug_assert_eq!(result.output, &__ret[..]); if !unconstrained { *result.multiplicity += G::ONE; } } else { record.function_queries[205].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained)); }; return Ok(__ret); }) } -const INPUT_SIZE_210: usize = 0; -const IN_210: usize = 0; -const OUT_210: usize = 1; -fn aiur_fn_210( - inp: [G; IN_210], +const INPUT_SIZE_206: usize = 0; +const IN_206: usize = 0; +const OUT_206: usize = 1; +fn aiur_fn_206( + inp: [G; IN_206], record: &mut QueryRecord, io_buffer: &mut IOBuffer, unconstrained: bool, -) -> Result<[G; OUT_210], ExecError> { +) -> Result<[G; OUT_206], ExecError> { stacker::maybe_grow(64 * 1024, 4 * 1024 * 1024, || { let __v_0: G = G::from_u64(37); let __v_1: G = G::from_u64(138); @@ -20346,21 +20072,21 @@ fn aiur_fn_210( let __v_30: G = G::from_u64(202); let __v_31: G = G::from_u64(62); let __v_32: G = { let __values: [G; 32] = [__v_0, __v_1, __v_2, __v_3, __v_4, __v_5, __v_6, __v_7, __v_8, __v_9, __v_10, __v_11, __v_12, __v_13, __v_14, __v_15, __v_16, __v_17, __v_18, __v_19, __v_20, __v_21, __v_22, __v_23, __v_24, __v_25, __v_26, __v_27, __v_28, __v_29, __v_30, __v_31]; let __mq = record.memory_queries.get_mut(&32).ok_or(ExecError::InvalidMemorySize(32))?; if let Some(result) = __mq.get_mut(&__values[..]) { if !unconstrained { *result.multiplicity += G::ONE; } result.output[0] } else { let __ptr = G::from_usize(__mq.len()); __mq.insert(&__values[..], &[__ptr], G::from_bool(!unconstrained)); __ptr } }; - let __ret: [G; OUT_210] = [__v_32]; - if let Some(result) = record.function_queries[210].get_mut(&inp[..]) { debug_assert_eq!(result.output, &__ret[..]); if !unconstrained { *result.multiplicity += G::ONE; } } else { record.function_queries[210].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained)); }; + let __ret: [G; OUT_206] = [__v_32]; + if let Some(result) = record.function_queries[206].get_mut(&inp[..]) { debug_assert_eq!(result.output, &__ret[..]); if !unconstrained { *result.multiplicity += G::ONE; } } else { record.function_queries[206].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained)); }; return Ok(__ret); }) } -const INPUT_SIZE_211: usize = 0; -const IN_211: usize = 0; -const OUT_211: usize = 1; -fn aiur_fn_211( - inp: [G; IN_211], +const INPUT_SIZE_207: usize = 0; +const IN_207: usize = 0; +const OUT_207: usize = 1; +fn aiur_fn_207( + inp: [G; IN_207], record: &mut QueryRecord, io_buffer: &mut IOBuffer, unconstrained: bool, -) -> Result<[G; OUT_211], ExecError> { +) -> Result<[G; OUT_207], ExecError> { stacker::maybe_grow(64 * 1024, 4 * 1024 * 1024, || { let __v_0: G = G::from_u64(119); let __v_1: G = G::from_u64(213); @@ -20395,21 +20121,21 @@ fn aiur_fn_211( let __v_30: G = G::from_u64(2); let __v_31: G = G::from_u64(160); let __v_32: G = { let __values: [G; 32] = [__v_0, __v_1, __v_2, __v_3, __v_4, __v_5, __v_6, __v_7, __v_8, __v_9, __v_10, __v_11, __v_12, __v_13, __v_14, __v_15, __v_16, __v_17, __v_18, __v_19, __v_20, __v_21, __v_22, __v_23, __v_24, __v_25, __v_26, __v_27, __v_28, __v_29, __v_30, __v_31]; let __mq = record.memory_queries.get_mut(&32).ok_or(ExecError::InvalidMemorySize(32))?; if let Some(result) = __mq.get_mut(&__values[..]) { if !unconstrained { *result.multiplicity += G::ONE; } result.output[0] } else { let __ptr = G::from_usize(__mq.len()); __mq.insert(&__values[..], &[__ptr], G::from_bool(!unconstrained)); __ptr } }; - let __ret: [G; OUT_211] = [__v_32]; - if let Some(result) = record.function_queries[211].get_mut(&inp[..]) { debug_assert_eq!(result.output, &__ret[..]); if !unconstrained { *result.multiplicity += G::ONE; } } else { record.function_queries[211].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained)); }; + let __ret: [G; OUT_207] = [__v_32]; + if let Some(result) = record.function_queries[207].get_mut(&inp[..]) { debug_assert_eq!(result.output, &__ret[..]); if !unconstrained { *result.multiplicity += G::ONE; } } else { record.function_queries[207].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained)); }; return Ok(__ret); }) } -const INPUT_SIZE_212: usize = 0; -const IN_212: usize = 0; -const OUT_212: usize = 1; -fn aiur_fn_212( - inp: [G; IN_212], +const INPUT_SIZE_208: usize = 0; +const IN_208: usize = 0; +const OUT_208: usize = 1; +fn aiur_fn_208( + inp: [G; IN_208], record: &mut QueryRecord, io_buffer: &mut IOBuffer, unconstrained: bool, -) -> Result<[G; OUT_212], ExecError> { +) -> Result<[G; OUT_208], ExecError> { stacker::maybe_grow(64 * 1024, 4 * 1024 * 1024, || { let __v_0: G = G::from_u64(32); let __v_1: G = G::from_u64(59); @@ -20444,21 +20170,21 @@ fn aiur_fn_212( let __v_30: G = G::from_u64(110); let __v_31: G = G::from_u64(238); let __v_32: G = { let __values: [G; 32] = [__v_0, __v_1, __v_2, __v_3, __v_4, __v_5, __v_6, __v_7, __v_8, __v_9, __v_10, __v_11, __v_12, __v_13, __v_14, __v_15, __v_16, __v_17, __v_18, __v_19, __v_20, __v_21, __v_22, __v_23, __v_24, __v_25, __v_26, __v_27, __v_28, __v_29, __v_30, __v_31]; let __mq = record.memory_queries.get_mut(&32).ok_or(ExecError::InvalidMemorySize(32))?; if let Some(result) = __mq.get_mut(&__values[..]) { if !unconstrained { *result.multiplicity += G::ONE; } result.output[0] } else { let __ptr = G::from_usize(__mq.len()); __mq.insert(&__values[..], &[__ptr], G::from_bool(!unconstrained)); __ptr } }; - let __ret: [G; OUT_212] = [__v_32]; - if let Some(result) = record.function_queries[212].get_mut(&inp[..]) { debug_assert_eq!(result.output, &__ret[..]); if !unconstrained { *result.multiplicity += G::ONE; } } else { record.function_queries[212].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained)); }; + let __ret: [G; OUT_208] = [__v_32]; + if let Some(result) = record.function_queries[208].get_mut(&inp[..]) { debug_assert_eq!(result.output, &__ret[..]); if !unconstrained { *result.multiplicity += G::ONE; } } else { record.function_queries[208].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained)); }; return Ok(__ret); }) } -const INPUT_SIZE_213: usize = 0; -const IN_213: usize = 0; -const OUT_213: usize = 1; -fn aiur_fn_213( - inp: [G; IN_213], +const INPUT_SIZE_209: usize = 0; +const IN_209: usize = 0; +const OUT_209: usize = 1; +fn aiur_fn_209( + inp: [G; IN_209], record: &mut QueryRecord, io_buffer: &mut IOBuffer, unconstrained: bool, -) -> Result<[G; OUT_213], ExecError> { +) -> Result<[G; OUT_209], ExecError> { stacker::maybe_grow(64 * 1024, 4 * 1024 * 1024, || { let __v_0: G = G::from_u64(84); let __v_1: G = G::from_u64(139); @@ -20493,21 +20219,21 @@ fn aiur_fn_213( let __v_30: G = G::from_u64(29); let __v_31: G = G::from_u64(101); let __v_32: G = { let __values: [G; 32] = [__v_0, __v_1, __v_2, __v_3, __v_4, __v_5, __v_6, __v_7, __v_8, __v_9, __v_10, __v_11, __v_12, __v_13, __v_14, __v_15, __v_16, __v_17, __v_18, __v_19, __v_20, __v_21, __v_22, __v_23, __v_24, __v_25, __v_26, __v_27, __v_28, __v_29, __v_30, __v_31]; let __mq = record.memory_queries.get_mut(&32).ok_or(ExecError::InvalidMemorySize(32))?; if let Some(result) = __mq.get_mut(&__values[..]) { if !unconstrained { *result.multiplicity += G::ONE; } result.output[0] } else { let __ptr = G::from_usize(__mq.len()); __mq.insert(&__values[..], &[__ptr], G::from_bool(!unconstrained)); __ptr } }; - let __ret: [G; OUT_213] = [__v_32]; - if let Some(result) = record.function_queries[213].get_mut(&inp[..]) { debug_assert_eq!(result.output, &__ret[..]); if !unconstrained { *result.multiplicity += G::ONE; } } else { record.function_queries[213].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained)); }; + let __ret: [G; OUT_209] = [__v_32]; + if let Some(result) = record.function_queries[209].get_mut(&inp[..]) { debug_assert_eq!(result.output, &__ret[..]); if !unconstrained { *result.multiplicity += G::ONE; } } else { record.function_queries[209].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained)); }; return Ok(__ret); }) } -const INPUT_SIZE_214: usize = 0; -const IN_214: usize = 0; -const OUT_214: usize = 1; -fn aiur_fn_214( - inp: [G; IN_214], +const INPUT_SIZE_210: usize = 0; +const IN_210: usize = 0; +const OUT_210: usize = 1; +fn aiur_fn_210( + inp: [G; IN_210], record: &mut QueryRecord, io_buffer: &mut IOBuffer, unconstrained: bool, -) -> Result<[G; OUT_214], ExecError> { +) -> Result<[G; OUT_210], ExecError> { stacker::maybe_grow(64 * 1024, 4 * 1024 * 1024, || { let __v_0: G = G::from_u64(239); let __v_1: G = G::from_u64(78); @@ -20542,21 +20268,21 @@ fn aiur_fn_214( let __v_30: G = G::from_u64(253); let __v_31: G = G::from_u64(201); let __v_32: G = { let __values: [G; 32] = [__v_0, __v_1, __v_2, __v_3, __v_4, __v_5, __v_6, __v_7, __v_8, __v_9, __v_10, __v_11, __v_12, __v_13, __v_14, __v_15, __v_16, __v_17, __v_18, __v_19, __v_20, __v_21, __v_22, __v_23, __v_24, __v_25, __v_26, __v_27, __v_28, __v_29, __v_30, __v_31]; let __mq = record.memory_queries.get_mut(&32).ok_or(ExecError::InvalidMemorySize(32))?; if let Some(result) = __mq.get_mut(&__values[..]) { if !unconstrained { *result.multiplicity += G::ONE; } result.output[0] } else { let __ptr = G::from_usize(__mq.len()); __mq.insert(&__values[..], &[__ptr], G::from_bool(!unconstrained)); __ptr } }; - let __ret: [G; OUT_214] = [__v_32]; - if let Some(result) = record.function_queries[214].get_mut(&inp[..]) { debug_assert_eq!(result.output, &__ret[..]); if !unconstrained { *result.multiplicity += G::ONE; } } else { record.function_queries[214].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained)); }; + let __ret: [G; OUT_210] = [__v_32]; + if let Some(result) = record.function_queries[210].get_mut(&inp[..]) { debug_assert_eq!(result.output, &__ret[..]); if !unconstrained { *result.multiplicity += G::ONE; } } else { record.function_queries[210].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained)); }; return Ok(__ret); }) } -const INPUT_SIZE_215: usize = 0; -const IN_215: usize = 0; -const OUT_215: usize = 1; -fn aiur_fn_215( - inp: [G; IN_215], +const INPUT_SIZE_211: usize = 0; +const IN_211: usize = 0; +const OUT_211: usize = 1; +fn aiur_fn_211( + inp: [G; IN_211], record: &mut QueryRecord, io_buffer: &mut IOBuffer, unconstrained: bool, -) -> Result<[G; OUT_215], ExecError> { +) -> Result<[G; OUT_211], ExecError> { stacker::maybe_grow(64 * 1024, 4 * 1024 * 1024, || { let __v_0: G = G::from_u64(135); let __v_1: G = G::from_u64(9); @@ -20591,21 +20317,21 @@ fn aiur_fn_215( let __v_30: G = G::from_u64(12); let __v_31: G = G::from_u64(41); let __v_32: G = { let __values: [G; 32] = [__v_0, __v_1, __v_2, __v_3, __v_4, __v_5, __v_6, __v_7, __v_8, __v_9, __v_10, __v_11, __v_12, __v_13, __v_14, __v_15, __v_16, __v_17, __v_18, __v_19, __v_20, __v_21, __v_22, __v_23, __v_24, __v_25, __v_26, __v_27, __v_28, __v_29, __v_30, __v_31]; let __mq = record.memory_queries.get_mut(&32).ok_or(ExecError::InvalidMemorySize(32))?; if let Some(result) = __mq.get_mut(&__values[..]) { if !unconstrained { *result.multiplicity += G::ONE; } result.output[0] } else { let __ptr = G::from_usize(__mq.len()); __mq.insert(&__values[..], &[__ptr], G::from_bool(!unconstrained)); __ptr } }; - let __ret: [G; OUT_215] = [__v_32]; - if let Some(result) = record.function_queries[215].get_mut(&inp[..]) { debug_assert_eq!(result.output, &__ret[..]); if !unconstrained { *result.multiplicity += G::ONE; } } else { record.function_queries[215].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained)); }; + let __ret: [G; OUT_211] = [__v_32]; + if let Some(result) = record.function_queries[211].get_mut(&inp[..]) { debug_assert_eq!(result.output, &__ret[..]); if !unconstrained { *result.multiplicity += G::ONE; } } else { record.function_queries[211].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained)); }; return Ok(__ret); }) } -const INPUT_SIZE_216: usize = 0; -const IN_216: usize = 0; -const OUT_216: usize = 1; -fn aiur_fn_216( - inp: [G; IN_216], +const INPUT_SIZE_212: usize = 0; +const IN_212: usize = 0; +const OUT_212: usize = 1; +fn aiur_fn_212( + inp: [G; IN_212], record: &mut QueryRecord, io_buffer: &mut IOBuffer, unconstrained: bool, -) -> Result<[G; OUT_216], ExecError> { +) -> Result<[G; OUT_212], ExecError> { stacker::maybe_grow(64 * 1024, 4 * 1024 * 1024, || { let __v_0: G = G::from_u64(13); let __v_1: G = G::from_u64(35); @@ -20640,21 +20366,21 @@ fn aiur_fn_216( let __v_30: G = G::from_u64(226); let __v_31: G = G::from_u64(34); let __v_32: G = { let __values: [G; 32] = [__v_0, __v_1, __v_2, __v_3, __v_4, __v_5, __v_6, __v_7, __v_8, __v_9, __v_10, __v_11, __v_12, __v_13, __v_14, __v_15, __v_16, __v_17, __v_18, __v_19, __v_20, __v_21, __v_22, __v_23, __v_24, __v_25, __v_26, __v_27, __v_28, __v_29, __v_30, __v_31]; let __mq = record.memory_queries.get_mut(&32).ok_or(ExecError::InvalidMemorySize(32))?; if let Some(result) = __mq.get_mut(&__values[..]) { if !unconstrained { *result.multiplicity += G::ONE; } result.output[0] } else { let __ptr = G::from_usize(__mq.len()); __mq.insert(&__values[..], &[__ptr], G::from_bool(!unconstrained)); __ptr } }; - let __ret: [G; OUT_216] = [__v_32]; - if let Some(result) = record.function_queries[216].get_mut(&inp[..]) { debug_assert_eq!(result.output, &__ret[..]); if !unconstrained { *result.multiplicity += G::ONE; } } else { record.function_queries[216].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained)); }; + let __ret: [G; OUT_212] = [__v_32]; + if let Some(result) = record.function_queries[212].get_mut(&inp[..]) { debug_assert_eq!(result.output, &__ret[..]); if !unconstrained { *result.multiplicity += G::ONE; } } else { record.function_queries[212].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained)); }; return Ok(__ret); }) } -const INPUT_SIZE_217: usize = 0; -const IN_217: usize = 0; -const OUT_217: usize = 1; -fn aiur_fn_217( - inp: [G; IN_217], +const INPUT_SIZE_213: usize = 0; +const IN_213: usize = 0; +const OUT_213: usize = 1; +fn aiur_fn_213( + inp: [G; IN_213], record: &mut QueryRecord, io_buffer: &mut IOBuffer, unconstrained: bool, -) -> Result<[G; OUT_217], ExecError> { +) -> Result<[G; OUT_213], ExecError> { stacker::maybe_grow(64 * 1024, 4 * 1024 * 1024, || { let __v_0: G = G::from_u64(20); let __v_1: G = G::from_u64(207); @@ -20689,21 +20415,21 @@ fn aiur_fn_217( let __v_30: G = G::from_u64(229); let __v_31: G = G::from_u64(107); let __v_32: G = { let __values: [G; 32] = [__v_0, __v_1, __v_2, __v_3, __v_4, __v_5, __v_6, __v_7, __v_8, __v_9, __v_10, __v_11, __v_12, __v_13, __v_14, __v_15, __v_16, __v_17, __v_18, __v_19, __v_20, __v_21, __v_22, __v_23, __v_24, __v_25, __v_26, __v_27, __v_28, __v_29, __v_30, __v_31]; let __mq = record.memory_queries.get_mut(&32).ok_or(ExecError::InvalidMemorySize(32))?; if let Some(result) = __mq.get_mut(&__values[..]) { if !unconstrained { *result.multiplicity += G::ONE; } result.output[0] } else { let __ptr = G::from_usize(__mq.len()); __mq.insert(&__values[..], &[__ptr], G::from_bool(!unconstrained)); __ptr } }; - let __ret: [G; OUT_217] = [__v_32]; - if let Some(result) = record.function_queries[217].get_mut(&inp[..]) { debug_assert_eq!(result.output, &__ret[..]); if !unconstrained { *result.multiplicity += G::ONE; } } else { record.function_queries[217].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained)); }; + let __ret: [G; OUT_213] = [__v_32]; + if let Some(result) = record.function_queries[213].get_mut(&inp[..]) { debug_assert_eq!(result.output, &__ret[..]); if !unconstrained { *result.multiplicity += G::ONE; } } else { record.function_queries[213].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained)); }; return Ok(__ret); }) } -const INPUT_SIZE_218: usize = 0; -const IN_218: usize = 0; -const OUT_218: usize = 1; -fn aiur_fn_218( - inp: [G; IN_218], +const INPUT_SIZE_214: usize = 0; +const IN_214: usize = 0; +const OUT_214: usize = 1; +fn aiur_fn_214( + inp: [G; IN_214], record: &mut QueryRecord, io_buffer: &mut IOBuffer, unconstrained: bool, -) -> Result<[G; OUT_218], ExecError> { +) -> Result<[G; OUT_214], ExecError> { stacker::maybe_grow(64 * 1024, 4 * 1024 * 1024, || { let __v_0: G = G::from_u64(253); let __v_1: G = G::from_u64(83); @@ -20738,110 +20464,110 @@ fn aiur_fn_218( let __v_30: G = G::from_u64(101); let __v_31: G = G::from_u64(135); let __v_32: G = { let __values: [G; 32] = [__v_0, __v_1, __v_2, __v_3, __v_4, __v_5, __v_6, __v_7, __v_8, __v_9, __v_10, __v_11, __v_12, __v_13, __v_14, __v_15, __v_16, __v_17, __v_18, __v_19, __v_20, __v_21, __v_22, __v_23, __v_24, __v_25, __v_26, __v_27, __v_28, __v_29, __v_30, __v_31]; let __mq = record.memory_queries.get_mut(&32).ok_or(ExecError::InvalidMemorySize(32))?; if let Some(result) = __mq.get_mut(&__values[..]) { if !unconstrained { *result.multiplicity += G::ONE; } result.output[0] } else { let __ptr = G::from_usize(__mq.len()); __mq.insert(&__values[..], &[__ptr], G::from_bool(!unconstrained)); __ptr } }; - let __ret: [G; OUT_218] = [__v_32]; - if let Some(result) = record.function_queries[218].get_mut(&inp[..]) { debug_assert_eq!(result.output, &__ret[..]); if !unconstrained { *result.multiplicity += G::ONE; } } else { record.function_queries[218].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained)); }; + let __ret: [G; OUT_214] = [__v_32]; + if let Some(result) = record.function_queries[214].get_mut(&inp[..]) { debug_assert_eq!(result.output, &__ret[..]); if !unconstrained { *result.multiplicity += G::ONE; } } else { record.function_queries[214].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained)); }; return Ok(__ret); }) } -const INPUT_SIZE_219: usize = 1; -const IN_219: usize = 1; -const OUT_219: usize = 1; -fn aiur_fn_219( - inp: [G; IN_219], +const INPUT_SIZE_215: usize = 1; +const IN_215: usize = 1; +const OUT_215: usize = 1; +fn aiur_fn_215( + inp: [G; IN_215], record: &mut QueryRecord, io_buffer: &mut IOBuffer, unconstrained: bool, -) -> Result<[G; OUT_219], ExecError> { +) -> Result<[G; OUT_215], ExecError> { stacker::maybe_grow(64 * 1024, 4 * 1024 * 1024, || { let __v_0: G = inp[0]; - let __r_arr: [G; OUT_206] = { let __args: [G; IN_206] = []; let __cu = unconstrained; if let Some(result) = record.function_queries[206].get_mut(&__args[..]) { if !__cu && *result.multiplicity == G::ZERO { aiur_fn_206(__args, record, io_buffer, false)? } else { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_206] = unsafe { *(result.output.as_ptr() as *const [G; OUT_206]) }; __ret } } else { aiur_fn_206(__args, record, io_buffer, __cu)? } }; + let __r_arr: [G; OUT_202] = { let __args: [G; IN_202] = []; let __cu = unconstrained; if let Some(result) = record.function_queries[202].get_mut(&__args[..]) { if !__cu && *result.multiplicity == G::ZERO { aiur_fn_202(__args, record, io_buffer, false)? } else { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_202] = unsafe { *(result.output.as_ptr() as *const [G; OUT_202]) }; __ret } } else { aiur_fn_202(__args, record, io_buffer, __cu)? } }; let __v_1: G = __r_arr[0]; let __r_arr: [G; OUT_1] = { let __args: [G; IN_1] = [__v_0, __v_1]; let __cu = unconstrained; if let Some(result) = record.function_queries[1].get_mut(&__args[..]) { if !__cu && *result.multiplicity == G::ZERO { aiur_fn_1(__args, record, io_buffer, false)? } else { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_1] = unsafe { *(result.output.as_ptr() as *const [G; OUT_1]) }; __ret } } else { aiur_fn_1(__args, record, io_buffer, __cu)? } }; let __v_2: G = __r_arr[0]; match __v_2.as_canonical_u64() { 1u64 => { let __v_3: G = G::from_u64(1); - let __ret: [G; OUT_219] = [__v_3]; - if let Some(result) = record.function_queries[219].get_mut(&inp[..]) { debug_assert_eq!(result.output, &__ret[..]); if !unconstrained { *result.multiplicity += G::ONE; } } else { record.function_queries[219].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained)); }; + let __ret: [G; OUT_215] = [__v_3]; + if let Some(result) = record.function_queries[215].get_mut(&inp[..]) { debug_assert_eq!(result.output, &__ret[..]); if !unconstrained { *result.multiplicity += G::ONE; } } else { record.function_queries[215].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained)); }; return Ok(__ret); }, _ => { - let __r_arr: [G; OUT_207] = { let __args: [G; IN_207] = []; let __cu = unconstrained; if let Some(result) = record.function_queries[207].get_mut(&__args[..]) { if !__cu && *result.multiplicity == G::ZERO { aiur_fn_207(__args, record, io_buffer, false)? } else { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_207] = unsafe { *(result.output.as_ptr() as *const [G; OUT_207]) }; __ret } } else { aiur_fn_207(__args, record, io_buffer, __cu)? } }; + let __r_arr: [G; OUT_203] = { let __args: [G; IN_203] = []; let __cu = unconstrained; if let Some(result) = record.function_queries[203].get_mut(&__args[..]) { if !__cu && *result.multiplicity == G::ZERO { aiur_fn_203(__args, record, io_buffer, false)? } else { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_203] = unsafe { *(result.output.as_ptr() as *const [G; OUT_203]) }; __ret } } else { aiur_fn_203(__args, record, io_buffer, __cu)? } }; let __v_3: G = __r_arr[0]; let __r_arr: [G; OUT_1] = { let __args: [G; IN_1] = [__v_0, __v_3]; let __cu = unconstrained; if let Some(result) = record.function_queries[1].get_mut(&__args[..]) { if !__cu && *result.multiplicity == G::ZERO { aiur_fn_1(__args, record, io_buffer, false)? } else { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_1] = unsafe { *(result.output.as_ptr() as *const [G; OUT_1]) }; __ret } } else { aiur_fn_1(__args, record, io_buffer, __cu)? } }; let __v_4: G = __r_arr[0]; match __v_4.as_canonical_u64() { 1u64 => { let __v_5: G = G::from_u64(1); - let __ret: [G; OUT_219] = [__v_5]; - if let Some(result) = record.function_queries[219].get_mut(&inp[..]) { debug_assert_eq!(result.output, &__ret[..]); if !unconstrained { *result.multiplicity += G::ONE; } } else { record.function_queries[219].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained)); }; + let __ret: [G; OUT_215] = [__v_5]; + if let Some(result) = record.function_queries[215].get_mut(&inp[..]) { debug_assert_eq!(result.output, &__ret[..]); if !unconstrained { *result.multiplicity += G::ONE; } } else { record.function_queries[215].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained)); }; return Ok(__ret); }, _ => { - let __r_arr: [G; OUT_208] = { let __args: [G; IN_208] = []; let __cu = unconstrained; if let Some(result) = record.function_queries[208].get_mut(&__args[..]) { if !__cu && *result.multiplicity == G::ZERO { aiur_fn_208(__args, record, io_buffer, false)? } else { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_208] = unsafe { *(result.output.as_ptr() as *const [G; OUT_208]) }; __ret } } else { aiur_fn_208(__args, record, io_buffer, __cu)? } }; + let __r_arr: [G; OUT_204] = { let __args: [G; IN_204] = []; let __cu = unconstrained; if let Some(result) = record.function_queries[204].get_mut(&__args[..]) { if !__cu && *result.multiplicity == G::ZERO { aiur_fn_204(__args, record, io_buffer, false)? } else { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_204] = unsafe { *(result.output.as_ptr() as *const [G; OUT_204]) }; __ret } } else { aiur_fn_204(__args, record, io_buffer, __cu)? } }; let __v_5: G = __r_arr[0]; let __r_arr: [G; OUT_1] = { let __args: [G; IN_1] = [__v_0, __v_5]; let __cu = unconstrained; if let Some(result) = record.function_queries[1].get_mut(&__args[..]) { if !__cu && *result.multiplicity == G::ZERO { aiur_fn_1(__args, record, io_buffer, false)? } else { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_1] = unsafe { *(result.output.as_ptr() as *const [G; OUT_1]) }; __ret } } else { aiur_fn_1(__args, record, io_buffer, __cu)? } }; let __v_6: G = __r_arr[0]; match __v_6.as_canonical_u64() { 1u64 => { let __v_7: G = G::from_u64(1); - let __ret: [G; OUT_219] = [__v_7]; - if let Some(result) = record.function_queries[219].get_mut(&inp[..]) { debug_assert_eq!(result.output, &__ret[..]); if !unconstrained { *result.multiplicity += G::ONE; } } else { record.function_queries[219].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained)); }; + let __ret: [G; OUT_215] = [__v_7]; + if let Some(result) = record.function_queries[215].get_mut(&inp[..]) { debug_assert_eq!(result.output, &__ret[..]); if !unconstrained { *result.multiplicity += G::ONE; } } else { record.function_queries[215].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained)); }; return Ok(__ret); }, _ => { - let __r_arr: [G; OUT_213] = { let __args: [G; IN_213] = []; let __cu = unconstrained; if let Some(result) = record.function_queries[213].get_mut(&__args[..]) { if !__cu && *result.multiplicity == G::ZERO { aiur_fn_213(__args, record, io_buffer, false)? } else { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_213] = unsafe { *(result.output.as_ptr() as *const [G; OUT_213]) }; __ret } } else { aiur_fn_213(__args, record, io_buffer, __cu)? } }; + let __r_arr: [G; OUT_209] = { let __args: [G; IN_209] = []; let __cu = unconstrained; if let Some(result) = record.function_queries[209].get_mut(&__args[..]) { if !__cu && *result.multiplicity == G::ZERO { aiur_fn_209(__args, record, io_buffer, false)? } else { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_209] = unsafe { *(result.output.as_ptr() as *const [G; OUT_209]) }; __ret } } else { aiur_fn_209(__args, record, io_buffer, __cu)? } }; let __v_7: G = __r_arr[0]; let __r_arr: [G; OUT_1] = { let __args: [G; IN_1] = [__v_0, __v_7]; let __cu = unconstrained; if let Some(result) = record.function_queries[1].get_mut(&__args[..]) { if !__cu && *result.multiplicity == G::ZERO { aiur_fn_1(__args, record, io_buffer, false)? } else { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_1] = unsafe { *(result.output.as_ptr() as *const [G; OUT_1]) }; __ret } } else { aiur_fn_1(__args, record, io_buffer, __cu)? } }; let __v_8: G = __r_arr[0]; match __v_8.as_canonical_u64() { 1u64 => { let __v_9: G = G::from_u64(1); - let __ret: [G; OUT_219] = [__v_9]; - if let Some(result) = record.function_queries[219].get_mut(&inp[..]) { debug_assert_eq!(result.output, &__ret[..]); if !unconstrained { *result.multiplicity += G::ONE; } } else { record.function_queries[219].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained)); }; + let __ret: [G; OUT_215] = [__v_9]; + if let Some(result) = record.function_queries[215].get_mut(&inp[..]) { debug_assert_eq!(result.output, &__ret[..]); if !unconstrained { *result.multiplicity += G::ONE; } } else { record.function_queries[215].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained)); }; return Ok(__ret); }, _ => { - let __r_arr: [G; OUT_214] = { let __args: [G; IN_214] = []; let __cu = unconstrained; if let Some(result) = record.function_queries[214].get_mut(&__args[..]) { if !__cu && *result.multiplicity == G::ZERO { aiur_fn_214(__args, record, io_buffer, false)? } else { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_214] = unsafe { *(result.output.as_ptr() as *const [G; OUT_214]) }; __ret } } else { aiur_fn_214(__args, record, io_buffer, __cu)? } }; + let __r_arr: [G; OUT_210] = { let __args: [G; IN_210] = []; let __cu = unconstrained; if let Some(result) = record.function_queries[210].get_mut(&__args[..]) { if !__cu && *result.multiplicity == G::ZERO { aiur_fn_210(__args, record, io_buffer, false)? } else { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_210] = unsafe { *(result.output.as_ptr() as *const [G; OUT_210]) }; __ret } } else { aiur_fn_210(__args, record, io_buffer, __cu)? } }; let __v_9: G = __r_arr[0]; let __r_arr: [G; OUT_1] = { let __args: [G; IN_1] = [__v_0, __v_9]; let __cu = unconstrained; if let Some(result) = record.function_queries[1].get_mut(&__args[..]) { if !__cu && *result.multiplicity == G::ZERO { aiur_fn_1(__args, record, io_buffer, false)? } else { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_1] = unsafe { *(result.output.as_ptr() as *const [G; OUT_1]) }; __ret } } else { aiur_fn_1(__args, record, io_buffer, __cu)? } }; let __v_10: G = __r_arr[0]; match __v_10.as_canonical_u64() { 1u64 => { let __v_11: G = G::from_u64(1); - let __ret: [G; OUT_219] = [__v_11]; - if let Some(result) = record.function_queries[219].get_mut(&inp[..]) { debug_assert_eq!(result.output, &__ret[..]); if !unconstrained { *result.multiplicity += G::ONE; } } else { record.function_queries[219].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained)); }; + let __ret: [G; OUT_215] = [__v_11]; + if let Some(result) = record.function_queries[215].get_mut(&inp[..]) { debug_assert_eq!(result.output, &__ret[..]); if !unconstrained { *result.multiplicity += G::ONE; } } else { record.function_queries[215].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained)); }; return Ok(__ret); }, _ => { - let __r_arr: [G; OUT_215] = { let __args: [G; IN_215] = []; let __cu = unconstrained; if let Some(result) = record.function_queries[215].get_mut(&__args[..]) { if !__cu && *result.multiplicity == G::ZERO { aiur_fn_215(__args, record, io_buffer, false)? } else { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_215] = unsafe { *(result.output.as_ptr() as *const [G; OUT_215]) }; __ret } } else { aiur_fn_215(__args, record, io_buffer, __cu)? } }; + let __r_arr: [G; OUT_211] = { let __args: [G; IN_211] = []; let __cu = unconstrained; if let Some(result) = record.function_queries[211].get_mut(&__args[..]) { if !__cu && *result.multiplicity == G::ZERO { aiur_fn_211(__args, record, io_buffer, false)? } else { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_211] = unsafe { *(result.output.as_ptr() as *const [G; OUT_211]) }; __ret } } else { aiur_fn_211(__args, record, io_buffer, __cu)? } }; let __v_11: G = __r_arr[0]; let __r_arr: [G; OUT_1] = { let __args: [G; IN_1] = [__v_0, __v_11]; let __cu = unconstrained; if let Some(result) = record.function_queries[1].get_mut(&__args[..]) { if !__cu && *result.multiplicity == G::ZERO { aiur_fn_1(__args, record, io_buffer, false)? } else { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_1] = unsafe { *(result.output.as_ptr() as *const [G; OUT_1]) }; __ret } } else { aiur_fn_1(__args, record, io_buffer, __cu)? } }; let __v_12: G = __r_arr[0]; match __v_12.as_canonical_u64() { 1u64 => { let __v_13: G = G::from_u64(1); - let __ret: [G; OUT_219] = [__v_13]; - if let Some(result) = record.function_queries[219].get_mut(&inp[..]) { debug_assert_eq!(result.output, &__ret[..]); if !unconstrained { *result.multiplicity += G::ONE; } } else { record.function_queries[219].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained)); }; + let __ret: [G; OUT_215] = [__v_13]; + if let Some(result) = record.function_queries[215].get_mut(&inp[..]) { debug_assert_eq!(result.output, &__ret[..]); if !unconstrained { *result.multiplicity += G::ONE; } } else { record.function_queries[215].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained)); }; return Ok(__ret); }, _ => { - let __r_arr: [G; OUT_217] = { let __args: [G; IN_217] = []; let __cu = unconstrained; if let Some(result) = record.function_queries[217].get_mut(&__args[..]) { if !__cu && *result.multiplicity == G::ZERO { aiur_fn_217(__args, record, io_buffer, false)? } else { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_217] = unsafe { *(result.output.as_ptr() as *const [G; OUT_217]) }; __ret } } else { aiur_fn_217(__args, record, io_buffer, __cu)? } }; + let __r_arr: [G; OUT_213] = { let __args: [G; IN_213] = []; let __cu = unconstrained; if let Some(result) = record.function_queries[213].get_mut(&__args[..]) { if !__cu && *result.multiplicity == G::ZERO { aiur_fn_213(__args, record, io_buffer, false)? } else { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_213] = unsafe { *(result.output.as_ptr() as *const [G; OUT_213]) }; __ret } } else { aiur_fn_213(__args, record, io_buffer, __cu)? } }; let __v_13: G = __r_arr[0]; let __r_arr: [G; OUT_1] = { let __args: [G; IN_1] = [__v_0, __v_13]; let __cu = unconstrained; if let Some(result) = record.function_queries[1].get_mut(&__args[..]) { if !__cu && *result.multiplicity == G::ZERO { aiur_fn_1(__args, record, io_buffer, false)? } else { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_1] = unsafe { *(result.output.as_ptr() as *const [G; OUT_1]) }; __ret } } else { aiur_fn_1(__args, record, io_buffer, __cu)? } }; let __v_14: G = __r_arr[0]; match __v_14.as_canonical_u64() { 1u64 => { let __v_15: G = G::from_u64(1); - let __ret: [G; OUT_219] = [__v_15]; - if let Some(result) = record.function_queries[219].get_mut(&inp[..]) { debug_assert_eq!(result.output, &__ret[..]); if !unconstrained { *result.multiplicity += G::ONE; } } else { record.function_queries[219].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained)); }; + let __ret: [G; OUT_215] = [__v_15]; + if let Some(result) = record.function_queries[215].get_mut(&inp[..]) { debug_assert_eq!(result.output, &__ret[..]); if !unconstrained { *result.multiplicity += G::ONE; } } else { record.function_queries[215].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained)); }; return Ok(__ret); }, _ => { let __v_15: G = G::from_u64(0); - let __ret: [G; OUT_219] = [__v_15]; - if let Some(result) = record.function_queries[219].get_mut(&inp[..]) { debug_assert_eq!(result.output, &__ret[..]); if !unconstrained { *result.multiplicity += G::ONE; } } else { record.function_queries[219].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained)); }; + let __ret: [G; OUT_215] = [__v_15]; + if let Some(result) = record.function_queries[215].get_mut(&inp[..]) { debug_assert_eq!(result.output, &__ret[..]); if !unconstrained { *result.multiplicity += G::ONE; } } else { record.function_queries[215].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained)); }; return Ok(__ret); }, } @@ -20860,22 +20586,22 @@ fn aiur_fn_219( }) } -const INPUT_SIZE_220: usize = 3; -const IN_220: usize = 3; -const OUT_220: usize = 2; -fn aiur_fn_220( - inp: [G; IN_220], +const INPUT_SIZE_216: usize = 3; +const IN_216: usize = 3; +const OUT_216: usize = 2; +fn aiur_fn_216( + inp: [G; IN_216], record: &mut QueryRecord, io_buffer: &mut IOBuffer, unconstrained: bool, -) -> Result<[G; OUT_220], ExecError> { +) -> Result<[G; OUT_216], ExecError> { stacker::maybe_grow(64 * 1024, 4 * 1024 * 1024, || { let __v_0: G = inp[0]; let __v_1: G = inp[1]; let __v_2: G = inp[2]; - let __r_arr: [G; OUT_764] = { let __args: [G; IN_764] = [__v_1]; let __cu = unconstrained; if let Some(result) = record.function_queries[764].get_mut(&__args[..]) { if !__cu && *result.multiplicity == G::ZERO { aiur_fn_764(__args, record, io_buffer, false)? } else { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_764] = unsafe { *(result.output.as_ptr() as *const [G; OUT_764]) }; __ret } } else { aiur_fn_764(__args, record, io_buffer, __cu)? } }; + let __r_arr: [G; OUT_760] = { let __args: [G; IN_760] = [__v_1]; let __cu = unconstrained; if let Some(result) = record.function_queries[760].get_mut(&__args[..]) { if !__cu && *result.multiplicity == G::ZERO { aiur_fn_760(__args, record, io_buffer, false)? } else { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_760] = unsafe { *(result.output.as_ptr() as *const [G; OUT_760]) }; __ret } } else { aiur_fn_760(__args, record, io_buffer, __cu)? } }; let __v_3: G = __r_arr[0]; - let __r_arr: [G; OUT_208] = { let __args: [G; IN_208] = []; let __cu = unconstrained; if let Some(result) = record.function_queries[208].get_mut(&__args[..]) { if !__cu && *result.multiplicity == G::ZERO { aiur_fn_208(__args, record, io_buffer, false)? } else { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_208] = unsafe { *(result.output.as_ptr() as *const [G; OUT_208]) }; __ret } } else { aiur_fn_208(__args, record, io_buffer, __cu)? } }; + let __r_arr: [G; OUT_204] = { let __args: [G; IN_204] = []; let __cu = unconstrained; if let Some(result) = record.function_queries[204].get_mut(&__args[..]) { if !__cu && *result.multiplicity == G::ZERO { aiur_fn_204(__args, record, io_buffer, false)? } else { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_204] = unsafe { *(result.output.as_ptr() as *const [G; OUT_204]) }; __ret } } else { aiur_fn_204(__args, record, io_buffer, __cu)? } }; let __v_4: G = __r_arr[0]; let __r_arr: [G; OUT_1] = { let __args: [G; IN_1] = [__v_0, __v_4]; let __cu = unconstrained; if let Some(result) = record.function_queries[1].get_mut(&__args[..]) { if !__cu && *result.multiplicity == G::ZERO { aiur_fn_1(__args, record, io_buffer, false)? } else { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_1] = unsafe { *(result.output.as_ptr() as *const [G; OUT_1]) }; __ret } } else { aiur_fn_1(__args, record, io_buffer, __cu)? } }; let __v_5: G = __r_arr[0]; @@ -20884,9 +20610,9 @@ fn aiur_fn_220( match __v_3.as_canonical_u64() { 1u64 => { let __v_6: G = G::from_u64(0); - let __r_arr: [G; OUT_766] = { let __args: [G; IN_766] = [__v_1, __v_6]; let __cu = unconstrained; if let Some(result) = record.function_queries[766].get_mut(&__args[..]) { if !__cu && *result.multiplicity == G::ZERO { aiur_fn_766(__args, record, io_buffer, false)? } else { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_766] = unsafe { *(result.output.as_ptr() as *const [G; OUT_766]) }; __ret } } else { aiur_fn_766(__args, record, io_buffer, __cu)? } }; + let __r_arr: [G; OUT_762] = { let __args: [G; IN_762] = [__v_1, __v_6]; let __cu = unconstrained; if let Some(result) = record.function_queries[762].get_mut(&__args[..]) { if !__cu && *result.multiplicity == G::ZERO { aiur_fn_762(__args, record, io_buffer, false)? } else { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_762] = unsafe { *(result.output.as_ptr() as *const [G; OUT_762]) }; __ret } } else { aiur_fn_762(__args, record, io_buffer, __cu)? } }; let __v_7: G = __r_arr[0]; - let __r_arr: [G; OUT_234] = { let __args: [G; IN_234] = [__v_7, __v_2]; let __cu = unconstrained; if let Some(result) = record.function_queries[234].get_mut(&__args[..]) { if !__cu && *result.multiplicity == G::ZERO { aiur_fn_234(__args, record, io_buffer, false)? } else { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_234] = unsafe { *(result.output.as_ptr() as *const [G; OUT_234]) }; __ret } } else { aiur_fn_234(__args, record, io_buffer, __cu)? } }; + let __r_arr: [G; OUT_230] = { let __args: [G; IN_230] = [__v_7, __v_2]; let __cu = unconstrained; if let Some(result) = record.function_queries[230].get_mut(&__args[..]) { if !__cu && *result.multiplicity == G::ZERO { aiur_fn_230(__args, record, io_buffer, false)? } else { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_230] = unsafe { *(result.output.as_ptr() as *const [G; OUT_230]) }; __ret } } else { aiur_fn_230(__args, record, io_buffer, __cu)? } }; let __v_8: G = __r_arr[0]; let __v_9: G = __r_arr[1]; match __v_8.as_canonical_u64() { @@ -20896,8 +20622,8 @@ fn aiur_fn_220( let __v_12: G = G::from_u64(1); let __v_13: G = G::from_u64(0); let __v_14: G = { let __values: [G; 4] = [__v_11, __v_12, __v_9, __v_13]; let __mq = record.memory_queries.get_mut(&4).ok_or(ExecError::InvalidMemorySize(4))?; if let Some(result) = __mq.get_mut(&__values[..]) { if !unconstrained { *result.multiplicity += G::ONE; } result.output[0] } else { let __ptr = G::from_usize(__mq.len()); __mq.insert(&__values[..], &[__ptr], G::from_bool(!unconstrained)); __ptr } }; - let __ret: [G; OUT_220] = [__v_10, __v_14]; - if let Some(result) = record.function_queries[220].get_mut(&inp[..]) { debug_assert_eq!(result.output, &__ret[..]); if !unconstrained { *result.multiplicity += G::ONE; } } else { record.function_queries[220].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained)); }; + let __ret: [G; OUT_216] = [__v_10, __v_14]; + if let Some(result) = record.function_queries[216].get_mut(&inp[..]) { debug_assert_eq!(result.output, &__ret[..]); if !unconstrained { *result.multiplicity += G::ONE; } } else { record.function_queries[216].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained)); }; return Ok(__ret); }, 0u64 => { @@ -20906,8 +20632,8 @@ fn aiur_fn_220( let __v_12: G = G::from_u64(0); let __v_13: G = G::from_u64(0); let __v_14: G = { let __values: [G; 4] = [__v_11, __v_12, __v_13, __v_13]; let __mq = record.memory_queries.get_mut(&4).ok_or(ExecError::InvalidMemorySize(4))?; if let Some(result) = __mq.get_mut(&__values[..]) { if !unconstrained { *result.multiplicity += G::ONE; } result.output[0] } else { let __ptr = G::from_usize(__mq.len()); __mq.insert(&__values[..], &[__ptr], G::from_bool(!unconstrained)); __ptr } }; - let __ret: [G; OUT_220] = [__v_10, __v_14]; - if let Some(result) = record.function_queries[220].get_mut(&inp[..]) { debug_assert_eq!(result.output, &__ret[..]); if !unconstrained { *result.multiplicity += G::ONE; } } else { record.function_queries[220].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained)); }; + let __ret: [G; OUT_216] = [__v_10, __v_14]; + if let Some(result) = record.function_queries[216].get_mut(&inp[..]) { debug_assert_eq!(result.output, &__ret[..]); if !unconstrained { *result.multiplicity += G::ONE; } } else { record.function_queries[216].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained)); }; return Ok(__ret); }, _ => { @@ -20921,14 +20647,14 @@ fn aiur_fn_220( let __v_8: G = G::from_u64(0); let __v_9: G = G::from_u64(0); let __v_10: G = { let __values: [G; 4] = [__v_7, __v_8, __v_9, __v_9]; let __mq = record.memory_queries.get_mut(&4).ok_or(ExecError::InvalidMemorySize(4))?; if let Some(result) = __mq.get_mut(&__values[..]) { if !unconstrained { *result.multiplicity += G::ONE; } result.output[0] } else { let __ptr = G::from_usize(__mq.len()); __mq.insert(&__values[..], &[__ptr], G::from_bool(!unconstrained)); __ptr } }; - let __ret: [G; OUT_220] = [__v_6, __v_10]; - if let Some(result) = record.function_queries[220].get_mut(&inp[..]) { debug_assert_eq!(result.output, &__ret[..]); if !unconstrained { *result.multiplicity += G::ONE; } } else { record.function_queries[220].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained)); }; + let __ret: [G; OUT_216] = [__v_6, __v_10]; + if let Some(result) = record.function_queries[216].get_mut(&inp[..]) { debug_assert_eq!(result.output, &__ret[..]); if !unconstrained { *result.multiplicity += G::ONE; } } else { record.function_queries[216].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained)); }; return Ok(__ret); }, } }, _ => { - let __r_arr: [G; OUT_206] = { let __args: [G; IN_206] = []; let __cu = unconstrained; if let Some(result) = record.function_queries[206].get_mut(&__args[..]) { if !__cu && *result.multiplicity == G::ZERO { aiur_fn_206(__args, record, io_buffer, false)? } else { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_206] = unsafe { *(result.output.as_ptr() as *const [G; OUT_206]) }; __ret } } else { aiur_fn_206(__args, record, io_buffer, __cu)? } }; + let __r_arr: [G; OUT_202] = { let __args: [G; IN_202] = []; let __cu = unconstrained; if let Some(result) = record.function_queries[202].get_mut(&__args[..]) { if !__cu && *result.multiplicity == G::ZERO { aiur_fn_202(__args, record, io_buffer, false)? } else { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_202] = unsafe { *(result.output.as_ptr() as *const [G; OUT_202]) }; __ret } } else { aiur_fn_202(__args, record, io_buffer, __cu)? } }; let __v_6: G = __r_arr[0]; let __r_arr: [G; OUT_1] = { let __args: [G; IN_1] = [__v_0, __v_6]; let __cu = unconstrained; if let Some(result) = record.function_queries[1].get_mut(&__args[..]) { if !__cu && *result.multiplicity == G::ZERO { aiur_fn_1(__args, record, io_buffer, false)? } else { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_1] = unsafe { *(result.output.as_ptr() as *const [G; OUT_1]) }; __ret } } else { aiur_fn_1(__args, record, io_buffer, __cu)? } }; let __v_7: G = __r_arr[0]; @@ -20943,13 +20669,13 @@ fn aiur_fn_220( let __v_12: G = G::from_u64(0); let __v_13: G = G::from_u64(0); let __v_14: G = { let __values: [G; 4] = [__v_11, __v_12, __v_13, __v_13]; let __mq = record.memory_queries.get_mut(&4).ok_or(ExecError::InvalidMemorySize(4))?; if let Some(result) = __mq.get_mut(&__values[..]) { if !unconstrained { *result.multiplicity += G::ONE; } result.output[0] } else { let __ptr = G::from_usize(__mq.len()); __mq.insert(&__values[..], &[__ptr], G::from_bool(!unconstrained)); __ptr } }; - let __ret: [G; OUT_220] = [__v_10, __v_14]; - if let Some(result) = record.function_queries[220].get_mut(&inp[..]) { debug_assert_eq!(result.output, &__ret[..]); if !unconstrained { *result.multiplicity += G::ONE; } } else { record.function_queries[220].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained)); }; + let __ret: [G; OUT_216] = [__v_10, __v_14]; + if let Some(result) = record.function_queries[216].get_mut(&inp[..]) { debug_assert_eq!(result.output, &__ret[..]); if !unconstrained { *result.multiplicity += G::ONE; } } else { record.function_queries[216].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained)); }; return Ok(__ret); }, _ => { let __v_10: G = G::from_u64(0); - let __r_arr: [G; OUT_766] = { let __args: [G; IN_766] = [__v_1, __v_10]; let __cu = unconstrained; if let Some(result) = record.function_queries[766].get_mut(&__args[..]) { if !__cu && *result.multiplicity == G::ZERO { aiur_fn_766(__args, record, io_buffer, false)? } else { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_766] = unsafe { *(result.output.as_ptr() as *const [G; OUT_766]) }; __ret } } else { aiur_fn_766(__args, record, io_buffer, __cu)? } }; + let __r_arr: [G; OUT_762] = { let __args: [G; IN_762] = [__v_1, __v_10]; let __cu = unconstrained; if let Some(result) = record.function_queries[762].get_mut(&__args[..]) { if !__cu && *result.multiplicity == G::ZERO { aiur_fn_762(__args, record, io_buffer, false)? } else { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_762] = unsafe { *(result.output.as_ptr() as *const [G; OUT_762]) }; __ret } } else { aiur_fn_762(__args, record, io_buffer, __cu)? } }; let __v_11: G = __r_arr[0]; let __loaded: [G; 4] = { let __mq = record.memory_queries.get_mut(&4).ok_or(ExecError::InvalidMemorySize(4))?; let __ptr_u64 = __v_11.as_canonical_u64(); let __ptr_usize = usize::try_from(__ptr_u64).ok().ok_or(ExecError::PointerTooLarge(__ptr_u64))?; let (__args, __mult) = __mq.get_index_mut(__ptr_usize).ok_or(ExecError::UnboundPointer { ptr: __ptr_u64, size: 4 })?; if !unconstrained { *__mult += G::ONE; } let __arr: [G; 4] = __args[..4].try_into().unwrap(); __arr }; let __v_12: G = __loaded[0]; @@ -20960,19 +20686,17 @@ fn aiur_fn_220( 7u64 => { match __v_13.as_canonical_u64() { 1u64 => { - let __r_arr: [G; OUT_764] = { let __args: [G; IN_764] = [__v_14]; let __cu = unconstrained; if let Some(result) = record.function_queries[764].get_mut(&__args[..]) { if !__cu && *result.multiplicity == G::ZERO { aiur_fn_764(__args, record, io_buffer, false)? } else { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_764] = unsafe { *(result.output.as_ptr() as *const [G; OUT_764]) }; __ret } } else { aiur_fn_764(__args, record, io_buffer, __cu)? } }; + let __r_arr: [G; OUT_760] = { let __args: [G; IN_760] = [__v_14]; let __cu = unconstrained; if let Some(result) = record.function_queries[760].get_mut(&__args[..]) { if !__cu && *result.multiplicity == G::ZERO { aiur_fn_760(__args, record, io_buffer, false)? } else { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_760] = unsafe { *(result.output.as_ptr() as *const [G; OUT_760]) }; __ret } } else { aiur_fn_760(__args, record, io_buffer, __cu)? } }; let __v_16: G = __r_arr[0]; - let __r_arr: [G; OUT_233] = { let __args: [G; IN_233] = [__v_16]; let __cu = unconstrained; if let Some(result) = record.function_queries[233].get_mut(&__args[..]) { if !__cu && *result.multiplicity == G::ZERO { aiur_fn_233(__args, record, io_buffer, false)? } else { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_233] = unsafe { *(result.output.as_ptr() as *const [G; OUT_233]) }; __ret } } else { aiur_fn_233(__args, record, io_buffer, __cu)? } }; + let __r_arr: [G; OUT_229] = { let __args: [G; IN_229] = [__v_16]; let __cu = unconstrained; if let Some(result) = record.function_queries[229].get_mut(&__args[..]) { if !__cu && *result.multiplicity == G::ZERO { aiur_fn_229(__args, record, io_buffer, false)? } else { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_229] = unsafe { *(result.output.as_ptr() as *const [G; OUT_229]) }; __ret } } else { aiur_fn_229(__args, record, io_buffer, __cu)? } }; let __v_17: G = __r_arr[0]; - let __r_arr: [G; OUT_118] = { let __args: [G; IN_118] = [__v_17]; let __cu = unconstrained; if let Some(result) = record.function_queries[118].get_mut(&__args[..]) { if !__cu && *result.multiplicity == G::ZERO { aiur_fn_118(__args, record, io_buffer, false)? } else { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_118] = unsafe { *(result.output.as_ptr() as *const [G; OUT_118]) }; __ret } } else { aiur_fn_118(__args, record, io_buffer, __cu)? } }; - let __v_18: G = __r_arr[0]; - let __v_19: G = G::from_u64(1); - let __v_20: G = G::from_u64(7); + let __v_18: G = G::from_u64(1); + let __v_19: G = G::from_u64(7); + let __v_20: G = G::from_u64(0); let __v_21: G = G::from_u64(0); - let __v_22: G = G::from_u64(0); - let __v_23: G = { let __values: [G; 4] = [__v_20, __v_21, __v_18, __v_22]; let __mq = record.memory_queries.get_mut(&4).ok_or(ExecError::InvalidMemorySize(4))?; if let Some(result) = __mq.get_mut(&__values[..]) { if !unconstrained { *result.multiplicity += G::ONE; } result.output[0] } else { let __ptr = G::from_usize(__mq.len()); __mq.insert(&__values[..], &[__ptr], G::from_bool(!unconstrained)); __ptr } }; - let __ret: [G; OUT_220] = [__v_19, __v_23]; - if let Some(result) = record.function_queries[220].get_mut(&inp[..]) { debug_assert_eq!(result.output, &__ret[..]); if !unconstrained { *result.multiplicity += G::ONE; } } else { record.function_queries[220].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained)); }; + let __v_22: G = { let __values: [G; 4] = [__v_19, __v_20, __v_17, __v_21]; let __mq = record.memory_queries.get_mut(&4).ok_or(ExecError::InvalidMemorySize(4))?; if let Some(result) = __mq.get_mut(&__values[..]) { if !unconstrained { *result.multiplicity += G::ONE; } result.output[0] } else { let __ptr = G::from_usize(__mq.len()); __mq.insert(&__values[..], &[__ptr], G::from_bool(!unconstrained)); __ptr } }; + let __ret: [G; OUT_216] = [__v_18, __v_22]; + if let Some(result) = record.function_queries[216].get_mut(&inp[..]) { debug_assert_eq!(result.output, &__ret[..]); if !unconstrained { *result.multiplicity += G::ONE; } } else { record.function_queries[216].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained)); }; return Ok(__ret); }, _ => { @@ -20981,8 +20705,8 @@ fn aiur_fn_220( let __v_18: G = G::from_u64(0); let __v_19: G = G::from_u64(0); let __v_20: G = { let __values: [G; 4] = [__v_17, __v_18, __v_19, __v_19]; let __mq = record.memory_queries.get_mut(&4).ok_or(ExecError::InvalidMemorySize(4))?; if let Some(result) = __mq.get_mut(&__values[..]) { if !unconstrained { *result.multiplicity += G::ONE; } result.output[0] } else { let __ptr = G::from_usize(__mq.len()); __mq.insert(&__values[..], &[__ptr], G::from_bool(!unconstrained)); __ptr } }; - let __ret: [G; OUT_220] = [__v_16, __v_20]; - if let Some(result) = record.function_queries[220].get_mut(&inp[..]) { debug_assert_eq!(result.output, &__ret[..]); if !unconstrained { *result.multiplicity += G::ONE; } } else { record.function_queries[220].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained)); }; + let __ret: [G; OUT_216] = [__v_16, __v_20]; + if let Some(result) = record.function_queries[216].get_mut(&inp[..]) { debug_assert_eq!(result.output, &__ret[..]); if !unconstrained { *result.multiplicity += G::ONE; } } else { record.function_queries[216].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained)); }; return Ok(__ret); }, } @@ -20993,8 +20717,8 @@ fn aiur_fn_220( let __v_18: G = G::from_u64(0); let __v_19: G = G::from_u64(0); let __v_20: G = { let __values: [G; 4] = [__v_17, __v_18, __v_19, __v_19]; let __mq = record.memory_queries.get_mut(&4).ok_or(ExecError::InvalidMemorySize(4))?; if let Some(result) = __mq.get_mut(&__values[..]) { if !unconstrained { *result.multiplicity += G::ONE; } result.output[0] } else { let __ptr = G::from_usize(__mq.len()); __mq.insert(&__values[..], &[__ptr], G::from_bool(!unconstrained)); __ptr } }; - let __ret: [G; OUT_220] = [__v_16, __v_20]; - if let Some(result) = record.function_queries[220].get_mut(&inp[..]) { debug_assert_eq!(result.output, &__ret[..]); if !unconstrained { *result.multiplicity += G::ONE; } } else { record.function_queries[220].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained)); }; + let __ret: [G; OUT_216] = [__v_16, __v_20]; + if let Some(result) = record.function_queries[216].get_mut(&inp[..]) { debug_assert_eq!(result.output, &__ret[..]); if !unconstrained { *result.multiplicity += G::ONE; } } else { record.function_queries[216].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained)); }; return Ok(__ret); }, } @@ -21002,63 +20726,63 @@ fn aiur_fn_220( } }, _ => { - let __r_arr: [G; OUT_213] = { let __args: [G; IN_213] = []; let __cu = unconstrained; if let Some(result) = record.function_queries[213].get_mut(&__args[..]) { if !__cu && *result.multiplicity == G::ZERO { aiur_fn_213(__args, record, io_buffer, false)? } else { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_213] = unsafe { *(result.output.as_ptr() as *const [G; OUT_213]) }; __ret } } else { aiur_fn_213(__args, record, io_buffer, __cu)? } }; + let __r_arr: [G; OUT_209] = { let __args: [G; IN_209] = []; let __cu = unconstrained; if let Some(result) = record.function_queries[209].get_mut(&__args[..]) { if !__cu && *result.multiplicity == G::ZERO { aiur_fn_209(__args, record, io_buffer, false)? } else { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_209] = unsafe { *(result.output.as_ptr() as *const [G; OUT_209]) }; __ret } } else { aiur_fn_209(__args, record, io_buffer, __cu)? } }; let __v_8: G = __r_arr[0]; let __r_arr: [G; OUT_1] = { let __args: [G; IN_1] = [__v_0, __v_8]; let __cu = unconstrained; if let Some(result) = record.function_queries[1].get_mut(&__args[..]) { if !__cu && *result.multiplicity == G::ZERO { aiur_fn_1(__args, record, io_buffer, false)? } else { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_1] = unsafe { *(result.output.as_ptr() as *const [G; OUT_1]) }; __ret } } else { aiur_fn_1(__args, record, io_buffer, __cu)? } }; let __v_9: G = __r_arr[0]; match __v_9.as_canonical_u64() { 1u64 => { - let __r_arr: [G; OUT_221] = { let __args: [G; IN_221] = [__v_1]; let __cu = unconstrained; if let Some(result) = record.function_queries[221].get_mut(&__args[..]) { if !__cu && *result.multiplicity == G::ZERO { aiur_fn_221(__args, record, io_buffer, false)? } else { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_221] = unsafe { *(result.output.as_ptr() as *const [G; OUT_221]) }; __ret } } else { aiur_fn_221(__args, record, io_buffer, __cu)? } }; + let __r_arr: [G; OUT_217] = { let __args: [G; IN_217] = [__v_1]; let __cu = unconstrained; if let Some(result) = record.function_queries[217].get_mut(&__args[..]) { if !__cu && *result.multiplicity == G::ZERO { aiur_fn_217(__args, record, io_buffer, false)? } else { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_217] = unsafe { *(result.output.as_ptr() as *const [G; OUT_217]) }; __ret } } else { aiur_fn_217(__args, record, io_buffer, __cu)? } }; let __v_10: G = __r_arr[0]; let __v_11: G = __r_arr[1]; - let __ret: [G; OUT_220] = [__v_10, __v_11]; - if let Some(result) = record.function_queries[220].get_mut(&inp[..]) { debug_assert_eq!(result.output, &__ret[..]); if !unconstrained { *result.multiplicity += G::ONE; } } else { record.function_queries[220].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained)); }; + let __ret: [G; OUT_216] = [__v_10, __v_11]; + if let Some(result) = record.function_queries[216].get_mut(&inp[..]) { debug_assert_eq!(result.output, &__ret[..]); if !unconstrained { *result.multiplicity += G::ONE; } } else { record.function_queries[216].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained)); }; return Ok(__ret); }, _ => { - let __r_arr: [G; OUT_214] = { let __args: [G; IN_214] = []; let __cu = unconstrained; if let Some(result) = record.function_queries[214].get_mut(&__args[..]) { if !__cu && *result.multiplicity == G::ZERO { aiur_fn_214(__args, record, io_buffer, false)? } else { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_214] = unsafe { *(result.output.as_ptr() as *const [G; OUT_214]) }; __ret } } else { aiur_fn_214(__args, record, io_buffer, __cu)? } }; + let __r_arr: [G; OUT_210] = { let __args: [G; IN_210] = []; let __cu = unconstrained; if let Some(result) = record.function_queries[210].get_mut(&__args[..]) { if !__cu && *result.multiplicity == G::ZERO { aiur_fn_210(__args, record, io_buffer, false)? } else { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_210] = unsafe { *(result.output.as_ptr() as *const [G; OUT_210]) }; __ret } } else { aiur_fn_210(__args, record, io_buffer, __cu)? } }; let __v_10: G = __r_arr[0]; let __r_arr: [G; OUT_1] = { let __args: [G; IN_1] = [__v_0, __v_10]; let __cu = unconstrained; if let Some(result) = record.function_queries[1].get_mut(&__args[..]) { if !__cu && *result.multiplicity == G::ZERO { aiur_fn_1(__args, record, io_buffer, false)? } else { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_1] = unsafe { *(result.output.as_ptr() as *const [G; OUT_1]) }; __ret } } else { aiur_fn_1(__args, record, io_buffer, __cu)? } }; let __v_11: G = __r_arr[0]; match __v_11.as_canonical_u64() { 1u64 => { - let __r_arr: [G; OUT_221] = { let __args: [G; IN_221] = [__v_1]; let __cu = unconstrained; if let Some(result) = record.function_queries[221].get_mut(&__args[..]) { if !__cu && *result.multiplicity == G::ZERO { aiur_fn_221(__args, record, io_buffer, false)? } else { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_221] = unsafe { *(result.output.as_ptr() as *const [G; OUT_221]) }; __ret } } else { aiur_fn_221(__args, record, io_buffer, __cu)? } }; + let __r_arr: [G; OUT_217] = { let __args: [G; IN_217] = [__v_1]; let __cu = unconstrained; if let Some(result) = record.function_queries[217].get_mut(&__args[..]) { if !__cu && *result.multiplicity == G::ZERO { aiur_fn_217(__args, record, io_buffer, false)? } else { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_217] = unsafe { *(result.output.as_ptr() as *const [G; OUT_217]) }; __ret } } else { aiur_fn_217(__args, record, io_buffer, __cu)? } }; let __v_12: G = __r_arr[0]; let __v_13: G = __r_arr[1]; - let __ret: [G; OUT_220] = [__v_12, __v_13]; - if let Some(result) = record.function_queries[220].get_mut(&inp[..]) { debug_assert_eq!(result.output, &__ret[..]); if !unconstrained { *result.multiplicity += G::ONE; } } else { record.function_queries[220].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained)); }; + let __ret: [G; OUT_216] = [__v_12, __v_13]; + if let Some(result) = record.function_queries[216].get_mut(&inp[..]) { debug_assert_eq!(result.output, &__ret[..]); if !unconstrained { *result.multiplicity += G::ONE; } } else { record.function_queries[216].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained)); }; return Ok(__ret); }, _ => { - let __r_arr: [G; OUT_215] = { let __args: [G; IN_215] = []; let __cu = unconstrained; if let Some(result) = record.function_queries[215].get_mut(&__args[..]) { if !__cu && *result.multiplicity == G::ZERO { aiur_fn_215(__args, record, io_buffer, false)? } else { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_215] = unsafe { *(result.output.as_ptr() as *const [G; OUT_215]) }; __ret } } else { aiur_fn_215(__args, record, io_buffer, __cu)? } }; + let __r_arr: [G; OUT_211] = { let __args: [G; IN_211] = []; let __cu = unconstrained; if let Some(result) = record.function_queries[211].get_mut(&__args[..]) { if !__cu && *result.multiplicity == G::ZERO { aiur_fn_211(__args, record, io_buffer, false)? } else { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_211] = unsafe { *(result.output.as_ptr() as *const [G; OUT_211]) }; __ret } } else { aiur_fn_211(__args, record, io_buffer, __cu)? } }; let __v_12: G = __r_arr[0]; let __r_arr: [G; OUT_1] = { let __args: [G; IN_1] = [__v_0, __v_12]; let __cu = unconstrained; if let Some(result) = record.function_queries[1].get_mut(&__args[..]) { if !__cu && *result.multiplicity == G::ZERO { aiur_fn_1(__args, record, io_buffer, false)? } else { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_1] = unsafe { *(result.output.as_ptr() as *const [G; OUT_1]) }; __ret } } else { aiur_fn_1(__args, record, io_buffer, __cu)? } }; let __v_13: G = __r_arr[0]; match __v_13.as_canonical_u64() { 1u64 => { - let __r_arr: [G; OUT_222] = { let __args: [G; IN_222] = [__v_1]; let __cu = unconstrained; if let Some(result) = record.function_queries[222].get_mut(&__args[..]) { if !__cu && *result.multiplicity == G::ZERO { aiur_fn_222(__args, record, io_buffer, false)? } else { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_222] = unsafe { *(result.output.as_ptr() as *const [G; OUT_222]) }; __ret } } else { aiur_fn_222(__args, record, io_buffer, __cu)? } }; + let __r_arr: [G; OUT_218] = { let __args: [G; IN_218] = [__v_1]; let __cu = unconstrained; if let Some(result) = record.function_queries[218].get_mut(&__args[..]) { if !__cu && *result.multiplicity == G::ZERO { aiur_fn_218(__args, record, io_buffer, false)? } else { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_218] = unsafe { *(result.output.as_ptr() as *const [G; OUT_218]) }; __ret } } else { aiur_fn_218(__args, record, io_buffer, __cu)? } }; let __v_14: G = __r_arr[0]; let __v_15: G = __r_arr[1]; - let __ret: [G; OUT_220] = [__v_14, __v_15]; - if let Some(result) = record.function_queries[220].get_mut(&inp[..]) { debug_assert_eq!(result.output, &__ret[..]); if !unconstrained { *result.multiplicity += G::ONE; } } else { record.function_queries[220].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained)); }; + let __ret: [G; OUT_216] = [__v_14, __v_15]; + if let Some(result) = record.function_queries[216].get_mut(&inp[..]) { debug_assert_eq!(result.output, &__ret[..]); if !unconstrained { *result.multiplicity += G::ONE; } } else { record.function_queries[216].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained)); }; return Ok(__ret); }, _ => { - let __r_arr: [G; OUT_217] = { let __args: [G; IN_217] = []; let __cu = unconstrained; if let Some(result) = record.function_queries[217].get_mut(&__args[..]) { if !__cu && *result.multiplicity == G::ZERO { aiur_fn_217(__args, record, io_buffer, false)? } else { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_217] = unsafe { *(result.output.as_ptr() as *const [G; OUT_217]) }; __ret } } else { aiur_fn_217(__args, record, io_buffer, __cu)? } }; + let __r_arr: [G; OUT_213] = { let __args: [G; IN_213] = []; let __cu = unconstrained; if let Some(result) = record.function_queries[213].get_mut(&__args[..]) { if !__cu && *result.multiplicity == G::ZERO { aiur_fn_213(__args, record, io_buffer, false)? } else { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_213] = unsafe { *(result.output.as_ptr() as *const [G; OUT_213]) }; __ret } } else { aiur_fn_213(__args, record, io_buffer, __cu)? } }; let __v_14: G = __r_arr[0]; let __r_arr: [G; OUT_1] = { let __args: [G; IN_1] = [__v_0, __v_14]; let __cu = unconstrained; if let Some(result) = record.function_queries[1].get_mut(&__args[..]) { if !__cu && *result.multiplicity == G::ZERO { aiur_fn_1(__args, record, io_buffer, false)? } else { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_1] = unsafe { *(result.output.as_ptr() as *const [G; OUT_1]) }; __ret } } else { aiur_fn_1(__args, record, io_buffer, __cu)? } }; let __v_15: G = __r_arr[0]; match __v_15.as_canonical_u64() { 1u64 => { - let __r_arr: [G; OUT_525] = { let __args: [G; IN_525] = [__v_0, __v_1, __v_2]; let __cu = unconstrained; if let Some(result) = record.function_queries[525].get_mut(&__args[..]) { if !__cu && *result.multiplicity == G::ZERO { aiur_fn_525(__args, record, io_buffer, false)? } else { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_525] = unsafe { *(result.output.as_ptr() as *const [G; OUT_525]) }; __ret } } else { aiur_fn_525(__args, record, io_buffer, __cu)? } }; + let __r_arr: [G; OUT_521] = { let __args: [G; IN_521] = [__v_0, __v_1, __v_2]; let __cu = unconstrained; if let Some(result) = record.function_queries[521].get_mut(&__args[..]) { if !__cu && *result.multiplicity == G::ZERO { aiur_fn_521(__args, record, io_buffer, false)? } else { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_521] = unsafe { *(result.output.as_ptr() as *const [G; OUT_521]) }; __ret } } else { aiur_fn_521(__args, record, io_buffer, __cu)? } }; let __v_16: G = __r_arr[0]; let __v_17: G = __r_arr[1]; - let __ret: [G; OUT_220] = [__v_16, __v_17]; - if let Some(result) = record.function_queries[220].get_mut(&inp[..]) { debug_assert_eq!(result.output, &__ret[..]); if !unconstrained { *result.multiplicity += G::ONE; } } else { record.function_queries[220].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained)); }; + let __ret: [G; OUT_216] = [__v_16, __v_17]; + if let Some(result) = record.function_queries[216].get_mut(&inp[..]) { debug_assert_eq!(result.output, &__ret[..]); if !unconstrained { *result.multiplicity += G::ONE; } } else { record.function_queries[216].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained)); }; return Ok(__ret); }, _ => { - let __r_arr: [G; OUT_207] = { let __args: [G; IN_207] = []; let __cu = unconstrained; if let Some(result) = record.function_queries[207].get_mut(&__args[..]) { if !__cu && *result.multiplicity == G::ZERO { aiur_fn_207(__args, record, io_buffer, false)? } else { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_207] = unsafe { *(result.output.as_ptr() as *const [G; OUT_207]) }; __ret } } else { aiur_fn_207(__args, record, io_buffer, __cu)? } }; + let __r_arr: [G; OUT_203] = { let __args: [G; IN_203] = []; let __cu = unconstrained; if let Some(result) = record.function_queries[203].get_mut(&__args[..]) { if !__cu && *result.multiplicity == G::ZERO { aiur_fn_203(__args, record, io_buffer, false)? } else { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_203] = unsafe { *(result.output.as_ptr() as *const [G; OUT_203]) }; __ret } } else { aiur_fn_203(__args, record, io_buffer, __cu)? } }; let __v_16: G = __r_arr[0]; let __r_arr: [G; OUT_1] = { let __args: [G; IN_1] = [__v_0, __v_16]; let __cu = unconstrained; if let Some(result) = record.function_queries[1].get_mut(&__args[..]) { if !__cu && *result.multiplicity == G::ZERO { aiur_fn_1(__args, record, io_buffer, false)? } else { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_1] = unsafe { *(result.output.as_ptr() as *const [G; OUT_1]) }; __ret } } else { aiur_fn_1(__args, record, io_buffer, __cu)? } }; let __v_17: G = __r_arr[0]; @@ -21073,16 +20797,16 @@ fn aiur_fn_220( let __v_22: G = G::from_u64(0); let __v_23: G = G::from_u64(0); let __v_24: G = { let __values: [G; 4] = [__v_21, __v_22, __v_23, __v_23]; let __mq = record.memory_queries.get_mut(&4).ok_or(ExecError::InvalidMemorySize(4))?; if let Some(result) = __mq.get_mut(&__values[..]) { if !unconstrained { *result.multiplicity += G::ONE; } result.output[0] } else { let __ptr = G::from_usize(__mq.len()); __mq.insert(&__values[..], &[__ptr], G::from_bool(!unconstrained)); __ptr } }; - let __ret: [G; OUT_220] = [__v_20, __v_24]; - if let Some(result) = record.function_queries[220].get_mut(&inp[..]) { debug_assert_eq!(result.output, &__ret[..]); if !unconstrained { *result.multiplicity += G::ONE; } } else { record.function_queries[220].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained)); }; + let __ret: [G; OUT_216] = [__v_20, __v_24]; + if let Some(result) = record.function_queries[216].get_mut(&inp[..]) { debug_assert_eq!(result.output, &__ret[..]); if !unconstrained { *result.multiplicity += G::ONE; } } else { record.function_queries[216].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained)); }; return Ok(__ret); }, _ => { let __v_20: G = G::from_u64(0); - let __r_arr: [G; OUT_766] = { let __args: [G; IN_766] = [__v_1, __v_20]; let __cu = unconstrained; if let Some(result) = record.function_queries[766].get_mut(&__args[..]) { if !__cu && *result.multiplicity == G::ZERO { aiur_fn_766(__args, record, io_buffer, false)? } else { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_766] = unsafe { *(result.output.as_ptr() as *const [G; OUT_766]) }; __ret } } else { aiur_fn_766(__args, record, io_buffer, __cu)? } }; + let __r_arr: [G; OUT_762] = { let __args: [G; IN_762] = [__v_1, __v_20]; let __cu = unconstrained; if let Some(result) = record.function_queries[762].get_mut(&__args[..]) { if !__cu && *result.multiplicity == G::ZERO { aiur_fn_762(__args, record, io_buffer, false)? } else { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_762] = unsafe { *(result.output.as_ptr() as *const [G; OUT_762]) }; __ret } } else { aiur_fn_762(__args, record, io_buffer, __cu)? } }; let __v_21: G = __r_arr[0]; let __v_22: G = G::from_u64(1); - let __r_arr: [G; OUT_766] = { let __args: [G; IN_766] = [__v_1, __v_22]; let __cu = unconstrained; if let Some(result) = record.function_queries[766].get_mut(&__args[..]) { if !__cu && *result.multiplicity == G::ZERO { aiur_fn_766(__args, record, io_buffer, false)? } else { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_766] = unsafe { *(result.output.as_ptr() as *const [G; OUT_766]) }; __ret } } else { aiur_fn_766(__args, record, io_buffer, __cu)? } }; + let __r_arr: [G; OUT_762] = { let __args: [G; IN_762] = [__v_1, __v_22]; let __cu = unconstrained; if let Some(result) = record.function_queries[762].get_mut(&__args[..]) { if !__cu && *result.multiplicity == G::ZERO { aiur_fn_762(__args, record, io_buffer, false)? } else { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_762] = unsafe { *(result.output.as_ptr() as *const [G; OUT_762]) }; __ret } } else { aiur_fn_762(__args, record, io_buffer, __cu)? } }; let __v_23: G = __r_arr[0]; let __loaded: [G; 4] = { let __mq = record.memory_queries.get_mut(&4).ok_or(ExecError::InvalidMemorySize(4))?; let __ptr_u64 = __v_21.as_canonical_u64(); let __ptr_usize = usize::try_from(__ptr_u64).ok().ok_or(ExecError::PointerTooLarge(__ptr_u64))?; let (__args, __mult) = __mq.get_index_mut(__ptr_usize).ok_or(ExecError::UnboundPointer { ptr: __ptr_u64, size: 4 })?; if !unconstrained { *__mult += G::ONE; } let __arr: [G; 4] = __args[..4].try_into().unwrap(); __arr }; let __v_24: G = __loaded[0]; @@ -21102,15 +20826,15 @@ fn aiur_fn_220( 7u64 => { match __v_29.as_canonical_u64() { 1u64 => { - let __r_arr: [G; OUT_763] = { let __args: [G; IN_763] = [__v_26, __v_30]; let __cu = unconstrained; if let Some(result) = record.function_queries[763].get_mut(&__args[..]) { if !__cu && *result.multiplicity == G::ZERO { aiur_fn_763(__args, record, io_buffer, false)? } else { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_763] = unsafe { *(result.output.as_ptr() as *const [G; OUT_763]) }; __ret } } else { aiur_fn_763(__args, record, io_buffer, __cu)? } }; + let __r_arr: [G; OUT_759] = { let __args: [G; IN_759] = [__v_26, __v_30]; let __cu = unconstrained; if let Some(result) = record.function_queries[759].get_mut(&__args[..]) { if !__cu && *result.multiplicity == G::ZERO { aiur_fn_759(__args, record, io_buffer, false)? } else { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_759] = unsafe { *(result.output.as_ptr() as *const [G; OUT_759]) }; __ret } } else { aiur_fn_759(__args, record, io_buffer, __cu)? } }; let __v_32: G = __r_arr[0]; let __v_33: G = G::from_u64(1); let __v_34: G = G::from_u64(7); let __v_35: G = G::from_u64(1); let __v_36: G = G::from_u64(0); let __v_37: G = { let __values: [G; 4] = [__v_34, __v_35, __v_32, __v_36]; let __mq = record.memory_queries.get_mut(&4).ok_or(ExecError::InvalidMemorySize(4))?; if let Some(result) = __mq.get_mut(&__values[..]) { if !unconstrained { *result.multiplicity += G::ONE; } result.output[0] } else { let __ptr = G::from_usize(__mq.len()); __mq.insert(&__values[..], &[__ptr], G::from_bool(!unconstrained)); __ptr } }; - let __ret: [G; OUT_220] = [__v_33, __v_37]; - if let Some(result) = record.function_queries[220].get_mut(&inp[..]) { debug_assert_eq!(result.output, &__ret[..]); if !unconstrained { *result.multiplicity += G::ONE; } } else { record.function_queries[220].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained)); }; + let __ret: [G; OUT_216] = [__v_33, __v_37]; + if let Some(result) = record.function_queries[216].get_mut(&inp[..]) { debug_assert_eq!(result.output, &__ret[..]); if !unconstrained { *result.multiplicity += G::ONE; } } else { record.function_queries[216].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained)); }; return Ok(__ret); }, _ => { @@ -21119,8 +20843,8 @@ fn aiur_fn_220( let __v_34: G = G::from_u64(0); let __v_35: G = G::from_u64(0); let __v_36: G = { let __values: [G; 4] = [__v_33, __v_34, __v_35, __v_35]; let __mq = record.memory_queries.get_mut(&4).ok_or(ExecError::InvalidMemorySize(4))?; if let Some(result) = __mq.get_mut(&__values[..]) { if !unconstrained { *result.multiplicity += G::ONE; } result.output[0] } else { let __ptr = G::from_usize(__mq.len()); __mq.insert(&__values[..], &[__ptr], G::from_bool(!unconstrained)); __ptr } }; - let __ret: [G; OUT_220] = [__v_32, __v_36]; - if let Some(result) = record.function_queries[220].get_mut(&inp[..]) { debug_assert_eq!(result.output, &__ret[..]); if !unconstrained { *result.multiplicity += G::ONE; } } else { record.function_queries[220].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained)); }; + let __ret: [G; OUT_216] = [__v_32, __v_36]; + if let Some(result) = record.function_queries[216].get_mut(&inp[..]) { debug_assert_eq!(result.output, &__ret[..]); if !unconstrained { *result.multiplicity += G::ONE; } } else { record.function_queries[216].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained)); }; return Ok(__ret); }, } @@ -21131,8 +20855,8 @@ fn aiur_fn_220( let __v_34: G = G::from_u64(0); let __v_35: G = G::from_u64(0); let __v_36: G = { let __values: [G; 4] = [__v_33, __v_34, __v_35, __v_35]; let __mq = record.memory_queries.get_mut(&4).ok_or(ExecError::InvalidMemorySize(4))?; if let Some(result) = __mq.get_mut(&__values[..]) { if !unconstrained { *result.multiplicity += G::ONE; } result.output[0] } else { let __ptr = G::from_usize(__mq.len()); __mq.insert(&__values[..], &[__ptr], G::from_bool(!unconstrained)); __ptr } }; - let __ret: [G; OUT_220] = [__v_32, __v_36]; - if let Some(result) = record.function_queries[220].get_mut(&inp[..]) { debug_assert_eq!(result.output, &__ret[..]); if !unconstrained { *result.multiplicity += G::ONE; } } else { record.function_queries[220].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained)); }; + let __ret: [G; OUT_216] = [__v_32, __v_36]; + if let Some(result) = record.function_queries[216].get_mut(&inp[..]) { debug_assert_eq!(result.output, &__ret[..]); if !unconstrained { *result.multiplicity += G::ONE; } } else { record.function_queries[216].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained)); }; return Ok(__ret); }, } @@ -21143,8 +20867,8 @@ fn aiur_fn_220( let __v_30: G = G::from_u64(0); let __v_31: G = G::from_u64(0); let __v_32: G = { let __values: [G; 4] = [__v_29, __v_30, __v_31, __v_31]; let __mq = record.memory_queries.get_mut(&4).ok_or(ExecError::InvalidMemorySize(4))?; if let Some(result) = __mq.get_mut(&__values[..]) { if !unconstrained { *result.multiplicity += G::ONE; } result.output[0] } else { let __ptr = G::from_usize(__mq.len()); __mq.insert(&__values[..], &[__ptr], G::from_bool(!unconstrained)); __ptr } }; - let __ret: [G; OUT_220] = [__v_28, __v_32]; - if let Some(result) = record.function_queries[220].get_mut(&inp[..]) { debug_assert_eq!(result.output, &__ret[..]); if !unconstrained { *result.multiplicity += G::ONE; } } else { record.function_queries[220].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained)); }; + let __ret: [G; OUT_216] = [__v_28, __v_32]; + if let Some(result) = record.function_queries[216].get_mut(&inp[..]) { debug_assert_eq!(result.output, &__ret[..]); if !unconstrained { *result.multiplicity += G::ONE; } } else { record.function_queries[216].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained)); }; return Ok(__ret); }, } @@ -21155,8 +20879,8 @@ fn aiur_fn_220( let __v_30: G = G::from_u64(0); let __v_31: G = G::from_u64(0); let __v_32: G = { let __values: [G; 4] = [__v_29, __v_30, __v_31, __v_31]; let __mq = record.memory_queries.get_mut(&4).ok_or(ExecError::InvalidMemorySize(4))?; if let Some(result) = __mq.get_mut(&__values[..]) { if !unconstrained { *result.multiplicity += G::ONE; } result.output[0] } else { let __ptr = G::from_usize(__mq.len()); __mq.insert(&__values[..], &[__ptr], G::from_bool(!unconstrained)); __ptr } }; - let __ret: [G; OUT_220] = [__v_28, __v_32]; - if let Some(result) = record.function_queries[220].get_mut(&inp[..]) { debug_assert_eq!(result.output, &__ret[..]); if !unconstrained { *result.multiplicity += G::ONE; } } else { record.function_queries[220].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained)); }; + let __ret: [G; OUT_216] = [__v_28, __v_32]; + if let Some(result) = record.function_queries[216].get_mut(&inp[..]) { debug_assert_eq!(result.output, &__ret[..]); if !unconstrained { *result.multiplicity += G::ONE; } } else { record.function_queries[216].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained)); }; return Ok(__ret); }, } @@ -21169,8 +20893,8 @@ fn aiur_fn_220( let __v_20: G = G::from_u64(0); let __v_21: G = G::from_u64(0); let __v_22: G = { let __values: [G; 4] = [__v_19, __v_20, __v_21, __v_21]; let __mq = record.memory_queries.get_mut(&4).ok_or(ExecError::InvalidMemorySize(4))?; if let Some(result) = __mq.get_mut(&__values[..]) { if !unconstrained { *result.multiplicity += G::ONE; } result.output[0] } else { let __ptr = G::from_usize(__mq.len()); __mq.insert(&__values[..], &[__ptr], G::from_bool(!unconstrained)); __ptr } }; - let __ret: [G; OUT_220] = [__v_18, __v_22]; - if let Some(result) = record.function_queries[220].get_mut(&inp[..]) { debug_assert_eq!(result.output, &__ret[..]); if !unconstrained { *result.multiplicity += G::ONE; } } else { record.function_queries[220].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained)); }; + let __ret: [G; OUT_216] = [__v_18, __v_22]; + if let Some(result) = record.function_queries[216].get_mut(&inp[..]) { debug_assert_eq!(result.output, &__ret[..]); if !unconstrained { *result.multiplicity += G::ONE; } } else { record.function_queries[216].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained)); }; return Ok(__ret); }, } @@ -21189,18 +20913,18 @@ fn aiur_fn_220( }) } -const INPUT_SIZE_221: usize = 1; -const IN_221: usize = 1; -const OUT_221: usize = 2; -fn aiur_fn_221( - inp: [G; IN_221], +const INPUT_SIZE_217: usize = 1; +const IN_217: usize = 1; +const OUT_217: usize = 2; +fn aiur_fn_217( + inp: [G; IN_217], record: &mut QueryRecord, io_buffer: &mut IOBuffer, unconstrained: bool, -) -> Result<[G; OUT_221], ExecError> { +) -> Result<[G; OUT_217], ExecError> { stacker::maybe_grow(64 * 1024, 4 * 1024 * 1024, || { let __v_0: G = inp[0]; - let __r_arr: [G; OUT_764] = { let __args: [G; IN_764] = [__v_0]; let __cu = unconstrained; if let Some(result) = record.function_queries[764].get_mut(&__args[..]) { if !__cu && *result.multiplicity == G::ZERO { aiur_fn_764(__args, record, io_buffer, false)? } else { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_764] = unsafe { *(result.output.as_ptr() as *const [G; OUT_764]) }; __ret } } else { aiur_fn_764(__args, record, io_buffer, __cu)? } }; + let __r_arr: [G; OUT_760] = { let __args: [G; IN_760] = [__v_0]; let __cu = unconstrained; if let Some(result) = record.function_queries[760].get_mut(&__args[..]) { if !__cu && *result.multiplicity == G::ZERO { aiur_fn_760(__args, record, io_buffer, false)? } else { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_760] = unsafe { *(result.output.as_ptr() as *const [G; OUT_760]) }; __ret } } else { aiur_fn_760(__args, record, io_buffer, __cu)? } }; let __v_1: G = __r_arr[0]; let __v_2: G = G::from_u64(1); let __v_3: G = { let __a_val = __v_1.as_canonical_u64(); let __b_val = __v_2.as_canonical_u64(); let __a_u32 = u32::try_from(__a_val).ok().ok_or(ExecError::U32OutOfRange(__a_val))?; let __b_u32 = u32::try_from(__b_val).ok().ok_or(ExecError::U32OutOfRange(__b_val))?; let __result = G::from_bool(__a_u32 < __b_u32); if !unconstrained { let __x_bytes = __a_u32.to_le_bytes(); let __z_bytes = __b_u32.to_le_bytes(); let __c_u32 = __b_u32.wrapping_sub(__a_u32).wrapping_sub(1); let __y_bytes = __c_u32.to_le_bytes(); record.bytes2_queries.bump_range_check(&G::from_u8(__x_bytes[0]), &G::from_u8(__x_bytes[1])); record.bytes2_queries.bump_range_check(&G::from_u8(__x_bytes[2]), &G::from_u8(__x_bytes[3])); record.bytes2_queries.bump_range_check(&G::from_u8(__y_bytes[0]), &G::from_u8(__y_bytes[1])); record.bytes2_queries.bump_range_check(&G::from_u8(__y_bytes[2]), &G::from_u8(__y_bytes[3])); record.bytes2_queries.bump_range_check(&G::from_u8(__z_bytes[0]), &G::from_u8(__z_bytes[1])); record.bytes2_queries.bump_range_check(&G::from_u8(__z_bytes[2]), &G::from_u8(__z_bytes[3])); } __result }; @@ -21211,13 +20935,13 @@ fn aiur_fn_221( let __v_6: G = G::from_u64(0); let __v_7: G = G::from_u64(0); let __v_8: G = { let __values: [G; 4] = [__v_5, __v_6, __v_7, __v_7]; let __mq = record.memory_queries.get_mut(&4).ok_or(ExecError::InvalidMemorySize(4))?; if let Some(result) = __mq.get_mut(&__values[..]) { if !unconstrained { *result.multiplicity += G::ONE; } result.output[0] } else { let __ptr = G::from_usize(__mq.len()); __mq.insert(&__values[..], &[__ptr], G::from_bool(!unconstrained)); __ptr } }; - let __ret: [G; OUT_221] = [__v_4, __v_8]; - if let Some(result) = record.function_queries[221].get_mut(&inp[..]) { debug_assert_eq!(result.output, &__ret[..]); if !unconstrained { *result.multiplicity += G::ONE; } } else { record.function_queries[221].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained)); }; + let __ret: [G; OUT_217] = [__v_4, __v_8]; + if let Some(result) = record.function_queries[217].get_mut(&inp[..]) { debug_assert_eq!(result.output, &__ret[..]); if !unconstrained { *result.multiplicity += G::ONE; } } else { record.function_queries[217].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained)); }; return Ok(__ret); }, _ => { let __v_4: G = G::from_u64(0); - let __r_arr: [G; OUT_766] = { let __args: [G; IN_766] = [__v_0, __v_4]; let __cu = unconstrained; if let Some(result) = record.function_queries[766].get_mut(&__args[..]) { if !__cu && *result.multiplicity == G::ZERO { aiur_fn_766(__args, record, io_buffer, false)? } else { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_766] = unsafe { *(result.output.as_ptr() as *const [G; OUT_766]) }; __ret } } else { aiur_fn_766(__args, record, io_buffer, __cu)? } }; + let __r_arr: [G; OUT_762] = { let __args: [G; IN_762] = [__v_0, __v_4]; let __cu = unconstrained; if let Some(result) = record.function_queries[762].get_mut(&__args[..]) { if !__cu && *result.multiplicity == G::ZERO { aiur_fn_762(__args, record, io_buffer, false)? } else { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_762] = unsafe { *(result.output.as_ptr() as *const [G; OUT_762]) }; __ret } } else { aiur_fn_762(__args, record, io_buffer, __cu)? } }; let __v_5: G = __r_arr[0]; let __loaded: [G; 4] = { let __mq = record.memory_queries.get_mut(&4).ok_or(ExecError::InvalidMemorySize(4))?; let __ptr_u64 = __v_5.as_canonical_u64(); let __ptr_usize = usize::try_from(__ptr_u64).ok().ok_or(ExecError::PointerTooLarge(__ptr_u64))?; let (__args, __mult) = __mq.get_index_mut(__ptr_usize).ok_or(ExecError::UnboundPointer { ptr: __ptr_u64, size: 4 })?; if !unconstrained { *__mult += G::ONE; } let __arr: [G; 4] = __args[..4].try_into().unwrap(); __arr }; let __v_6: G = __loaded[0]; @@ -21228,16 +20952,16 @@ fn aiur_fn_221( 7u64 => { match __v_7.as_canonical_u64() { 1u64 => { - let __r_arr: [G; OUT_224] = { let __args: [G; IN_224] = [__v_8]; let __cu = unconstrained; if let Some(result) = record.function_queries[224].get_mut(&__args[..]) { if !__cu && *result.multiplicity == G::ZERO { aiur_fn_224(__args, record, io_buffer, false)? } else { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_224] = unsafe { *(result.output.as_ptr() as *const [G; OUT_224]) }; __ret } } else { aiur_fn_224(__args, record, io_buffer, __cu)? } }; + let __r_arr: [G; OUT_220] = { let __args: [G; IN_220] = [__v_8]; let __cu = unconstrained; if let Some(result) = record.function_queries[220].get_mut(&__args[..]) { if !__cu && *result.multiplicity == G::ZERO { aiur_fn_220(__args, record, io_buffer, false)? } else { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_220] = unsafe { *(result.output.as_ptr() as *const [G; OUT_220]) }; __ret } } else { aiur_fn_220(__args, record, io_buffer, __cu)? } }; let __v_10: G = __r_arr[0]; - let __r_arr: [G; OUT_233] = { let __args: [G; IN_233] = [__v_10]; let __cu = unconstrained; if let Some(result) = record.function_queries[233].get_mut(&__args[..]) { if !__cu && *result.multiplicity == G::ZERO { aiur_fn_233(__args, record, io_buffer, false)? } else { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_233] = unsafe { *(result.output.as_ptr() as *const [G; OUT_233]) }; __ret } } else { aiur_fn_233(__args, record, io_buffer, __cu)? } }; + let __r_arr: [G; OUT_229] = { let __args: [G; IN_229] = [__v_10]; let __cu = unconstrained; if let Some(result) = record.function_queries[229].get_mut(&__args[..]) { if !__cu && *result.multiplicity == G::ZERO { aiur_fn_229(__args, record, io_buffer, false)? } else { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_229] = unsafe { *(result.output.as_ptr() as *const [G; OUT_229]) }; __ret } } else { aiur_fn_229(__args, record, io_buffer, __cu)? } }; let __v_11: G = __r_arr[0]; let __v_12: G = G::from_u64(7); let __v_13: G = G::from_u64(0); let __v_14: G = G::from_u64(0); let __v_15: G = { let __values: [G; 4] = [__v_12, __v_13, __v_11, __v_14]; let __mq = record.memory_queries.get_mut(&4).ok_or(ExecError::InvalidMemorySize(4))?; if let Some(result) = __mq.get_mut(&__values[..]) { if !unconstrained { *result.multiplicity += G::ONE; } result.output[0] } else { let __ptr = G::from_usize(__mq.len()); __mq.insert(&__values[..], &[__ptr], G::from_bool(!unconstrained)); __ptr } }; let __v_16: G = G::from_u64(2); - let __r_arr: [G; OUT_209] = { let __args: [G; IN_209] = []; let __cu = unconstrained; if let Some(result) = record.function_queries[209].get_mut(&__args[..]) { if !__cu && *result.multiplicity == G::ZERO { aiur_fn_209(__args, record, io_buffer, false)? } else { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_209] = unsafe { *(result.output.as_ptr() as *const [G; OUT_209]) }; __ret } } else { aiur_fn_209(__args, record, io_buffer, __cu)? } }; + let __r_arr: [G; OUT_205] = { let __args: [G; IN_205] = []; let __cu = unconstrained; if let Some(result) = record.function_queries[205].get_mut(&__args[..]) { if !__cu && *result.multiplicity == G::ZERO { aiur_fn_205(__args, record, io_buffer, false)? } else { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_205] = unsafe { *(result.output.as_ptr() as *const [G; OUT_205]) }; __ret } } else { aiur_fn_205(__args, record, io_buffer, __cu)? } }; let __v_17: G = __r_arr[0]; let __v_18: G = G::from_u64(1); let __v_19: G = G::from_u64(1); @@ -21248,8 +20972,8 @@ fn aiur_fn_221( let __v_24: G = G::from_u64(3); let __v_25: G = G::from_u64(0); let __v_26: G = { let __values: [G; 4] = [__v_24, __v_22, __v_15, __v_25]; let __mq = record.memory_queries.get_mut(&4).ok_or(ExecError::InvalidMemorySize(4))?; if let Some(result) = __mq.get_mut(&__values[..]) { if !unconstrained { *result.multiplicity += G::ONE; } result.output[0] } else { let __ptr = G::from_usize(__mq.len()); __mq.insert(&__values[..], &[__ptr], G::from_bool(!unconstrained)); __ptr } }; - let __ret: [G; OUT_221] = [__v_23, __v_26]; - if let Some(result) = record.function_queries[221].get_mut(&inp[..]) { debug_assert_eq!(result.output, &__ret[..]); if !unconstrained { *result.multiplicity += G::ONE; } } else { record.function_queries[221].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained)); }; + let __ret: [G; OUT_217] = [__v_23, __v_26]; + if let Some(result) = record.function_queries[217].get_mut(&inp[..]) { debug_assert_eq!(result.output, &__ret[..]); if !unconstrained { *result.multiplicity += G::ONE; } } else { record.function_queries[217].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained)); }; return Ok(__ret); }, _ => { @@ -21258,8 +20982,8 @@ fn aiur_fn_221( let __v_12: G = G::from_u64(0); let __v_13: G = G::from_u64(0); let __v_14: G = { let __values: [G; 4] = [__v_11, __v_12, __v_13, __v_13]; let __mq = record.memory_queries.get_mut(&4).ok_or(ExecError::InvalidMemorySize(4))?; if let Some(result) = __mq.get_mut(&__values[..]) { if !unconstrained { *result.multiplicity += G::ONE; } result.output[0] } else { let __ptr = G::from_usize(__mq.len()); __mq.insert(&__values[..], &[__ptr], G::from_bool(!unconstrained)); __ptr } }; - let __ret: [G; OUT_221] = [__v_10, __v_14]; - if let Some(result) = record.function_queries[221].get_mut(&inp[..]) { debug_assert_eq!(result.output, &__ret[..]); if !unconstrained { *result.multiplicity += G::ONE; } } else { record.function_queries[221].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained)); }; + let __ret: [G; OUT_217] = [__v_10, __v_14]; + if let Some(result) = record.function_queries[217].get_mut(&inp[..]) { debug_assert_eq!(result.output, &__ret[..]); if !unconstrained { *result.multiplicity += G::ONE; } } else { record.function_queries[217].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained)); }; return Ok(__ret); }, } @@ -21270,8 +20994,8 @@ fn aiur_fn_221( let __v_12: G = G::from_u64(0); let __v_13: G = G::from_u64(0); let __v_14: G = { let __values: [G; 4] = [__v_11, __v_12, __v_13, __v_13]; let __mq = record.memory_queries.get_mut(&4).ok_or(ExecError::InvalidMemorySize(4))?; if let Some(result) = __mq.get_mut(&__values[..]) { if !unconstrained { *result.multiplicity += G::ONE; } result.output[0] } else { let __ptr = G::from_usize(__mq.len()); __mq.insert(&__values[..], &[__ptr], G::from_bool(!unconstrained)); __ptr } }; - let __ret: [G; OUT_221] = [__v_10, __v_14]; - if let Some(result) = record.function_queries[221].get_mut(&inp[..]) { debug_assert_eq!(result.output, &__ret[..]); if !unconstrained { *result.multiplicity += G::ONE; } } else { record.function_queries[221].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained)); }; + let __ret: [G; OUT_217] = [__v_10, __v_14]; + if let Some(result) = record.function_queries[217].get_mut(&inp[..]) { debug_assert_eq!(result.output, &__ret[..]); if !unconstrained { *result.multiplicity += G::ONE; } } else { record.function_queries[217].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained)); }; return Ok(__ret); }, } @@ -21280,18 +21004,18 @@ fn aiur_fn_221( }) } -const INPUT_SIZE_222: usize = 1; -const IN_222: usize = 1; -const OUT_222: usize = 2; -fn aiur_fn_222( - inp: [G; IN_222], +const INPUT_SIZE_218: usize = 1; +const IN_218: usize = 1; +const OUT_218: usize = 2; +fn aiur_fn_218( + inp: [G; IN_218], record: &mut QueryRecord, io_buffer: &mut IOBuffer, unconstrained: bool, -) -> Result<[G; OUT_222], ExecError> { +) -> Result<[G; OUT_218], ExecError> { stacker::maybe_grow(64 * 1024, 4 * 1024 * 1024, || { let __v_0: G = inp[0]; - let __r_arr: [G; OUT_764] = { let __args: [G; IN_764] = [__v_0]; let __cu = unconstrained; if let Some(result) = record.function_queries[764].get_mut(&__args[..]) { if !__cu && *result.multiplicity == G::ZERO { aiur_fn_764(__args, record, io_buffer, false)? } else { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_764] = unsafe { *(result.output.as_ptr() as *const [G; OUT_764]) }; __ret } } else { aiur_fn_764(__args, record, io_buffer, __cu)? } }; + let __r_arr: [G; OUT_760] = { let __args: [G; IN_760] = [__v_0]; let __cu = unconstrained; if let Some(result) = record.function_queries[760].get_mut(&__args[..]) { if !__cu && *result.multiplicity == G::ZERO { aiur_fn_760(__args, record, io_buffer, false)? } else { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_760] = unsafe { *(result.output.as_ptr() as *const [G; OUT_760]) }; __ret } } else { aiur_fn_760(__args, record, io_buffer, __cu)? } }; let __v_1: G = __r_arr[0]; let __v_2: G = G::from_u64(1); let __v_3: G = { let __a_val = __v_1.as_canonical_u64(); let __b_val = __v_2.as_canonical_u64(); let __a_u32 = u32::try_from(__a_val).ok().ok_or(ExecError::U32OutOfRange(__a_val))?; let __b_u32 = u32::try_from(__b_val).ok().ok_or(ExecError::U32OutOfRange(__b_val))?; let __result = G::from_bool(__a_u32 < __b_u32); if !unconstrained { let __x_bytes = __a_u32.to_le_bytes(); let __z_bytes = __b_u32.to_le_bytes(); let __c_u32 = __b_u32.wrapping_sub(__a_u32).wrapping_sub(1); let __y_bytes = __c_u32.to_le_bytes(); record.bytes2_queries.bump_range_check(&G::from_u8(__x_bytes[0]), &G::from_u8(__x_bytes[1])); record.bytes2_queries.bump_range_check(&G::from_u8(__x_bytes[2]), &G::from_u8(__x_bytes[3])); record.bytes2_queries.bump_range_check(&G::from_u8(__y_bytes[0]), &G::from_u8(__y_bytes[1])); record.bytes2_queries.bump_range_check(&G::from_u8(__y_bytes[2]), &G::from_u8(__y_bytes[3])); record.bytes2_queries.bump_range_check(&G::from_u8(__z_bytes[0]), &G::from_u8(__z_bytes[1])); record.bytes2_queries.bump_range_check(&G::from_u8(__z_bytes[2]), &G::from_u8(__z_bytes[3])); } __result }; @@ -21302,13 +21026,13 @@ fn aiur_fn_222( let __v_6: G = G::from_u64(0); let __v_7: G = G::from_u64(0); let __v_8: G = { let __values: [G; 4] = [__v_5, __v_6, __v_7, __v_7]; let __mq = record.memory_queries.get_mut(&4).ok_or(ExecError::InvalidMemorySize(4))?; if let Some(result) = __mq.get_mut(&__values[..]) { if !unconstrained { *result.multiplicity += G::ONE; } result.output[0] } else { let __ptr = G::from_usize(__mq.len()); __mq.insert(&__values[..], &[__ptr], G::from_bool(!unconstrained)); __ptr } }; - let __ret: [G; OUT_222] = [__v_4, __v_8]; - if let Some(result) = record.function_queries[222].get_mut(&inp[..]) { debug_assert_eq!(result.output, &__ret[..]); if !unconstrained { *result.multiplicity += G::ONE; } } else { record.function_queries[222].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained)); }; + let __ret: [G; OUT_218] = [__v_4, __v_8]; + if let Some(result) = record.function_queries[218].get_mut(&inp[..]) { debug_assert_eq!(result.output, &__ret[..]); if !unconstrained { *result.multiplicity += G::ONE; } } else { record.function_queries[218].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained)); }; return Ok(__ret); }, _ => { let __v_4: G = G::from_u64(0); - let __r_arr: [G; OUT_766] = { let __args: [G; IN_766] = [__v_0, __v_4]; let __cu = unconstrained; if let Some(result) = record.function_queries[766].get_mut(&__args[..]) { if !__cu && *result.multiplicity == G::ZERO { aiur_fn_766(__args, record, io_buffer, false)? } else { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_766] = unsafe { *(result.output.as_ptr() as *const [G; OUT_766]) }; __ret } } else { aiur_fn_766(__args, record, io_buffer, __cu)? } }; + let __r_arr: [G; OUT_762] = { let __args: [G; IN_762] = [__v_0, __v_4]; let __cu = unconstrained; if let Some(result) = record.function_queries[762].get_mut(&__args[..]) { if !__cu && *result.multiplicity == G::ZERO { aiur_fn_762(__args, record, io_buffer, false)? } else { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_762] = unsafe { *(result.output.as_ptr() as *const [G; OUT_762]) }; __ret } } else { aiur_fn_762(__args, record, io_buffer, __cu)? } }; let __v_5: G = __r_arr[0]; let __loaded: [G; 4] = { let __mq = record.memory_queries.get_mut(&4).ok_or(ExecError::InvalidMemorySize(4))?; let __ptr_u64 = __v_5.as_canonical_u64(); let __ptr_usize = usize::try_from(__ptr_u64).ok().ok_or(ExecError::PointerTooLarge(__ptr_u64))?; let (__args, __mult) = __mq.get_index_mut(__ptr_usize).ok_or(ExecError::UnboundPointer { ptr: __ptr_u64, size: 4 })?; if !unconstrained { *__mult += G::ONE; } let __arr: [G; 4] = __args[..4].try_into().unwrap(); __arr }; let __v_6: G = __loaded[0]; @@ -21327,15 +21051,15 @@ fn aiur_fn_222( 1u64 => { let __v_13: G = G::from_u64(1); let __v_14: G = G::from_u64(2); - let __r_arr: [G; OUT_216] = { let __args: [G; IN_216] = []; let __cu = unconstrained; if let Some(result) = record.function_queries[216].get_mut(&__args[..]) { if !__cu && *result.multiplicity == G::ZERO { aiur_fn_216(__args, record, io_buffer, false)? } else { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_216] = unsafe { *(result.output.as_ptr() as *const [G; OUT_216]) }; __ret } } else { aiur_fn_216(__args, record, io_buffer, __cu)? } }; + let __r_arr: [G; OUT_212] = { let __args: [G; IN_212] = []; let __cu = unconstrained; if let Some(result) = record.function_queries[212].get_mut(&__args[..]) { if !__cu && *result.multiplicity == G::ZERO { aiur_fn_212(__args, record, io_buffer, false)? } else { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_212] = unsafe { *(result.output.as_ptr() as *const [G; OUT_212]) }; __ret } } else { aiur_fn_212(__args, record, io_buffer, __cu)? } }; let __v_15: G = __r_arr[0]; let __v_16: G = G::from_u64(1); let __v_17: G = G::from_u64(1); let __v_18: G = { let __values: [G; 3] = [__v_16, __v_17, __v_17]; let __mq = record.memory_queries.get_mut(&3).ok_or(ExecError::InvalidMemorySize(3))?; if let Some(result) = __mq.get_mut(&__values[..]) { if !unconstrained { *result.multiplicity += G::ONE; } result.output[0] } else { let __ptr = G::from_usize(__mq.len()); __mq.insert(&__values[..], &[__ptr], G::from_bool(!unconstrained)); __ptr } }; let __v_19: G = G::from_u64(0); let __v_20: G = { let __values: [G; 4] = [__v_14, __v_15, __v_18, __v_19]; let __mq = record.memory_queries.get_mut(&4).ok_or(ExecError::InvalidMemorySize(4))?; if let Some(result) = __mq.get_mut(&__values[..]) { if !unconstrained { *result.multiplicity += G::ONE; } result.output[0] } else { let __ptr = G::from_usize(__mq.len()); __mq.insert(&__values[..], &[__ptr], G::from_bool(!unconstrained)); __ptr } }; - let __ret: [G; OUT_222] = [__v_13, __v_20]; - if let Some(result) = record.function_queries[222].get_mut(&inp[..]) { debug_assert_eq!(result.output, &__ret[..]); if !unconstrained { *result.multiplicity += G::ONE; } } else { record.function_queries[222].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained)); }; + let __ret: [G; OUT_218] = [__v_13, __v_20]; + if let Some(result) = record.function_queries[218].get_mut(&inp[..]) { debug_assert_eq!(result.output, &__ret[..]); if !unconstrained { *result.multiplicity += G::ONE; } } else { record.function_queries[218].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained)); }; return Ok(__ret); }, _ => { @@ -21344,8 +21068,8 @@ fn aiur_fn_222( let __v_15: G = G::from_u64(0); let __v_16: G = G::from_u64(0); let __v_17: G = { let __values: [G; 4] = [__v_14, __v_15, __v_16, __v_16]; let __mq = record.memory_queries.get_mut(&4).ok_or(ExecError::InvalidMemorySize(4))?; if let Some(result) = __mq.get_mut(&__values[..]) { if !unconstrained { *result.multiplicity += G::ONE; } result.output[0] } else { let __ptr = G::from_usize(__mq.len()); __mq.insert(&__values[..], &[__ptr], G::from_bool(!unconstrained)); __ptr } }; - let __ret: [G; OUT_222] = [__v_13, __v_17]; - if let Some(result) = record.function_queries[222].get_mut(&inp[..]) { debug_assert_eq!(result.output, &__ret[..]); if !unconstrained { *result.multiplicity += G::ONE; } } else { record.function_queries[222].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained)); }; + let __ret: [G; OUT_218] = [__v_13, __v_17]; + if let Some(result) = record.function_queries[218].get_mut(&inp[..]) { debug_assert_eq!(result.output, &__ret[..]); if !unconstrained { *result.multiplicity += G::ONE; } } else { record.function_queries[218].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained)); }; return Ok(__ret); }, } @@ -21356,8 +21080,8 @@ fn aiur_fn_222( let __v_12: G = G::from_u64(0); let __v_13: G = G::from_u64(0); let __v_14: G = { let __values: [G; 4] = [__v_11, __v_12, __v_13, __v_13]; let __mq = record.memory_queries.get_mut(&4).ok_or(ExecError::InvalidMemorySize(4))?; if let Some(result) = __mq.get_mut(&__values[..]) { if !unconstrained { *result.multiplicity += G::ONE; } result.output[0] } else { let __ptr = G::from_usize(__mq.len()); __mq.insert(&__values[..], &[__ptr], G::from_bool(!unconstrained)); __ptr } }; - let __ret: [G; OUT_222] = [__v_10, __v_14]; - if let Some(result) = record.function_queries[222].get_mut(&inp[..]) { debug_assert_eq!(result.output, &__ret[..]); if !unconstrained { *result.multiplicity += G::ONE; } } else { record.function_queries[222].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained)); }; + let __ret: [G; OUT_218] = [__v_10, __v_14]; + if let Some(result) = record.function_queries[218].get_mut(&inp[..]) { debug_assert_eq!(result.output, &__ret[..]); if !unconstrained { *result.multiplicity += G::ONE; } } else { record.function_queries[218].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained)); }; return Ok(__ret); }, } @@ -21368,8 +21092,8 @@ fn aiur_fn_222( let __v_12: G = G::from_u64(0); let __v_13: G = G::from_u64(0); let __v_14: G = { let __values: [G; 4] = [__v_11, __v_12, __v_13, __v_13]; let __mq = record.memory_queries.get_mut(&4).ok_or(ExecError::InvalidMemorySize(4))?; if let Some(result) = __mq.get_mut(&__values[..]) { if !unconstrained { *result.multiplicity += G::ONE; } result.output[0] } else { let __ptr = G::from_usize(__mq.len()); __mq.insert(&__values[..], &[__ptr], G::from_bool(!unconstrained)); __ptr } }; - let __ret: [G; OUT_222] = [__v_10, __v_14]; - if let Some(result) = record.function_queries[222].get_mut(&inp[..]) { debug_assert_eq!(result.output, &__ret[..]); if !unconstrained { *result.multiplicity += G::ONE; } } else { record.function_queries[222].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained)); }; + let __ret: [G; OUT_218] = [__v_10, __v_14]; + if let Some(result) = record.function_queries[218].get_mut(&inp[..]) { debug_assert_eq!(result.output, &__ret[..]); if !unconstrained { *result.multiplicity += G::ONE; } } else { record.function_queries[218].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained)); }; return Ok(__ret); }, } @@ -21378,15 +21102,15 @@ fn aiur_fn_222( }) } -const INPUT_SIZE_223: usize = 1; -const IN_223: usize = 1; -const OUT_223: usize = 0; -fn aiur_fn_223( - inp: [G; IN_223], +const INPUT_SIZE_219: usize = 1; +const IN_219: usize = 1; +const OUT_219: usize = 0; +fn aiur_fn_219( + inp: [G; IN_219], record: &mut QueryRecord, io_buffer: &mut IOBuffer, unconstrained: bool, -) -> Result<[G; OUT_223], ExecError> { +) -> Result<[G; OUT_219], ExecError> { stacker::maybe_grow(64 * 1024, 4 * 1024 * 1024, || { let __v_0: G = inp[0]; let __loaded: [G; 3] = { let __mq = record.memory_queries.get_mut(&3).ok_or(ExecError::InvalidMemorySize(3))?; let __ptr_u64 = __v_0.as_canonical_u64(); let __ptr_usize = usize::try_from(__ptr_u64).ok().ok_or(ExecError::PointerTooLarge(__ptr_u64))?; let (__args, __mult) = __mq.get_index_mut(__ptr_usize).ok_or(ExecError::UnboundPointer { ptr: __ptr_u64, size: 3 })?; if !unconstrained { *__mult += G::ONE; } let __arr: [G; 3] = __args[..3].try_into().unwrap(); __arr }; @@ -21395,17 +21119,17 @@ fn aiur_fn_223( let __v_3: G = __loaded[2]; match __v_1.as_canonical_u64() { 1u64 => { - let __ret: [G; OUT_223] = []; - if let Some(result) = record.function_queries[223].get_mut(&inp[..]) { debug_assert_eq!(result.output, &__ret[..]); if !unconstrained { *result.multiplicity += G::ONE; } } else { record.function_queries[223].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained)); }; + let __ret: [G; OUT_219] = []; + if let Some(result) = record.function_queries[219].get_mut(&inp[..]) { debug_assert_eq!(result.output, &__ret[..]); if !unconstrained { *result.multiplicity += G::ONE; } } else { record.function_queries[219].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained)); }; return Ok(__ret); }, 0u64 => { - let __r_arr: [G; OUT_227] = { let __args: [G; IN_227] = [__v_2, __v_3]; let __cu = unconstrained; if let Some(result) = record.function_queries[227].get_mut(&__args[..]) { if !__cu && *result.multiplicity == G::ZERO { aiur_fn_227(__args, record, io_buffer, false)? } else { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_227] = unsafe { *(result.output.as_ptr() as *const [G; OUT_227]) }; __ret } } else { aiur_fn_227(__args, record, io_buffer, __cu)? } }; + let __r_arr: [G; OUT_223] = { let __args: [G; IN_223] = [__v_2, __v_3]; let __cu = unconstrained; if let Some(result) = record.function_queries[223].get_mut(&__args[..]) { if !__cu && *result.multiplicity == G::ZERO { aiur_fn_223(__args, record, io_buffer, false)? } else { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_223] = unsafe { *(result.output.as_ptr() as *const [G; OUT_223]) }; __ret } } else { aiur_fn_223(__args, record, io_buffer, __cu)? } }; let __v_4: G = __r_arr[0]; let __v_5: G = __r_arr[1]; - let __r_arr: [G; OUT_223] = { let __args: [G; IN_223] = [__v_5]; let __cu = unconstrained; if let Some(result) = record.function_queries[223].get_mut(&__args[..]) { if !__cu && *result.multiplicity == G::ZERO { aiur_fn_223(__args, record, io_buffer, false)? } else { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_223] = unsafe { *(result.output.as_ptr() as *const [G; OUT_223]) }; __ret } } else { aiur_fn_223(__args, record, io_buffer, __cu)? } }; - let __ret: [G; OUT_223] = []; - if let Some(result) = record.function_queries[223].get_mut(&inp[..]) { debug_assert_eq!(result.output, &__ret[..]); if !unconstrained { *result.multiplicity += G::ONE; } } else { record.function_queries[223].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained)); }; + let __r_arr: [G; OUT_219] = { let __args: [G; IN_219] = [__v_5]; let __cu = unconstrained; if let Some(result) = record.function_queries[219].get_mut(&__args[..]) { if !__cu && *result.multiplicity == G::ZERO { aiur_fn_219(__args, record, io_buffer, false)? } else { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_219] = unsafe { *(result.output.as_ptr() as *const [G; OUT_219]) }; __ret } } else { aiur_fn_219(__args, record, io_buffer, __cu)? } }; + let __ret: [G; OUT_219] = []; + if let Some(result) = record.function_queries[219].get_mut(&inp[..]) { debug_assert_eq!(result.output, &__ret[..]); if !unconstrained { *result.multiplicity += G::ONE; } } else { record.function_queries[219].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained)); }; return Ok(__ret); }, _ => { @@ -21415,35 +21139,35 @@ fn aiur_fn_223( }) } -const INPUT_SIZE_224: usize = 1; -const IN_224: usize = 1; -const OUT_224: usize = 1; -fn aiur_fn_224( - inp: [G; IN_224], +const INPUT_SIZE_220: usize = 1; +const IN_220: usize = 1; +const OUT_220: usize = 1; +fn aiur_fn_220( + inp: [G; IN_220], record: &mut QueryRecord, io_buffer: &mut IOBuffer, unconstrained: bool, -) -> Result<[G; OUT_224], ExecError> { +) -> Result<[G; OUT_220], ExecError> { stacker::maybe_grow(64 * 1024, 4 * 1024 * 1024, || { let __v_0: G = inp[0]; let __v_1: G = G::from_u64(65); - let __r_arr: [G; OUT_225] = { let __args: [G; IN_225] = [__v_0, __v_1]; let __cu = unconstrained; if let Some(result) = record.function_queries[225].get_mut(&__args[..]) { if !__cu && *result.multiplicity == G::ZERO { aiur_fn_225(__args, record, io_buffer, false)? } else { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_225] = unsafe { *(result.output.as_ptr() as *const [G; OUT_225]) }; __ret } } else { aiur_fn_225(__args, record, io_buffer, __cu)? } }; + let __r_arr: [G; OUT_221] = { let __args: [G; IN_221] = [__v_0, __v_1]; let __cu = unconstrained; if let Some(result) = record.function_queries[221].get_mut(&__args[..]) { if !__cu && *result.multiplicity == G::ZERO { aiur_fn_221(__args, record, io_buffer, false)? } else { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_221] = unsafe { *(result.output.as_ptr() as *const [G; OUT_221]) }; __ret } } else { aiur_fn_221(__args, record, io_buffer, __cu)? } }; let __v_2: G = __r_arr[0]; - let __ret: [G; OUT_224] = [__v_2]; - if let Some(result) = record.function_queries[224].get_mut(&inp[..]) { debug_assert_eq!(result.output, &__ret[..]); if !unconstrained { *result.multiplicity += G::ONE; } } else { record.function_queries[224].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained)); }; + let __ret: [G; OUT_220] = [__v_2]; + if let Some(result) = record.function_queries[220].get_mut(&inp[..]) { debug_assert_eq!(result.output, &__ret[..]); if !unconstrained { *result.multiplicity += G::ONE; } } else { record.function_queries[220].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained)); }; return Ok(__ret); }) } -const INPUT_SIZE_225: usize = 2; -const IN_225: usize = 2; -const OUT_225: usize = 1; -fn aiur_fn_225( - inp: [G; IN_225], +const INPUT_SIZE_221: usize = 2; +const IN_221: usize = 2; +const OUT_221: usize = 1; +fn aiur_fn_221( + inp: [G; IN_221], record: &mut QueryRecord, io_buffer: &mut IOBuffer, unconstrained: bool, -) -> Result<[G; OUT_225], ExecError> { +) -> Result<[G; OUT_221], ExecError> { stacker::maybe_grow(64 * 1024, 4 * 1024 * 1024, || { let __v_0: G = inp[0]; let __v_1: G = inp[1]; @@ -21453,18 +21177,18 @@ fn aiur_fn_225( let __v_4: G = __loaded[2]; match __v_2.as_canonical_u64() { 1u64 => { - let __ret: [G; OUT_225] = [__v_1]; - if let Some(result) = record.function_queries[225].get_mut(&inp[..]) { debug_assert_eq!(result.output, &__ret[..]); if !unconstrained { *result.multiplicity += G::ONE; } } else { record.function_queries[225].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained)); }; + let __ret: [G; OUT_221] = [__v_1]; + if let Some(result) = record.function_queries[221].get_mut(&inp[..]) { debug_assert_eq!(result.output, &__ret[..]); if !unconstrained { *result.multiplicity += G::ONE; } } else { record.function_queries[221].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained)); }; return Ok(__ret); }, 0u64 => { - let __r_arr: [G; OUT_227] = { let __args: [G; IN_227] = [__v_3, __v_4]; let __cu = unconstrained; if let Some(result) = record.function_queries[227].get_mut(&__args[..]) { if !__cu && *result.multiplicity == G::ZERO { aiur_fn_227(__args, record, io_buffer, false)? } else { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_227] = unsafe { *(result.output.as_ptr() as *const [G; OUT_227]) }; __ret } } else { aiur_fn_227(__args, record, io_buffer, __cu)? } }; + let __r_arr: [G; OUT_223] = { let __args: [G; IN_223] = [__v_3, __v_4]; let __cu = unconstrained; if let Some(result) = record.function_queries[223].get_mut(&__args[..]) { if !__cu && *result.multiplicity == G::ZERO { aiur_fn_223(__args, record, io_buffer, false)? } else { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_223] = unsafe { *(result.output.as_ptr() as *const [G; OUT_223]) }; __ret } } else { aiur_fn_223(__args, record, io_buffer, __cu)? } }; let __v_5: G = __r_arr[0]; let __v_6: G = __r_arr[1]; - let __r_arr: [G; OUT_225] = { let __args: [G; IN_225] = [__v_6, __v_5]; let __cu = unconstrained; if let Some(result) = record.function_queries[225].get_mut(&__args[..]) { if !__cu && *result.multiplicity == G::ZERO { aiur_fn_225(__args, record, io_buffer, false)? } else { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_225] = unsafe { *(result.output.as_ptr() as *const [G; OUT_225]) }; __ret } } else { aiur_fn_225(__args, record, io_buffer, __cu)? } }; + let __r_arr: [G; OUT_221] = { let __args: [G; IN_221] = [__v_6, __v_5]; let __cu = unconstrained; if let Some(result) = record.function_queries[221].get_mut(&__args[..]) { if !__cu && *result.multiplicity == G::ZERO { aiur_fn_221(__args, record, io_buffer, false)? } else { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_221] = unsafe { *(result.output.as_ptr() as *const [G; OUT_221]) }; __ret } } else { aiur_fn_221(__args, record, io_buffer, __cu)? } }; let __v_7: G = __r_arr[0]; - let __ret: [G; OUT_225] = [__v_7]; - if let Some(result) = record.function_queries[225].get_mut(&inp[..]) { debug_assert_eq!(result.output, &__ret[..]); if !unconstrained { *result.multiplicity += G::ONE; } } else { record.function_queries[225].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained)); }; + let __ret: [G; OUT_221] = [__v_7]; + if let Some(result) = record.function_queries[221].get_mut(&inp[..]) { debug_assert_eq!(result.output, &__ret[..]); if !unconstrained { *result.multiplicity += G::ONE; } } else { record.function_queries[221].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained)); }; return Ok(__ret); }, _ => { @@ -21474,15 +21198,15 @@ fn aiur_fn_225( }) } -const INPUT_SIZE_226: usize = 1; -const IN_226: usize = 1; -const OUT_226: usize = 1; -fn aiur_fn_226( - inp: [G; IN_226], +const INPUT_SIZE_222: usize = 1; +const IN_222: usize = 1; +const OUT_222: usize = 1; +fn aiur_fn_222( + inp: [G; IN_222], record: &mut QueryRecord, io_buffer: &mut IOBuffer, unconstrained: bool, -) -> Result<[G; OUT_226], ExecError> { +) -> Result<[G; OUT_222], ExecError> { stacker::maybe_grow(64 * 1024, 4 * 1024 * 1024, || { let __v_0: G = inp[0]; let __v_1: G = G::from_u64(128); @@ -21495,8 +21219,8 @@ fn aiur_fn_226( 1u64 => { let __v_5: G = G::from_u64(128); let __v_6: G = (__v_0 - __v_5); - let __ret: [G; OUT_226] = [__v_6]; - if let Some(result) = record.function_queries[226].get_mut(&inp[..]) { debug_assert_eq!(result.output, &__ret[..]); if !unconstrained { *result.multiplicity += G::ONE; } } else { record.function_queries[226].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained)); }; + let __ret: [G; OUT_222] = [__v_6]; + if let Some(result) = record.function_queries[222].get_mut(&inp[..]) { debug_assert_eq!(result.output, &__ret[..]); if !unconstrained { *result.multiplicity += G::ONE; } } else { record.function_queries[222].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained)); }; return Ok(__ret); }, _ => { @@ -21511,15 +21235,15 @@ fn aiur_fn_226( }) } -const INPUT_SIZE_227: usize = 2; -const IN_227: usize = 2; -const OUT_227: usize = 2; -fn aiur_fn_227( - inp: [G; IN_227], +const INPUT_SIZE_223: usize = 2; +const IN_223: usize = 2; +const OUT_223: usize = 2; +fn aiur_fn_223( + inp: [G; IN_223], record: &mut QueryRecord, io_buffer: &mut IOBuffer, unconstrained: bool, -) -> Result<[G; OUT_227], ExecError> { +) -> Result<[G; OUT_223], ExecError> { stacker::maybe_grow(64 * 1024, 4 * 1024 * 1024, || { let __v_0: G = inp[0]; let __v_1: G = inp[1]; @@ -21527,8 +21251,8 @@ fn aiur_fn_227( let __v_3: G = if unconstrained { Bytes2::less_than(&__v_0, &__v_2) } else { bytes2_less_than_value(__v_0, __v_2, record) }; match __v_3.as_canonical_u64() { 1u64 => { - let __ret: [G; OUT_227] = [__v_0, __v_1]; - if let Some(result) = record.function_queries[227].get_mut(&inp[..]) { debug_assert_eq!(result.output, &__ret[..]); if !unconstrained { *result.multiplicity += G::ONE; } } else { record.function_queries[227].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained)); }; + let __ret: [G; OUT_223] = [__v_0, __v_1]; + if let Some(result) = record.function_queries[223].get_mut(&inp[..]) { debug_assert_eq!(result.output, &__ret[..]); if !unconstrained { *result.multiplicity += G::ONE; } } else { record.function_queries[223].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained)); }; return Ok(__ret); }, _ => { @@ -21550,11 +21274,11 @@ fn aiur_fn_227( let __v_12: G = (__v_0 - __v_11); let __v_13: G = G::from_u64(64); let __v_14: G = (__v_12 * __v_13); - let __r_arr: [G; OUT_226] = { let __args: [G; IN_226] = [__v_9]; let __cu = unconstrained; if let Some(result) = record.function_queries[226].get_mut(&__args[..]) { if !__cu && *result.multiplicity == G::ZERO { aiur_fn_226(__args, record, io_buffer, false)? } else { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_226] = unsafe { *(result.output.as_ptr() as *const [G; OUT_226]) }; __ret } } else { aiur_fn_226(__args, record, io_buffer, __cu)? } }; + let __r_arr: [G; OUT_222] = { let __args: [G; IN_222] = [__v_9]; let __cu = unconstrained; if let Some(result) = record.function_queries[222].get_mut(&__args[..]) { if !__cu && *result.multiplicity == G::ZERO { aiur_fn_222(__args, record, io_buffer, false)? } else { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_222] = unsafe { *(result.output.as_ptr() as *const [G; OUT_222]) }; __ret } } else { aiur_fn_222(__args, record, io_buffer, __cu)? } }; let __v_15: G = __r_arr[0]; let __v_16: G = (__v_14 + __v_15); - let __ret: [G; OUT_227] = [__v_16, __v_10]; - if let Some(result) = record.function_queries[227].get_mut(&inp[..]) { debug_assert_eq!(result.output, &__ret[..]); if !unconstrained { *result.multiplicity += G::ONE; } } else { record.function_queries[227].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained)); }; + let __ret: [G; OUT_223] = [__v_16, __v_10]; + if let Some(result) = record.function_queries[223].get_mut(&inp[..]) { debug_assert_eq!(result.output, &__ret[..]); if !unconstrained { *result.multiplicity += G::ONE; } } else { record.function_queries[223].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained)); }; return Ok(__ret); }, _ => { @@ -21583,11 +21307,11 @@ fn aiur_fn_227( let __v_17: G = (__v_0 - __v_16); let __v_18: G = G::from_u64(4096); let __v_19: G = (__v_17 * __v_18); - let __r_arr: [G; OUT_226] = { let __args: [G; IN_226] = [__v_11]; let __cu = unconstrained; if let Some(result) = record.function_queries[226].get_mut(&__args[..]) { if !__cu && *result.multiplicity == G::ZERO { aiur_fn_226(__args, record, io_buffer, false)? } else { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_226] = unsafe { *(result.output.as_ptr() as *const [G; OUT_226]) }; __ret } } else { aiur_fn_226(__args, record, io_buffer, __cu)? } }; + let __r_arr: [G; OUT_222] = { let __args: [G; IN_222] = [__v_11]; let __cu = unconstrained; if let Some(result) = record.function_queries[222].get_mut(&__args[..]) { if !__cu && *result.multiplicity == G::ZERO { aiur_fn_222(__args, record, io_buffer, false)? } else { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_222] = unsafe { *(result.output.as_ptr() as *const [G; OUT_222]) }; __ret } } else { aiur_fn_222(__args, record, io_buffer, __cu)? } }; let __v_20: G = __r_arr[0]; let __v_21: G = G::from_u64(64); let __v_22: G = (__v_20 * __v_21); - let __r_arr: [G; OUT_226] = { let __args: [G; IN_226] = [__v_14]; let __cu = unconstrained; if let Some(result) = record.function_queries[226].get_mut(&__args[..]) { if !__cu && *result.multiplicity == G::ZERO { aiur_fn_226(__args, record, io_buffer, false)? } else { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_226] = unsafe { *(result.output.as_ptr() as *const [G; OUT_226]) }; __ret } } else { aiur_fn_226(__args, record, io_buffer, __cu)? } }; + let __r_arr: [G; OUT_222] = { let __args: [G; IN_222] = [__v_14]; let __cu = unconstrained; if let Some(result) = record.function_queries[222].get_mut(&__args[..]) { if !__cu && *result.multiplicity == G::ZERO { aiur_fn_222(__args, record, io_buffer, false)? } else { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_222] = unsafe { *(result.output.as_ptr() as *const [G; OUT_222]) }; __ret } } else { aiur_fn_222(__args, record, io_buffer, __cu)? } }; let __v_23: G = __r_arr[0]; let __v_24: G = (__v_22 + __v_23); let __v_25: G = (__v_19 + __v_24); @@ -21595,8 +21319,8 @@ fn aiur_fn_227( let __v_27: G = { let __a_val = __v_25.as_canonical_u64(); let __b_val = __v_26.as_canonical_u64(); let __a_u32 = u32::try_from(__a_val).ok().ok_or(ExecError::U32OutOfRange(__a_val))?; let __b_u32 = u32::try_from(__b_val).ok().ok_or(ExecError::U32OutOfRange(__b_val))?; let __result = G::from_bool(__a_u32 < __b_u32); if !unconstrained { let __x_bytes = __a_u32.to_le_bytes(); let __z_bytes = __b_u32.to_le_bytes(); let __c_u32 = __b_u32.wrapping_sub(__a_u32).wrapping_sub(1); let __y_bytes = __c_u32.to_le_bytes(); record.bytes2_queries.bump_range_check(&G::from_u8(__x_bytes[0]), &G::from_u8(__x_bytes[1])); record.bytes2_queries.bump_range_check(&G::from_u8(__x_bytes[2]), &G::from_u8(__x_bytes[3])); record.bytes2_queries.bump_range_check(&G::from_u8(__y_bytes[0]), &G::from_u8(__y_bytes[1])); record.bytes2_queries.bump_range_check(&G::from_u8(__y_bytes[2]), &G::from_u8(__y_bytes[3])); record.bytes2_queries.bump_range_check(&G::from_u8(__z_bytes[0]), &G::from_u8(__z_bytes[1])); record.bytes2_queries.bump_range_check(&G::from_u8(__z_bytes[2]), &G::from_u8(__z_bytes[3])); } __result }; match __v_27.as_canonical_u64() { 0u64 => { - let __ret: [G; OUT_227] = [__v_25, __v_15]; - if let Some(result) = record.function_queries[227].get_mut(&inp[..]) { debug_assert_eq!(result.output, &__ret[..]); if !unconstrained { *result.multiplicity += G::ONE; } } else { record.function_queries[227].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained)); }; + let __ret: [G; OUT_223] = [__v_25, __v_15]; + if let Some(result) = record.function_queries[223].get_mut(&inp[..]) { debug_assert_eq!(result.output, &__ret[..]); if !unconstrained { *result.multiplicity += G::ONE; } } else { record.function_queries[223].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained)); }; return Ok(__ret); }, _ => { @@ -21637,15 +21361,15 @@ fn aiur_fn_227( let __v_20: G = (__v_0 - __v_19); let __v_21: G = G::from_u64(262144); let __v_22: G = (__v_20 * __v_21); - let __r_arr: [G; OUT_226] = { let __args: [G; IN_226] = [__v_11]; let __cu = unconstrained; if let Some(result) = record.function_queries[226].get_mut(&__args[..]) { if !__cu && *result.multiplicity == G::ZERO { aiur_fn_226(__args, record, io_buffer, false)? } else { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_226] = unsafe { *(result.output.as_ptr() as *const [G; OUT_226]) }; __ret } } else { aiur_fn_226(__args, record, io_buffer, __cu)? } }; + let __r_arr: [G; OUT_222] = { let __args: [G; IN_222] = [__v_11]; let __cu = unconstrained; if let Some(result) = record.function_queries[222].get_mut(&__args[..]) { if !__cu && *result.multiplicity == G::ZERO { aiur_fn_222(__args, record, io_buffer, false)? } else { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_222] = unsafe { *(result.output.as_ptr() as *const [G; OUT_222]) }; __ret } } else { aiur_fn_222(__args, record, io_buffer, __cu)? } }; let __v_23: G = __r_arr[0]; let __v_24: G = G::from_u64(4096); let __v_25: G = (__v_23 * __v_24); - let __r_arr: [G; OUT_226] = { let __args: [G; IN_226] = [__v_14]; let __cu = unconstrained; if let Some(result) = record.function_queries[226].get_mut(&__args[..]) { if !__cu && *result.multiplicity == G::ZERO { aiur_fn_226(__args, record, io_buffer, false)? } else { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_226] = unsafe { *(result.output.as_ptr() as *const [G; OUT_226]) }; __ret } } else { aiur_fn_226(__args, record, io_buffer, __cu)? } }; + let __r_arr: [G; OUT_222] = { let __args: [G; IN_222] = [__v_14]; let __cu = unconstrained; if let Some(result) = record.function_queries[222].get_mut(&__args[..]) { if !__cu && *result.multiplicity == G::ZERO { aiur_fn_222(__args, record, io_buffer, false)? } else { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_222] = unsafe { *(result.output.as_ptr() as *const [G; OUT_222]) }; __ret } } else { aiur_fn_222(__args, record, io_buffer, __cu)? } }; let __v_26: G = __r_arr[0]; let __v_27: G = G::from_u64(64); let __v_28: G = (__v_26 * __v_27); - let __r_arr: [G; OUT_226] = { let __args: [G; IN_226] = [__v_17]; let __cu = unconstrained; if let Some(result) = record.function_queries[226].get_mut(&__args[..]) { if !__cu && *result.multiplicity == G::ZERO { aiur_fn_226(__args, record, io_buffer, false)? } else { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_226] = unsafe { *(result.output.as_ptr() as *const [G; OUT_226]) }; __ret } } else { aiur_fn_226(__args, record, io_buffer, __cu)? } }; + let __r_arr: [G; OUT_222] = { let __args: [G; IN_222] = [__v_17]; let __cu = unconstrained; if let Some(result) = record.function_queries[222].get_mut(&__args[..]) { if !__cu && *result.multiplicity == G::ZERO { aiur_fn_222(__args, record, io_buffer, false)? } else { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_222] = unsafe { *(result.output.as_ptr() as *const [G; OUT_222]) }; __ret } } else { aiur_fn_222(__args, record, io_buffer, __cu)? } }; let __v_29: G = __r_arr[0]; let __v_30: G = (__v_28 + __v_29); let __v_31: G = (__v_25 + __v_30); @@ -21654,8 +21378,8 @@ fn aiur_fn_227( let __v_34: G = { let __a_val = __v_32.as_canonical_u64(); let __b_val = __v_33.as_canonical_u64(); let __a_u32 = u32::try_from(__a_val).ok().ok_or(ExecError::U32OutOfRange(__a_val))?; let __b_u32 = u32::try_from(__b_val).ok().ok_or(ExecError::U32OutOfRange(__b_val))?; let __result = G::from_bool(__a_u32 < __b_u32); if !unconstrained { let __x_bytes = __a_u32.to_le_bytes(); let __z_bytes = __b_u32.to_le_bytes(); let __c_u32 = __b_u32.wrapping_sub(__a_u32).wrapping_sub(1); let __y_bytes = __c_u32.to_le_bytes(); record.bytes2_queries.bump_range_check(&G::from_u8(__x_bytes[0]), &G::from_u8(__x_bytes[1])); record.bytes2_queries.bump_range_check(&G::from_u8(__x_bytes[2]), &G::from_u8(__x_bytes[3])); record.bytes2_queries.bump_range_check(&G::from_u8(__y_bytes[0]), &G::from_u8(__y_bytes[1])); record.bytes2_queries.bump_range_check(&G::from_u8(__y_bytes[2]), &G::from_u8(__y_bytes[3])); record.bytes2_queries.bump_range_check(&G::from_u8(__z_bytes[0]), &G::from_u8(__z_bytes[1])); record.bytes2_queries.bump_range_check(&G::from_u8(__z_bytes[2]), &G::from_u8(__z_bytes[3])); } __result }; match __v_34.as_canonical_u64() { 0u64 => { - let __ret: [G; OUT_227] = [__v_32, __v_18]; - if let Some(result) = record.function_queries[227].get_mut(&inp[..]) { debug_assert_eq!(result.output, &__ret[..]); if !unconstrained { *result.multiplicity += G::ONE; } } else { record.function_queries[227].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained)); }; + let __ret: [G; OUT_223] = [__v_32, __v_18]; + if let Some(result) = record.function_queries[223].get_mut(&inp[..]) { debug_assert_eq!(result.output, &__ret[..]); if !unconstrained { *result.multiplicity += G::ONE; } } else { record.function_queries[223].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained)); }; return Ok(__ret); }, _ => { @@ -21691,15 +21415,15 @@ fn aiur_fn_227( }) } -const INPUT_SIZE_228: usize = 1; -const IN_228: usize = 1; -const OUT_228: usize = 1; -fn aiur_fn_228( - inp: [G; IN_228], +const INPUT_SIZE_224: usize = 1; +const IN_224: usize = 1; +const OUT_224: usize = 1; +fn aiur_fn_224( + inp: [G; IN_224], record: &mut QueryRecord, io_buffer: &mut IOBuffer, unconstrained: bool, -) -> Result<[G; OUT_228], ExecError> { +) -> Result<[G; OUT_224], ExecError> { stacker::maybe_grow(64 * 1024, 4 * 1024 * 1024, || { let __v_0: G = inp[0]; let __v_1: G = G::from_u64(0); @@ -21711,17 +21435,17 @@ fn aiur_fn_228( let __v_7: G = { let __values: [G; 3] = [__v_5, __v_6, __v_6]; let __mq = record.memory_queries.get_mut(&3).ok_or(ExecError::InvalidMemorySize(3))?; if let Some(result) = __mq.get_mut(&__values[..]) { if !unconstrained { *result.multiplicity += G::ONE; } result.output[0] } else { let __ptr = G::from_usize(__mq.len()); __mq.insert(&__values[..], &[__ptr], G::from_bool(!unconstrained)); __ptr } }; let __v_8: G = { let __values: [G; 3] = [__v_4, __v_3, __v_7]; let __mq = record.memory_queries.get_mut(&3).ok_or(ExecError::InvalidMemorySize(3))?; if let Some(result) = __mq.get_mut(&__values[..]) { if !unconstrained { *result.multiplicity += G::ONE; } result.output[0] } else { let __ptr = G::from_usize(__mq.len()); __mq.insert(&__values[..], &[__ptr], G::from_bool(!unconstrained)); __ptr } }; let __v_9: G = G::from_u64(2); - let __r_arr: [G; OUT_210] = { let __args: [G; IN_210] = []; let __cu = unconstrained; if let Some(result) = record.function_queries[210].get_mut(&__args[..]) { if !__cu && *result.multiplicity == G::ZERO { aiur_fn_210(__args, record, io_buffer, false)? } else { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_210] = unsafe { *(result.output.as_ptr() as *const [G; OUT_210]) }; __ret } } else { aiur_fn_210(__args, record, io_buffer, __cu)? } }; + let __r_arr: [G; OUT_206] = { let __args: [G; IN_206] = []; let __cu = unconstrained; if let Some(result) = record.function_queries[206].get_mut(&__args[..]) { if !__cu && *result.multiplicity == G::ZERO { aiur_fn_206(__args, record, io_buffer, false)? } else { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_206] = unsafe { *(result.output.as_ptr() as *const [G; OUT_206]) }; __ret } } else { aiur_fn_206(__args, record, io_buffer, __cu)? } }; let __v_10: G = __r_arr[0]; let __v_11: G = G::from_u64(0); let __v_12: G = { let __values: [G; 4] = [__v_9, __v_10, __v_8, __v_11]; let __mq = record.memory_queries.get_mut(&4).ok_or(ExecError::InvalidMemorySize(4))?; if let Some(result) = __mq.get_mut(&__values[..]) { if !unconstrained { *result.multiplicity += G::ONE; } result.output[0] } else { let __ptr = G::from_usize(__mq.len()); __mq.insert(&__values[..], &[__ptr], G::from_bool(!unconstrained)); __ptr } }; let __v_13: G = G::from_u64(2); - let __r_arr: [G; OUT_211] = { let __args: [G; IN_211] = []; let __cu = unconstrained; if let Some(result) = record.function_queries[211].get_mut(&__args[..]) { if !__cu && *result.multiplicity == G::ZERO { aiur_fn_211(__args, record, io_buffer, false)? } else { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_211] = unsafe { *(result.output.as_ptr() as *const [G; OUT_211]) }; __ret } } else { aiur_fn_211(__args, record, io_buffer, __cu)? } }; + let __r_arr: [G; OUT_207] = { let __args: [G; IN_207] = []; let __cu = unconstrained; if let Some(result) = record.function_queries[207].get_mut(&__args[..]) { if !__cu && *result.multiplicity == G::ZERO { aiur_fn_207(__args, record, io_buffer, false)? } else { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_207] = unsafe { *(result.output.as_ptr() as *const [G; OUT_207]) }; __ret } } else { aiur_fn_207(__args, record, io_buffer, __cu)? } }; let __v_14: G = __r_arr[0]; let __v_15: G = G::from_u64(0); let __v_16: G = { let __values: [G; 4] = [__v_13, __v_14, __v_8, __v_15]; let __mq = record.memory_queries.get_mut(&4).ok_or(ExecError::InvalidMemorySize(4))?; if let Some(result) = __mq.get_mut(&__values[..]) { if !unconstrained { *result.multiplicity += G::ONE; } result.output[0] } else { let __ptr = G::from_usize(__mq.len()); __mq.insert(&__values[..], &[__ptr], G::from_bool(!unconstrained)); __ptr } }; let __v_17: G = G::from_u64(2); - let __r_arr: [G; OUT_212] = { let __args: [G; IN_212] = []; let __cu = unconstrained; if let Some(result) = record.function_queries[212].get_mut(&__args[..]) { if !__cu && *result.multiplicity == G::ZERO { aiur_fn_212(__args, record, io_buffer, false)? } else { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_212] = unsafe { *(result.output.as_ptr() as *const [G; OUT_212]) }; __ret } } else { aiur_fn_212(__args, record, io_buffer, __cu)? } }; + let __r_arr: [G; OUT_208] = { let __args: [G; IN_208] = []; let __cu = unconstrained; if let Some(result) = record.function_queries[208].get_mut(&__args[..]) { if !__cu && *result.multiplicity == G::ZERO { aiur_fn_208(__args, record, io_buffer, false)? } else { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_208] = unsafe { *(result.output.as_ptr() as *const [G; OUT_208]) }; __ret } } else { aiur_fn_208(__args, record, io_buffer, __cu)? } }; let __v_18: G = __r_arr[0]; let __v_19: G = G::from_u64(1); let __v_20: G = G::from_u64(1); @@ -21729,7 +21453,7 @@ fn aiur_fn_228( let __v_22: G = G::from_u64(0); let __v_23: G = { let __values: [G; 4] = [__v_17, __v_18, __v_21, __v_22]; let __mq = record.memory_queries.get_mut(&4).ok_or(ExecError::InvalidMemorySize(4))?; if let Some(result) = __mq.get_mut(&__values[..]) { if !unconstrained { *result.multiplicity += G::ONE; } result.output[0] } else { let __ptr = G::from_usize(__mq.len()); __mq.insert(&__values[..], &[__ptr], G::from_bool(!unconstrained)); __ptr } }; let __v_24: G = G::from_u64(2); - let __r_arr: [G; OUT_209] = { let __args: [G; IN_209] = []; let __cu = unconstrained; if let Some(result) = record.function_queries[209].get_mut(&__args[..]) { if !__cu && *result.multiplicity == G::ZERO { aiur_fn_209(__args, record, io_buffer, false)? } else { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_209] = unsafe { *(result.output.as_ptr() as *const [G; OUT_209]) }; __ret } } else { aiur_fn_209(__args, record, io_buffer, __cu)? } }; + let __r_arr: [G; OUT_205] = { let __args: [G; IN_205] = []; let __cu = unconstrained; if let Some(result) = record.function_queries[205].get_mut(&__args[..]) { if !__cu && *result.multiplicity == G::ZERO { aiur_fn_205(__args, record, io_buffer, false)? } else { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_205] = unsafe { *(result.output.as_ptr() as *const [G; OUT_205]) }; __ret } } else { aiur_fn_205(__args, record, io_buffer, __cu)? } }; let __v_25: G = __r_arr[0]; let __v_26: G = G::from_u64(1); let __v_27: G = G::from_u64(1); @@ -21737,7 +21461,7 @@ fn aiur_fn_228( let __v_29: G = G::from_u64(0); let __v_30: G = { let __values: [G; 4] = [__v_24, __v_25, __v_28, __v_29]; let __mq = record.memory_queries.get_mut(&4).ok_or(ExecError::InvalidMemorySize(4))?; if let Some(result) = __mq.get_mut(&__values[..]) { if !unconstrained { *result.multiplicity += G::ONE; } result.output[0] } else { let __ptr = G::from_usize(__mq.len()); __mq.insert(&__values[..], &[__ptr], G::from_bool(!unconstrained)); __ptr } }; let __v_31: G = G::from_u64(2); - let __r_arr: [G; OUT_208] = { let __args: [G; IN_208] = []; let __cu = unconstrained; if let Some(result) = record.function_queries[208].get_mut(&__args[..]) { if !__cu && *result.multiplicity == G::ZERO { aiur_fn_208(__args, record, io_buffer, false)? } else { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_208] = unsafe { *(result.output.as_ptr() as *const [G; OUT_208]) }; __ret } } else { aiur_fn_208(__args, record, io_buffer, __cu)? } }; + let __r_arr: [G; OUT_204] = { let __args: [G; IN_204] = []; let __cu = unconstrained; if let Some(result) = record.function_queries[204].get_mut(&__args[..]) { if !__cu && *result.multiplicity == G::ZERO { aiur_fn_204(__args, record, io_buffer, false)? } else { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_204] = unsafe { *(result.output.as_ptr() as *const [G; OUT_204]) }; __ret } } else { aiur_fn_204(__args, record, io_buffer, __cu)? } }; let __v_32: G = __r_arr[0]; let __v_33: G = G::from_u64(1); let __v_34: G = G::from_u64(1); @@ -21750,26 +21474,26 @@ fn aiur_fn_228( let __v_41: G = G::from_u64(3); let __v_42: G = G::from_u64(0); let __v_43: G = { let __values: [G; 4] = [__v_41, __v_16, __v_23, __v_42]; let __mq = record.memory_queries.get_mut(&4).ok_or(ExecError::InvalidMemorySize(4))?; if let Some(result) = __mq.get_mut(&__values[..]) { if !unconstrained { *result.multiplicity += G::ONE; } result.output[0] } else { let __ptr = G::from_usize(__mq.len()); __mq.insert(&__values[..], &[__ptr], G::from_bool(!unconstrained)); __ptr } }; - let __r_arr: [G; OUT_229] = { let __args: [G; IN_229] = [__v_0, __v_40, __v_43, __v_30]; let __cu = unconstrained; if let Some(result) = record.function_queries[229].get_mut(&__args[..]) { if !__cu && *result.multiplicity == G::ZERO { aiur_fn_229(__args, record, io_buffer, false)? } else { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_229] = unsafe { *(result.output.as_ptr() as *const [G; OUT_229]) }; __ret } } else { aiur_fn_229(__args, record, io_buffer, __cu)? } }; + let __r_arr: [G; OUT_225] = { let __args: [G; IN_225] = [__v_0, __v_40, __v_43, __v_30]; let __cu = unconstrained; if let Some(result) = record.function_queries[225].get_mut(&__args[..]) { if !__cu && *result.multiplicity == G::ZERO { aiur_fn_225(__args, record, io_buffer, false)? } else { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_225] = unsafe { *(result.output.as_ptr() as *const [G; OUT_225]) }; __ret } } else { aiur_fn_225(__args, record, io_buffer, __cu)? } }; let __v_44: G = __r_arr[0]; let __v_45: G = G::from_u64(3); let __v_46: G = G::from_u64(0); let __v_47: G = { let __values: [G; 4] = [__v_45, __v_37, __v_44, __v_46]; let __mq = record.memory_queries.get_mut(&4).ok_or(ExecError::InvalidMemorySize(4))?; if let Some(result) = __mq.get_mut(&__values[..]) { if !unconstrained { *result.multiplicity += G::ONE; } result.output[0] } else { let __ptr = G::from_usize(__mq.len()); __mq.insert(&__values[..], &[__ptr], G::from_bool(!unconstrained)); __ptr } }; - let __ret: [G; OUT_228] = [__v_47]; - if let Some(result) = record.function_queries[228].get_mut(&inp[..]) { debug_assert_eq!(result.output, &__ret[..]); if !unconstrained { *result.multiplicity += G::ONE; } } else { record.function_queries[228].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained)); }; + let __ret: [G; OUT_224] = [__v_47]; + if let Some(result) = record.function_queries[224].get_mut(&inp[..]) { debug_assert_eq!(result.output, &__ret[..]); if !unconstrained { *result.multiplicity += G::ONE; } } else { record.function_queries[224].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained)); }; return Ok(__ret); }) } -const INPUT_SIZE_229: usize = 4; -const IN_229: usize = 4; -const OUT_229: usize = 1; -fn aiur_fn_229( - inp: [G; IN_229], +const INPUT_SIZE_225: usize = 4; +const IN_225: usize = 4; +const OUT_225: usize = 1; +fn aiur_fn_225( + inp: [G; IN_225], record: &mut QueryRecord, io_buffer: &mut IOBuffer, unconstrained: bool, -) -> Result<[G; OUT_229], ExecError> { +) -> Result<[G; OUT_225], ExecError> { stacker::maybe_grow(64 * 1024, 4 * 1024 * 1024, || { let __v_0: G = inp[0]; let __v_1: G = inp[1]; @@ -21781,15 +21505,15 @@ fn aiur_fn_229( let __v_6: G = __loaded[2]; match __v_4.as_canonical_u64() { 1u64 => { - let __ret: [G; OUT_229] = [__v_1]; - if let Some(result) = record.function_queries[229].get_mut(&inp[..]) { debug_assert_eq!(result.output, &__ret[..]); if !unconstrained { *result.multiplicity += G::ONE; } } else { record.function_queries[229].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained)); }; + let __ret: [G; OUT_225] = [__v_1]; + if let Some(result) = record.function_queries[225].get_mut(&inp[..]) { debug_assert_eq!(result.output, &__ret[..]); if !unconstrained { *result.multiplicity += G::ONE; } } else { record.function_queries[225].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained)); }; return Ok(__ret); }, 0u64 => { - let __r_arr: [G; OUT_227] = { let __args: [G; IN_227] = [__v_5, __v_6]; let __cu = unconstrained; if let Some(result) = record.function_queries[227].get_mut(&__args[..]) { if !__cu && *result.multiplicity == G::ZERO { aiur_fn_227(__args, record, io_buffer, false)? } else { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_227] = unsafe { *(result.output.as_ptr() as *const [G; OUT_227]) }; __ret } } else { aiur_fn_227(__args, record, io_buffer, __cu)? } }; + let __r_arr: [G; OUT_223] = { let __args: [G; IN_223] = [__v_5, __v_6]; let __cu = unconstrained; if let Some(result) = record.function_queries[223].get_mut(&__args[..]) { if !__cu && *result.multiplicity == G::ZERO { aiur_fn_223(__args, record, io_buffer, false)? } else { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_223] = unsafe { *(result.output.as_ptr() as *const [G; OUT_223]) }; __ret } } else { aiur_fn_223(__args, record, io_buffer, __cu)? } }; let __v_7: G = __r_arr[0]; let __v_8: G = __r_arr[1]; - let __r_arr: [G; OUT_233] = { let __args: [G; IN_233] = [__v_7]; let __cu = unconstrained; if let Some(result) = record.function_queries[233].get_mut(&__args[..]) { if !__cu && *result.multiplicity == G::ZERO { aiur_fn_233(__args, record, io_buffer, false)? } else { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_233] = unsafe { *(result.output.as_ptr() as *const [G; OUT_233]) }; __ret } } else { aiur_fn_233(__args, record, io_buffer, __cu)? } }; + let __r_arr: [G; OUT_229] = { let __args: [G; IN_229] = [__v_7]; let __cu = unconstrained; if let Some(result) = record.function_queries[229].get_mut(&__args[..]) { if !__cu && *result.multiplicity == G::ZERO { aiur_fn_229(__args, record, io_buffer, false)? } else { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_229] = unsafe { *(result.output.as_ptr() as *const [G; OUT_229]) }; __ret } } else { aiur_fn_229(__args, record, io_buffer, __cu)? } }; let __v_9: G = __r_arr[0]; let __v_10: G = G::from_u64(7); let __v_11: G = G::from_u64(0); @@ -21801,13 +21525,13 @@ fn aiur_fn_229( let __v_17: G = G::from_u64(3); let __v_18: G = G::from_u64(0); let __v_19: G = { let __values: [G; 4] = [__v_17, __v_2, __v_16, __v_18]; let __mq = record.memory_queries.get_mut(&4).ok_or(ExecError::InvalidMemorySize(4))?; if let Some(result) = __mq.get_mut(&__values[..]) { if !unconstrained { *result.multiplicity += G::ONE; } result.output[0] } else { let __ptr = G::from_usize(__mq.len()); __mq.insert(&__values[..], &[__ptr], G::from_bool(!unconstrained)); __ptr } }; - let __r_arr: [G; OUT_229] = { let __args: [G; IN_229] = [__v_8, __v_1, __v_2, __v_3]; let __cu = unconstrained; if let Some(result) = record.function_queries[229].get_mut(&__args[..]) { if !__cu && *result.multiplicity == G::ZERO { aiur_fn_229(__args, record, io_buffer, false)? } else { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_229] = unsafe { *(result.output.as_ptr() as *const [G; OUT_229]) }; __ret } } else { aiur_fn_229(__args, record, io_buffer, __cu)? } }; + let __r_arr: [G; OUT_225] = { let __args: [G; IN_225] = [__v_8, __v_1, __v_2, __v_3]; let __cu = unconstrained; if let Some(result) = record.function_queries[225].get_mut(&__args[..]) { if !__cu && *result.multiplicity == G::ZERO { aiur_fn_225(__args, record, io_buffer, false)? } else { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_225] = unsafe { *(result.output.as_ptr() as *const [G; OUT_225]) }; __ret } } else { aiur_fn_225(__args, record, io_buffer, __cu)? } }; let __v_20: G = __r_arr[0]; let __v_21: G = G::from_u64(3); let __v_22: G = G::from_u64(0); let __v_23: G = { let __values: [G; 4] = [__v_21, __v_19, __v_20, __v_22]; let __mq = record.memory_queries.get_mut(&4).ok_or(ExecError::InvalidMemorySize(4))?; if let Some(result) = __mq.get_mut(&__values[..]) { if !unconstrained { *result.multiplicity += G::ONE; } result.output[0] } else { let __ptr = G::from_usize(__mq.len()); __mq.insert(&__values[..], &[__ptr], G::from_bool(!unconstrained)); __ptr } }; - let __ret: [G; OUT_229] = [__v_23]; - if let Some(result) = record.function_queries[229].get_mut(&inp[..]) { debug_assert_eq!(result.output, &__ret[..]); if !unconstrained { *result.multiplicity += G::ONE; } } else { record.function_queries[229].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained)); }; + let __ret: [G; OUT_225] = [__v_23]; + if let Some(result) = record.function_queries[225].get_mut(&inp[..]) { debug_assert_eq!(result.output, &__ret[..]); if !unconstrained { *result.multiplicity += G::ONE; } } else { record.function_queries[225].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained)); }; return Ok(__ret); }, _ => { @@ -21817,15 +21541,15 @@ fn aiur_fn_229( }) } -const INPUT_SIZE_230: usize = 2; -const IN_230: usize = 2; -const OUT_230: usize = 1; -fn aiur_fn_230( - inp: [G; IN_230], +const INPUT_SIZE_226: usize = 2; +const IN_226: usize = 2; +const OUT_226: usize = 1; +fn aiur_fn_226( + inp: [G; IN_226], record: &mut QueryRecord, io_buffer: &mut IOBuffer, unconstrained: bool, -) -> Result<[G; OUT_230], ExecError> { +) -> Result<[G; OUT_226], ExecError> { stacker::maybe_grow(64 * 1024, 4 * 1024 * 1024, || { let __v_0: G = inp[0]; let __v_1: G = inp[1]; @@ -21843,7 +21567,7 @@ fn aiur_fn_230( let __v_9: G = __loaded[3]; match __v_6.as_canonical_u64() { 2u64 => { - let __r_arr: [G; OUT_287] = { let __args: [G; IN_287] = [__v_7]; let __cu = unconstrained; if let Some(result) = record.function_queries[287].get_mut(&__args[..]) { if !__cu && *result.multiplicity == G::ZERO { aiur_fn_287(__args, record, io_buffer, false)? } else { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_287] = unsafe { *(result.output.as_ptr() as *const [G; OUT_287]) }; __ret } } else { aiur_fn_287(__args, record, io_buffer, __cu)? } }; + let __r_arr: [G; OUT_283] = { let __args: [G; IN_283] = [__v_7]; let __cu = unconstrained; if let Some(result) = record.function_queries[283].get_mut(&__args[..]) { if !__cu && *result.multiplicity == G::ZERO { aiur_fn_283(__args, record, io_buffer, false)? } else { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_283] = unsafe { *(result.output.as_ptr() as *const [G; OUT_283]) }; __ret } } else { aiur_fn_283(__args, record, io_buffer, __cu)? } }; let __v_10: G = __r_arr[0]; let __loaded: [G; 12] = { let __mq = record.memory_queries.get_mut(&12).ok_or(ExecError::InvalidMemorySize(12))?; let __ptr_u64 = __v_10.as_canonical_u64(); let __ptr_usize = usize::try_from(__ptr_u64).ok().ok_or(ExecError::PointerTooLarge(__ptr_u64))?; let (__args, __mult) = __mq.get_index_mut(__ptr_usize).ok_or(ExecError::UnboundPointer { ptr: __ptr_u64, size: 12 })?; if !unconstrained { *__mult += G::ONE; } let __arr: [G; 12] = __args[..12].try_into().unwrap(); __arr }; let __v_11: G = __loaded[0]; @@ -21863,7 +21587,7 @@ fn aiur_fn_230( let __v_23: G = G::from_u64(1); let __v_24: G = G::from_u64(1); let __v_25: G = { let __values: [G; 3] = [__v_23, __v_24, __v_24]; let __mq = record.memory_queries.get_mut(&3).ok_or(ExecError::InvalidMemorySize(3))?; if let Some(result) = __mq.get_mut(&__values[..]) { if !unconstrained { *result.multiplicity += G::ONE; } result.output[0] } else { let __ptr = G::from_usize(__mq.len()); __mq.insert(&__values[..], &[__ptr], G::from_bool(!unconstrained)); __ptr } }; - let __r_arr: [G; OUT_336] = { let __args: [G; IN_336] = [__v_14, __v_25]; let __cu = unconstrained; if let Some(result) = record.function_queries[336].get_mut(&__args[..]) { if !__cu && *result.multiplicity == G::ZERO { aiur_fn_336(__args, record, io_buffer, false)? } else { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_336] = unsafe { *(result.output.as_ptr() as *const [G; OUT_336]) }; __ret } } else { aiur_fn_336(__args, record, io_buffer, __cu)? } }; + let __r_arr: [G; OUT_332] = { let __args: [G; IN_332] = [__v_14, __v_25]; let __cu = unconstrained; if let Some(result) = record.function_queries[332].get_mut(&__args[..]) { if !__cu && *result.multiplicity == G::ZERO { aiur_fn_332(__args, record, io_buffer, false)? } else { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_332] = unsafe { *(result.output.as_ptr() as *const [G; OUT_332]) }; __ret } } else { aiur_fn_332(__args, record, io_buffer, __cu)? } }; let __v_26: G = __r_arr[0]; let __loaded: [G; 4] = { let __mq = record.memory_queries.get_mut(&4).ok_or(ExecError::InvalidMemorySize(4))?; let __ptr_u64 = __v_26.as_canonical_u64(); let __ptr_usize = usize::try_from(__ptr_u64).ok().ok_or(ExecError::PointerTooLarge(__ptr_u64))?; let (__args, __mult) = __mq.get_index_mut(__ptr_usize).ok_or(ExecError::UnboundPointer { ptr: __ptr_u64, size: 4 })?; if !unconstrained { *__mult += G::ONE; } let __arr: [G; 4] = __args[..4].try_into().unwrap(); __arr }; let __v_27: G = __loaded[0]; @@ -21873,58 +21597,58 @@ fn aiur_fn_230( match __v_27.as_canonical_u64() { 4u64 => { let __v_31: G = G::from_u64(0); - let __r_arr: [G; OUT_368] = { let __args: [G; IN_368] = [__v_29, __v_4, __v_31]; let __cu = unconstrained; if let Some(result) = record.function_queries[368].get_mut(&__args[..]) { if !__cu && *result.multiplicity == G::ZERO { aiur_fn_368(__args, record, io_buffer, false)? } else { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_368] = unsafe { *(result.output.as_ptr() as *const [G; OUT_368]) }; __ret } } else { aiur_fn_368(__args, record, io_buffer, __cu)? } }; + let __r_arr: [G; OUT_364] = { let __args: [G; IN_364] = [__v_29, __v_4, __v_31]; let __cu = unconstrained; if let Some(result) = record.function_queries[364].get_mut(&__args[..]) { if !__cu && *result.multiplicity == G::ZERO { aiur_fn_364(__args, record, io_buffer, false)? } else { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_364] = unsafe { *(result.output.as_ptr() as *const [G; OUT_364]) }; __ret } } else { aiur_fn_364(__args, record, io_buffer, __cu)? } }; let __v_32: G = __r_arr[0]; - let __r_arr: [G; OUT_424] = { let __args: [G; IN_424] = [__v_32, __v_1]; let __cu = unconstrained; if let Some(result) = record.function_queries[424].get_mut(&__args[..]) { if !__cu && *result.multiplicity == G::ZERO { aiur_fn_424(__args, record, io_buffer, false)? } else { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_424] = unsafe { *(result.output.as_ptr() as *const [G; OUT_424]) }; __ret } } else { aiur_fn_424(__args, record, io_buffer, __cu)? } }; + let __r_arr: [G; OUT_420] = { let __args: [G; IN_420] = [__v_32, __v_1]; let __cu = unconstrained; if let Some(result) = record.function_queries[420].get_mut(&__args[..]) { if !__cu && *result.multiplicity == G::ZERO { aiur_fn_420(__args, record, io_buffer, false)? } else { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_420] = unsafe { *(result.output.as_ptr() as *const [G; OUT_420]) }; __ret } } else { aiur_fn_420(__args, record, io_buffer, __cu)? } }; let __v_33: G = __r_arr[0]; - let __ret: [G; OUT_230] = [__v_33]; - if let Some(result) = record.function_queries[230].get_mut(&inp[..]) { debug_assert_eq!(result.output, &__ret[..]); if !unconstrained { *result.multiplicity += G::ONE; } } else { record.function_queries[230].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained)); }; + let __ret: [G; OUT_226] = [__v_33]; + if let Some(result) = record.function_queries[226].get_mut(&inp[..]) { debug_assert_eq!(result.output, &__ret[..]); if !unconstrained { *result.multiplicity += G::ONE; } } else { record.function_queries[226].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained)); }; return Ok(__ret); }, _ => { let __v_31: G = G::from_u64(3); let __v_32: G = G::from_u64(0); let __v_33: G = { let __values: [G; 4] = [__v_31, __v_26, __v_4, __v_32]; let __mq = record.memory_queries.get_mut(&4).ok_or(ExecError::InvalidMemorySize(4))?; if let Some(result) = __mq.get_mut(&__values[..]) { if !unconstrained { *result.multiplicity += G::ONE; } result.output[0] } else { let __ptr = G::from_usize(__mq.len()); __mq.insert(&__values[..], &[__ptr], G::from_bool(!unconstrained)); __ptr } }; - let __r_arr: [G; OUT_424] = { let __args: [G; IN_424] = [__v_33, __v_1]; let __cu = unconstrained; if let Some(result) = record.function_queries[424].get_mut(&__args[..]) { if !__cu && *result.multiplicity == G::ZERO { aiur_fn_424(__args, record, io_buffer, false)? } else { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_424] = unsafe { *(result.output.as_ptr() as *const [G; OUT_424]) }; __ret } } else { aiur_fn_424(__args, record, io_buffer, __cu)? } }; + let __r_arr: [G; OUT_420] = { let __args: [G; IN_420] = [__v_33, __v_1]; let __cu = unconstrained; if let Some(result) = record.function_queries[420].get_mut(&__args[..]) { if !__cu && *result.multiplicity == G::ZERO { aiur_fn_420(__args, record, io_buffer, false)? } else { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_420] = unsafe { *(result.output.as_ptr() as *const [G; OUT_420]) }; __ret } } else { aiur_fn_420(__args, record, io_buffer, __cu)? } }; let __v_34: G = __r_arr[0]; - let __ret: [G; OUT_230] = [__v_34]; - if let Some(result) = record.function_queries[230].get_mut(&inp[..]) { debug_assert_eq!(result.output, &__ret[..]); if !unconstrained { *result.multiplicity += G::ONE; } } else { record.function_queries[230].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained)); }; + let __ret: [G; OUT_226] = [__v_34]; + if let Some(result) = record.function_queries[226].get_mut(&inp[..]) { debug_assert_eq!(result.output, &__ret[..]); if !unconstrained { *result.multiplicity += G::ONE; } } else { record.function_queries[226].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained)); }; return Ok(__ret); }, } }, _ => { - let __ret: [G; OUT_230] = [__v_0]; - if let Some(result) = record.function_queries[230].get_mut(&inp[..]) { debug_assert_eq!(result.output, &__ret[..]); if !unconstrained { *result.multiplicity += G::ONE; } } else { record.function_queries[230].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained)); }; + let __ret: [G; OUT_226] = [__v_0]; + if let Some(result) = record.function_queries[226].get_mut(&inp[..]) { debug_assert_eq!(result.output, &__ret[..]); if !unconstrained { *result.multiplicity += G::ONE; } } else { record.function_queries[226].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained)); }; return Ok(__ret); }, } }, _ => { - let __ret: [G; OUT_230] = [__v_0]; - if let Some(result) = record.function_queries[230].get_mut(&inp[..]) { debug_assert_eq!(result.output, &__ret[..]); if !unconstrained { *result.multiplicity += G::ONE; } } else { record.function_queries[230].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained)); }; + let __ret: [G; OUT_226] = [__v_0]; + if let Some(result) = record.function_queries[226].get_mut(&inp[..]) { debug_assert_eq!(result.output, &__ret[..]); if !unconstrained { *result.multiplicity += G::ONE; } } else { record.function_queries[226].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained)); }; return Ok(__ret); }, } }, _ => { - let __ret: [G; OUT_230] = [__v_0]; - if let Some(result) = record.function_queries[230].get_mut(&inp[..]) { debug_assert_eq!(result.output, &__ret[..]); if !unconstrained { *result.multiplicity += G::ONE; } } else { record.function_queries[230].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained)); }; + let __ret: [G; OUT_226] = [__v_0]; + if let Some(result) = record.function_queries[226].get_mut(&inp[..]) { debug_assert_eq!(result.output, &__ret[..]); if !unconstrained { *result.multiplicity += G::ONE; } } else { record.function_queries[226].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained)); }; return Ok(__ret); }, } }) } -const INPUT_SIZE_231: usize = 2; -const IN_231: usize = 2; -const OUT_231: usize = 1; -fn aiur_fn_231( - inp: [G; IN_231], +const INPUT_SIZE_227: usize = 2; +const IN_227: usize = 2; +const OUT_227: usize = 1; +fn aiur_fn_227( + inp: [G; IN_227], record: &mut QueryRecord, io_buffer: &mut IOBuffer, unconstrained: bool, -) -> Result<[G; OUT_231], ExecError> { +) -> Result<[G; OUT_227], ExecError> { stacker::maybe_grow(64 * 1024, 4 * 1024 * 1024, || { let __v_0: G = inp[0]; let __v_1: G = inp[1]; @@ -21937,39 +21661,39 @@ fn aiur_fn_231( 7u64 => { match __v_3.as_canonical_u64() { 1u64 => { - let __r_arr: [G; OUT_228] = { let __args: [G; IN_228] = [__v_4]; let __cu = unconstrained; if let Some(result) = record.function_queries[228].get_mut(&__args[..]) { if !__cu && *result.multiplicity == G::ZERO { aiur_fn_228(__args, record, io_buffer, false)? } else { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_228] = unsafe { *(result.output.as_ptr() as *const [G; OUT_228]) }; __ret } } else { aiur_fn_228(__args, record, io_buffer, __cu)? } }; + let __r_arr: [G; OUT_224] = { let __args: [G; IN_224] = [__v_4]; let __cu = unconstrained; if let Some(result) = record.function_queries[224].get_mut(&__args[..]) { if !__cu && *result.multiplicity == G::ZERO { aiur_fn_224(__args, record, io_buffer, false)? } else { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_224] = unsafe { *(result.output.as_ptr() as *const [G; OUT_224]) }; __ret } } else { aiur_fn_224(__args, record, io_buffer, __cu)? } }; let __v_6: G = __r_arr[0]; - let __r_arr: [G; OUT_230] = { let __args: [G; IN_230] = [__v_6, __v_1]; let __cu = unconstrained; if let Some(result) = record.function_queries[230].get_mut(&__args[..]) { if !__cu && *result.multiplicity == G::ZERO { aiur_fn_230(__args, record, io_buffer, false)? } else { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_230] = unsafe { *(result.output.as_ptr() as *const [G; OUT_230]) }; __ret } } else { aiur_fn_230(__args, record, io_buffer, __cu)? } }; + let __r_arr: [G; OUT_226] = { let __args: [G; IN_226] = [__v_6, __v_1]; let __cu = unconstrained; if let Some(result) = record.function_queries[226].get_mut(&__args[..]) { if !__cu && *result.multiplicity == G::ZERO { aiur_fn_226(__args, record, io_buffer, false)? } else { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_226] = unsafe { *(result.output.as_ptr() as *const [G; OUT_226]) }; __ret } } else { aiur_fn_226(__args, record, io_buffer, __cu)? } }; let __v_7: G = __r_arr[0]; - let __ret: [G; OUT_231] = [__v_7]; - if let Some(result) = record.function_queries[231].get_mut(&inp[..]) { debug_assert_eq!(result.output, &__ret[..]); if !unconstrained { *result.multiplicity += G::ONE; } } else { record.function_queries[231].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained)); }; + let __ret: [G; OUT_227] = [__v_7]; + if let Some(result) = record.function_queries[227].get_mut(&inp[..]) { debug_assert_eq!(result.output, &__ret[..]); if !unconstrained { *result.multiplicity += G::ONE; } } else { record.function_queries[227].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained)); }; return Ok(__ret); }, _ => { - let __ret: [G; OUT_231] = [__v_0]; - if let Some(result) = record.function_queries[231].get_mut(&inp[..]) { debug_assert_eq!(result.output, &__ret[..]); if !unconstrained { *result.multiplicity += G::ONE; } } else { record.function_queries[231].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained)); }; + let __ret: [G; OUT_227] = [__v_0]; + if let Some(result) = record.function_queries[227].get_mut(&inp[..]) { debug_assert_eq!(result.output, &__ret[..]); if !unconstrained { *result.multiplicity += G::ONE; } } else { record.function_queries[227].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained)); }; return Ok(__ret); }, } }, _ => { - let __ret: [G; OUT_231] = [__v_0]; - if let Some(result) = record.function_queries[231].get_mut(&inp[..]) { debug_assert_eq!(result.output, &__ret[..]); if !unconstrained { *result.multiplicity += G::ONE; } } else { record.function_queries[231].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained)); }; + let __ret: [G; OUT_227] = [__v_0]; + if let Some(result) = record.function_queries[227].get_mut(&inp[..]) { debug_assert_eq!(result.output, &__ret[..]); if !unconstrained { *result.multiplicity += G::ONE; } } else { record.function_queries[227].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained)); }; return Ok(__ret); }, } }) } -const INPUT_SIZE_232: usize = 1; -const IN_232: usize = 1; -const OUT_232: usize = 4; -fn aiur_fn_232( - inp: [G; IN_232], +const INPUT_SIZE_228: usize = 1; +const IN_228: usize = 1; +const OUT_228: usize = 4; +fn aiur_fn_228( + inp: [G; IN_228], record: &mut QueryRecord, io_buffer: &mut IOBuffer, unconstrained: bool, -) -> Result<[G; OUT_232], ExecError> { +) -> Result<[G; OUT_228], ExecError> { stacker::maybe_grow(64 * 1024, 4 * 1024 * 1024, || { let __v_0: G = inp[0]; let __v_1: G = G::from_u64(0); @@ -21988,24 +21712,24 @@ fn aiur_fn_232( let __r_arr: [G; OUT_122] = { let __args: [G; IN_122] = [__v_9, __v_10]; let __cu = unconstrained; if let Some(result) = record.function_queries[122].get_mut(&__args[..]) { if !__cu && *result.multiplicity == G::ZERO { aiur_fn_122(__args, record, io_buffer, false)? } else { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_122] = unsafe { *(result.output.as_ptr() as *const [G; OUT_122]) }; __ret } } else { aiur_fn_122(__args, record, io_buffer, __cu)? } }; let __v_11: G = __r_arr[0]; let __v_12: G = __r_arr[1]; - let __ret: [G; OUT_232] = [__v_2, __v_5, __v_8, __v_11]; - if let Some(result) = record.function_queries[232].get_mut(&inp[..]) { debug_assert_eq!(result.output, &__ret[..]); if !unconstrained { *result.multiplicity += G::ONE; } } else { record.function_queries[232].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained)); }; + let __ret: [G; OUT_228] = [__v_2, __v_5, __v_8, __v_11]; + if let Some(result) = record.function_queries[228].get_mut(&inp[..]) { debug_assert_eq!(result.output, &__ret[..]); if !unconstrained { *result.multiplicity += G::ONE; } } else { record.function_queries[228].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained)); }; return Ok(__ret); }) } -const INPUT_SIZE_233: usize = 1; -const IN_233: usize = 1; -const OUT_233: usize = 1; -fn aiur_fn_233( - inp: [G; IN_233], +const INPUT_SIZE_229: usize = 1; +const IN_229: usize = 1; +const OUT_229: usize = 1; +fn aiur_fn_229( + inp: [G; IN_229], record: &mut QueryRecord, io_buffer: &mut IOBuffer, unconstrained: bool, -) -> Result<[G; OUT_233], ExecError> { +) -> Result<[G; OUT_229], ExecError> { stacker::maybe_grow(64 * 1024, 4 * 1024 * 1024, || { let __v_0: G = inp[0]; - let __r_arr: [G; OUT_232] = { let __args: [G; IN_232] = [__v_0]; let __cu = true; if let Some(result) = record.function_queries[232].get_mut(&__args[..]) { if !__cu && *result.multiplicity == G::ZERO { aiur_fn_232(__args, record, io_buffer, false)? } else { let __ret: [G; OUT_232] = unsafe { *(result.output.as_ptr() as *const [G; OUT_232]) }; __ret } } else { aiur_fn_232(__args, record, io_buffer, __cu)? } }; + let __r_arr: [G; OUT_228] = { let __args: [G; IN_228] = [__v_0]; let __cu = true; if let Some(result) = record.function_queries[228].get_mut(&__args[..]) { if !__cu && *result.multiplicity == G::ZERO { aiur_fn_228(__args, record, io_buffer, false)? } else { let __ret: [G; OUT_228] = unsafe { *(result.output.as_ptr() as *const [G; OUT_228]) }; __ret } } else { aiur_fn_228(__args, record, io_buffer, __cu)? } }; let __v_1: G = __r_arr[0]; let __v_2: G = __r_arr[1]; let __v_3: G = __r_arr[2]; @@ -22039,25 +21763,27 @@ fn aiur_fn_233( let __v_28: G = G::from_u64(1); let __v_29: G = { let __values: [G; 10] = [__v_27, __v_28, __v_28, __v_28, __v_28, __v_28, __v_28, __v_28, __v_28, __v_28]; let __mq = record.memory_queries.get_mut(&10).ok_or(ExecError::InvalidMemorySize(10))?; if let Some(result) = __mq.get_mut(&__values[..]) { if !unconstrained { *result.multiplicity += G::ONE; } result.output[0] } else { let __ptr = G::from_usize(__mq.len()); __mq.insert(&__values[..], &[__ptr], G::from_bool(!unconstrained)); __ptr } }; let __v_30: G = { let __values: [G; 10] = [__v_22, __v_6, __v_8, __v_10, __v_12, __v_23, __v_24, __v_25, __v_26, __v_29]; let __mq = record.memory_queries.get_mut(&10).ok_or(ExecError::InvalidMemorySize(10))?; if let Some(result) = __mq.get_mut(&__values[..]) { if !unconstrained { *result.multiplicity += G::ONE; } result.output[0] } else { let __ptr = G::from_usize(__mq.len()); __mq.insert(&__values[..], &[__ptr], G::from_bool(!unconstrained)); __ptr } }; - let __ret: [G; OUT_233] = [__v_30]; - if let Some(result) = record.function_queries[233].get_mut(&inp[..]) { debug_assert_eq!(result.output, &__ret[..]); if !unconstrained { *result.multiplicity += G::ONE; } } else { record.function_queries[233].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained)); }; + let __r_arr: [G; OUT_118] = { let __args: [G; IN_118] = [__v_30]; let __cu = unconstrained; if let Some(result) = record.function_queries[118].get_mut(&__args[..]) { if !__cu && *result.multiplicity == G::ZERO { aiur_fn_118(__args, record, io_buffer, false)? } else { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_118] = unsafe { *(result.output.as_ptr() as *const [G; OUT_118]) }; __ret } } else { aiur_fn_118(__args, record, io_buffer, __cu)? } }; + let __v_31: G = __r_arr[0]; + let __ret: [G; OUT_229] = [__v_31]; + if let Some(result) = record.function_queries[229].get_mut(&inp[..]) { debug_assert_eq!(result.output, &__ret[..]); if !unconstrained { *result.multiplicity += G::ONE; } } else { record.function_queries[229].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained)); }; return Ok(__ret); }) } -const INPUT_SIZE_234: usize = 2; -const IN_234: usize = 2; -const OUT_234: usize = 2; -fn aiur_fn_234( - inp: [G; IN_234], +const INPUT_SIZE_230: usize = 2; +const IN_230: usize = 2; +const OUT_230: usize = 2; +fn aiur_fn_230( + inp: [G; IN_230], record: &mut QueryRecord, io_buffer: &mut IOBuffer, unconstrained: bool, -) -> Result<[G; OUT_234], ExecError> { +) -> Result<[G; OUT_230], ExecError> { stacker::maybe_grow(64 * 1024, 4 * 1024 * 1024, || { let __v_0: G = inp[0]; let __v_1: G = inp[1]; - let __r_arr: [G; OUT_418] = { let __args: [G; IN_418] = [__v_0, __v_1]; let __cu = unconstrained; if let Some(result) = record.function_queries[418].get_mut(&__args[..]) { if !__cu && *result.multiplicity == G::ZERO { aiur_fn_418(__args, record, io_buffer, false)? } else { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_418] = unsafe { *(result.output.as_ptr() as *const [G; OUT_418]) }; __ret } } else { aiur_fn_418(__args, record, io_buffer, __cu)? } }; + let __r_arr: [G; OUT_414] = { let __args: [G; IN_414] = [__v_0, __v_1]; let __cu = unconstrained; if let Some(result) = record.function_queries[414].get_mut(&__args[..]) { if !__cu && *result.multiplicity == G::ZERO { aiur_fn_414(__args, record, io_buffer, false)? } else { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_414] = unsafe { *(result.output.as_ptr() as *const [G; OUT_414]) }; __ret } } else { aiur_fn_414(__args, record, io_buffer, __cu)? } }; let __v_2: G = __r_arr[0]; let __r_arr: [G; OUT_111] = { let __args: [G; IN_111] = [__v_2]; let __cu = unconstrained; if let Some(result) = record.function_queries[111].get_mut(&__args[..]) { if !__cu && *result.multiplicity == G::ZERO { aiur_fn_111(__args, record, io_buffer, false)? } else { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_111] = unsafe { *(result.output.as_ptr() as *const [G; OUT_111]) }; __ret } } else { aiur_fn_111(__args, record, io_buffer, __cu)? } }; let __v_3: G = __r_arr[0]; @@ -22069,13 +21795,13 @@ fn aiur_fn_234( let __v_8: G = __loaded[3]; match __v_5.as_canonical_u64() { 2u64 => { - let __r_arr: [G; OUT_210] = { let __args: [G; IN_210] = []; let __cu = unconstrained; if let Some(result) = record.function_queries[210].get_mut(&__args[..]) { if !__cu && *result.multiplicity == G::ZERO { aiur_fn_210(__args, record, io_buffer, false)? } else { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_210] = unsafe { *(result.output.as_ptr() as *const [G; OUT_210]) }; __ret } } else { aiur_fn_210(__args, record, io_buffer, __cu)? } }; + let __r_arr: [G; OUT_206] = { let __args: [G; IN_206] = []; let __cu = unconstrained; if let Some(result) = record.function_queries[206].get_mut(&__args[..]) { if !__cu && *result.multiplicity == G::ZERO { aiur_fn_206(__args, record, io_buffer, false)? } else { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_206] = unsafe { *(result.output.as_ptr() as *const [G; OUT_206]) }; __ret } } else { aiur_fn_206(__args, record, io_buffer, __cu)? } }; let __v_9: G = __r_arr[0]; let __r_arr: [G; OUT_1] = { let __args: [G; IN_1] = [__v_6, __v_9]; let __cu = unconstrained; if let Some(result) = record.function_queries[1].get_mut(&__args[..]) { if !__cu && *result.multiplicity == G::ZERO { aiur_fn_1(__args, record, io_buffer, false)? } else { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_1] = unsafe { *(result.output.as_ptr() as *const [G; OUT_1]) }; __ret } } else { aiur_fn_1(__args, record, io_buffer, __cu)? } }; let __v_10: G = __r_arr[0]; match __v_10.as_canonical_u64() { 1u64 => { - let __r_arr: [G; OUT_764] = { let __args: [G; IN_764] = [__v_4]; let __cu = unconstrained; if let Some(result) = record.function_queries[764].get_mut(&__args[..]) { if !__cu && *result.multiplicity == G::ZERO { aiur_fn_764(__args, record, io_buffer, false)? } else { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_764] = unsafe { *(result.output.as_ptr() as *const [G; OUT_764]) }; __ret } } else { aiur_fn_764(__args, record, io_buffer, __cu)? } }; + let __r_arr: [G; OUT_760] = { let __args: [G; IN_760] = [__v_4]; let __cu = unconstrained; if let Some(result) = record.function_queries[760].get_mut(&__args[..]) { if !__cu && *result.multiplicity == G::ZERO { aiur_fn_760(__args, record, io_buffer, false)? } else { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_760] = unsafe { *(result.output.as_ptr() as *const [G; OUT_760]) }; __ret } } else { aiur_fn_760(__args, record, io_buffer, __cu)? } }; let __v_11: G = __r_arr[0]; match __v_11.as_canonical_u64() { 1u64 => { @@ -22083,8 +21809,8 @@ fn aiur_fn_234( let __v_13: G = G::from_u64(1); let __v_14: G = G::from_u64(1); let __v_15: G = { let __values: [G; 3] = [__v_13, __v_14, __v_14]; let __mq = record.memory_queries.get_mut(&3).ok_or(ExecError::InvalidMemorySize(3))?; if let Some(result) = __mq.get_mut(&__values[..]) { if !unconstrained { *result.multiplicity += G::ONE; } result.output[0] } else { let __ptr = G::from_usize(__mq.len()); __mq.insert(&__values[..], &[__ptr], G::from_bool(!unconstrained)); __ptr } }; - let __ret: [G; OUT_234] = [__v_12, __v_15]; - if let Some(result) = record.function_queries[234].get_mut(&inp[..]) { debug_assert_eq!(result.output, &__ret[..]); if !unconstrained { *result.multiplicity += G::ONE; } } else { record.function_queries[234].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained)); }; + let __ret: [G; OUT_230] = [__v_12, __v_15]; + if let Some(result) = record.function_queries[230].get_mut(&inp[..]) { debug_assert_eq!(result.output, &__ret[..]); if !unconstrained { *result.multiplicity += G::ONE; } } else { record.function_queries[230].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained)); }; return Ok(__ret); }, _ => { @@ -22092,14 +21818,14 @@ fn aiur_fn_234( let __v_13: G = G::from_u64(1); let __v_14: G = G::from_u64(1); let __v_15: G = { let __values: [G; 3] = [__v_13, __v_14, __v_14]; let __mq = record.memory_queries.get_mut(&3).ok_or(ExecError::InvalidMemorySize(3))?; if let Some(result) = __mq.get_mut(&__values[..]) { if !unconstrained { *result.multiplicity += G::ONE; } result.output[0] } else { let __ptr = G::from_usize(__mq.len()); __mq.insert(&__values[..], &[__ptr], G::from_bool(!unconstrained)); __ptr } }; - let __ret: [G; OUT_234] = [__v_12, __v_15]; - if let Some(result) = record.function_queries[234].get_mut(&inp[..]) { debug_assert_eq!(result.output, &__ret[..]); if !unconstrained { *result.multiplicity += G::ONE; } } else { record.function_queries[234].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained)); }; + let __ret: [G; OUT_230] = [__v_12, __v_15]; + if let Some(result) = record.function_queries[230].get_mut(&inp[..]) { debug_assert_eq!(result.output, &__ret[..]); if !unconstrained { *result.multiplicity += G::ONE; } } else { record.function_queries[230].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained)); }; return Ok(__ret); }, } }, _ => { - let __r_arr: [G; OUT_211] = { let __args: [G; IN_211] = []; let __cu = unconstrained; if let Some(result) = record.function_queries[211].get_mut(&__args[..]) { if !__cu && *result.multiplicity == G::ZERO { aiur_fn_211(__args, record, io_buffer, false)? } else { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_211] = unsafe { *(result.output.as_ptr() as *const [G; OUT_211]) }; __ret } } else { aiur_fn_211(__args, record, io_buffer, __cu)? } }; + let __r_arr: [G; OUT_207] = { let __args: [G; IN_207] = []; let __cu = unconstrained; if let Some(result) = record.function_queries[207].get_mut(&__args[..]) { if !__cu && *result.multiplicity == G::ZERO { aiur_fn_207(__args, record, io_buffer, false)? } else { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_207] = unsafe { *(result.output.as_ptr() as *const [G; OUT_207]) }; __ret } } else { aiur_fn_207(__args, record, io_buffer, __cu)? } }; let __v_11: G = __r_arr[0]; let __r_arr: [G; OUT_1] = { let __args: [G; IN_1] = [__v_6, __v_11]; let __cu = unconstrained; if let Some(result) = record.function_queries[1].get_mut(&__args[..]) { if !__cu && *result.multiplicity == G::ZERO { aiur_fn_1(__args, record, io_buffer, false)? } else { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_1] = unsafe { *(result.output.as_ptr() as *const [G; OUT_1]) }; __ret } } else { aiur_fn_1(__args, record, io_buffer, __cu)? } }; let __v_12: G = __r_arr[0]; @@ -22109,19 +21835,19 @@ fn aiur_fn_234( let __v_14: G = G::from_u64(1); let __v_15: G = G::from_u64(1); let __v_16: G = { let __values: [G; 3] = [__v_14, __v_15, __v_15]; let __mq = record.memory_queries.get_mut(&3).ok_or(ExecError::InvalidMemorySize(3))?; if let Some(result) = __mq.get_mut(&__values[..]) { if !unconstrained { *result.multiplicity += G::ONE; } result.output[0] } else { let __ptr = G::from_usize(__mq.len()); __mq.insert(&__values[..], &[__ptr], G::from_bool(!unconstrained)); __ptr } }; - let __ret: [G; OUT_234] = [__v_13, __v_16]; - if let Some(result) = record.function_queries[234].get_mut(&inp[..]) { debug_assert_eq!(result.output, &__ret[..]); if !unconstrained { *result.multiplicity += G::ONE; } } else { record.function_queries[234].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained)); }; + let __ret: [G; OUT_230] = [__v_13, __v_16]; + if let Some(result) = record.function_queries[230].get_mut(&inp[..]) { debug_assert_eq!(result.output, &__ret[..]); if !unconstrained { *result.multiplicity += G::ONE; } } else { record.function_queries[230].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained)); }; return Ok(__ret); }, _ => { - let __r_arr: [G; OUT_764] = { let __args: [G; IN_764] = [__v_4]; let __cu = unconstrained; if let Some(result) = record.function_queries[764].get_mut(&__args[..]) { if !__cu && *result.multiplicity == G::ZERO { aiur_fn_764(__args, record, io_buffer, false)? } else { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_764] = unsafe { *(result.output.as_ptr() as *const [G; OUT_764]) }; __ret } } else { aiur_fn_764(__args, record, io_buffer, __cu)? } }; + let __r_arr: [G; OUT_760] = { let __args: [G; IN_760] = [__v_4]; let __cu = unconstrained; if let Some(result) = record.function_queries[760].get_mut(&__args[..]) { if !__cu && *result.multiplicity == G::ZERO { aiur_fn_760(__args, record, io_buffer, false)? } else { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_760] = unsafe { *(result.output.as_ptr() as *const [G; OUT_760]) }; __ret } } else { aiur_fn_760(__args, record, io_buffer, __cu)? } }; let __v_13: G = __r_arr[0]; match __v_13.as_canonical_u64() { 3u64 => { let __v_14: G = G::from_u64(1); - let __r_arr: [G; OUT_766] = { let __args: [G; IN_766] = [__v_4, __v_14]; let __cu = unconstrained; if let Some(result) = record.function_queries[766].get_mut(&__args[..]) { if !__cu && *result.multiplicity == G::ZERO { aiur_fn_766(__args, record, io_buffer, false)? } else { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_766] = unsafe { *(result.output.as_ptr() as *const [G; OUT_766]) }; __ret } } else { aiur_fn_766(__args, record, io_buffer, __cu)? } }; + let __r_arr: [G; OUT_762] = { let __args: [G; IN_762] = [__v_4, __v_14]; let __cu = unconstrained; if let Some(result) = record.function_queries[762].get_mut(&__args[..]) { if !__cu && *result.multiplicity == G::ZERO { aiur_fn_762(__args, record, io_buffer, false)? } else { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_762] = unsafe { *(result.output.as_ptr() as *const [G; OUT_762]) }; __ret } } else { aiur_fn_762(__args, record, io_buffer, __cu)? } }; let __v_15: G = __r_arr[0]; - let __r_arr: [G; OUT_235] = { let __args: [G; IN_235] = [__v_15, __v_1]; let __cu = unconstrained; if let Some(result) = record.function_queries[235].get_mut(&__args[..]) { if !__cu && *result.multiplicity == G::ZERO { aiur_fn_235(__args, record, io_buffer, false)? } else { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_235] = unsafe { *(result.output.as_ptr() as *const [G; OUT_235]) }; __ret } } else { aiur_fn_235(__args, record, io_buffer, __cu)? } }; + let __r_arr: [G; OUT_231] = { let __args: [G; IN_231] = [__v_15, __v_1]; let __cu = unconstrained; if let Some(result) = record.function_queries[231].get_mut(&__args[..]) { if !__cu && *result.multiplicity == G::ZERO { aiur_fn_231(__args, record, io_buffer, false)? } else { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_231] = unsafe { *(result.output.as_ptr() as *const [G; OUT_231]) }; __ret } } else { aiur_fn_231(__args, record, io_buffer, __cu)? } }; let __v_16: G = __r_arr[0]; let __v_17: G = __r_arr[1]; match __v_16.as_canonical_u64() { @@ -22130,30 +21856,30 @@ fn aiur_fn_234( let __v_19: G = G::from_u64(1); let __v_20: G = G::from_u64(1); let __v_21: G = { let __values: [G; 3] = [__v_19, __v_20, __v_20]; let __mq = record.memory_queries.get_mut(&3).ok_or(ExecError::InvalidMemorySize(3))?; if let Some(result) = __mq.get_mut(&__values[..]) { if !unconstrained { *result.multiplicity += G::ONE; } result.output[0] } else { let __ptr = G::from_usize(__mq.len()); __mq.insert(&__values[..], &[__ptr], G::from_bool(!unconstrained)); __ptr } }; - let __ret: [G; OUT_234] = [__v_18, __v_21]; - if let Some(result) = record.function_queries[234].get_mut(&inp[..]) { debug_assert_eq!(result.output, &__ret[..]); if !unconstrained { *result.multiplicity += G::ONE; } } else { record.function_queries[234].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained)); }; + let __ret: [G; OUT_230] = [__v_18, __v_21]; + if let Some(result) = record.function_queries[230].get_mut(&inp[..]) { debug_assert_eq!(result.output, &__ret[..]); if !unconstrained { *result.multiplicity += G::ONE; } } else { record.function_queries[230].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained)); }; return Ok(__ret); }, 1u64 => { let __v_18: G = G::from_u64(2); - let __r_arr: [G; OUT_766] = { let __args: [G; IN_766] = [__v_4, __v_18]; let __cu = unconstrained; if let Some(result) = record.function_queries[766].get_mut(&__args[..]) { if !__cu && *result.multiplicity == G::ZERO { aiur_fn_766(__args, record, io_buffer, false)? } else { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_766] = unsafe { *(result.output.as_ptr() as *const [G; OUT_766]) }; __ret } } else { aiur_fn_766(__args, record, io_buffer, __cu)? } }; + let __r_arr: [G; OUT_762] = { let __args: [G; IN_762] = [__v_4, __v_18]; let __cu = unconstrained; if let Some(result) = record.function_queries[762].get_mut(&__args[..]) { if !__cu && *result.multiplicity == G::ZERO { aiur_fn_762(__args, record, io_buffer, false)? } else { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_762] = unsafe { *(result.output.as_ptr() as *const [G; OUT_762]) }; __ret } } else { aiur_fn_762(__args, record, io_buffer, __cu)? } }; let __v_19: G = __r_arr[0]; - let __r_arr: [G; OUT_234] = { let __args: [G; IN_234] = [__v_19, __v_1]; let __cu = unconstrained; if let Some(result) = record.function_queries[234].get_mut(&__args[..]) { if !__cu && *result.multiplicity == G::ZERO { aiur_fn_234(__args, record, io_buffer, false)? } else { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_234] = unsafe { *(result.output.as_ptr() as *const [G; OUT_234]) }; __ret } } else { aiur_fn_234(__args, record, io_buffer, __cu)? } }; + let __r_arr: [G; OUT_230] = { let __args: [G; IN_230] = [__v_19, __v_1]; let __cu = unconstrained; if let Some(result) = record.function_queries[230].get_mut(&__args[..]) { if !__cu && *result.multiplicity == G::ZERO { aiur_fn_230(__args, record, io_buffer, false)? } else { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_230] = unsafe { *(result.output.as_ptr() as *const [G; OUT_230]) }; __ret } } else { aiur_fn_230(__args, record, io_buffer, __cu)? } }; let __v_20: G = __r_arr[0]; let __v_21: G = __r_arr[1]; match __v_20.as_canonical_u64() { 0u64 => { let __v_22: G = G::from_u64(0); - let __ret: [G; OUT_234] = [__v_22, __v_21]; - if let Some(result) = record.function_queries[234].get_mut(&inp[..]) { debug_assert_eq!(result.output, &__ret[..]); if !unconstrained { *result.multiplicity += G::ONE; } } else { record.function_queries[234].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained)); }; + let __ret: [G; OUT_230] = [__v_22, __v_21]; + if let Some(result) = record.function_queries[230].get_mut(&inp[..]) { debug_assert_eq!(result.output, &__ret[..]); if !unconstrained { *result.multiplicity += G::ONE; } } else { record.function_queries[230].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained)); }; return Ok(__ret); }, 1u64 => { let __v_22: G = G::from_u64(1); - let __r_arr: [G; OUT_240] = { let __args: [G; IN_240] = [__v_17, __v_21]; let __cu = unconstrained; if let Some(result) = record.function_queries[240].get_mut(&__args[..]) { if !__cu && *result.multiplicity == G::ZERO { aiur_fn_240(__args, record, io_buffer, false)? } else { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_240] = unsafe { *(result.output.as_ptr() as *const [G; OUT_240]) }; __ret } } else { aiur_fn_240(__args, record, io_buffer, __cu)? } }; + let __r_arr: [G; OUT_236] = { let __args: [G; IN_236] = [__v_17, __v_21]; let __cu = unconstrained; if let Some(result) = record.function_queries[236].get_mut(&__args[..]) { if !__cu && *result.multiplicity == G::ZERO { aiur_fn_236(__args, record, io_buffer, false)? } else { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_236] = unsafe { *(result.output.as_ptr() as *const [G; OUT_236]) }; __ret } } else { aiur_fn_236(__args, record, io_buffer, __cu)? } }; let __v_23: G = __r_arr[0]; - let __ret: [G; OUT_234] = [__v_22, __v_23]; - if let Some(result) = record.function_queries[234].get_mut(&inp[..]) { debug_assert_eq!(result.output, &__ret[..]); if !unconstrained { *result.multiplicity += G::ONE; } } else { record.function_queries[234].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained)); }; + let __ret: [G; OUT_230] = [__v_22, __v_23]; + if let Some(result) = record.function_queries[230].get_mut(&inp[..]) { debug_assert_eq!(result.output, &__ret[..]); if !unconstrained { *result.multiplicity += G::ONE; } } else { record.function_queries[230].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained)); }; return Ok(__ret); }, _ => { @@ -22171,8 +21897,8 @@ fn aiur_fn_234( let __v_15: G = G::from_u64(1); let __v_16: G = G::from_u64(1); let __v_17: G = { let __values: [G; 3] = [__v_15, __v_16, __v_16]; let __mq = record.memory_queries.get_mut(&3).ok_or(ExecError::InvalidMemorySize(3))?; if let Some(result) = __mq.get_mut(&__values[..]) { if !unconstrained { *result.multiplicity += G::ONE; } result.output[0] } else { let __ptr = G::from_usize(__mq.len()); __mq.insert(&__values[..], &[__ptr], G::from_bool(!unconstrained)); __ptr } }; - let __ret: [G; OUT_234] = [__v_14, __v_17]; - if let Some(result) = record.function_queries[234].get_mut(&inp[..]) { debug_assert_eq!(result.output, &__ret[..]); if !unconstrained { *result.multiplicity += G::ONE; } } else { record.function_queries[234].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained)); }; + let __ret: [G; OUT_230] = [__v_14, __v_17]; + if let Some(result) = record.function_queries[230].get_mut(&inp[..]) { debug_assert_eq!(result.output, &__ret[..]); if !unconstrained { *result.multiplicity += G::ONE; } } else { record.function_queries[230].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained)); }; return Ok(__ret); }, } @@ -22186,59 +21912,59 @@ fn aiur_fn_234( let __v_10: G = G::from_u64(1); let __v_11: G = G::from_u64(1); let __v_12: G = { let __values: [G; 3] = [__v_10, __v_11, __v_11]; let __mq = record.memory_queries.get_mut(&3).ok_or(ExecError::InvalidMemorySize(3))?; if let Some(result) = __mq.get_mut(&__values[..]) { if !unconstrained { *result.multiplicity += G::ONE; } result.output[0] } else { let __ptr = G::from_usize(__mq.len()); __mq.insert(&__values[..], &[__ptr], G::from_bool(!unconstrained)); __ptr } }; - let __ret: [G; OUT_234] = [__v_9, __v_12]; - if let Some(result) = record.function_queries[234].get_mut(&inp[..]) { debug_assert_eq!(result.output, &__ret[..]); if !unconstrained { *result.multiplicity += G::ONE; } } else { record.function_queries[234].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained)); }; + let __ret: [G; OUT_230] = [__v_9, __v_12]; + if let Some(result) = record.function_queries[230].get_mut(&inp[..]) { debug_assert_eq!(result.output, &__ret[..]); if !unconstrained { *result.multiplicity += G::ONE; } } else { record.function_queries[230].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained)); }; return Ok(__ret); }, } }) } -const INPUT_SIZE_235: usize = 2; -const IN_235: usize = 2; -const OUT_235: usize = 2; -fn aiur_fn_235( - inp: [G; IN_235], +const INPUT_SIZE_231: usize = 2; +const IN_231: usize = 2; +const OUT_231: usize = 2; +fn aiur_fn_231( + inp: [G; IN_231], record: &mut QueryRecord, io_buffer: &mut IOBuffer, unconstrained: bool, -) -> Result<[G; OUT_235], ExecError> { +) -> Result<[G; OUT_231], ExecError> { stacker::maybe_grow(64 * 1024, 4 * 1024 * 1024, || { let __v_0: G = inp[0]; let __v_1: G = inp[1]; - let __r_arr: [G; OUT_236] = { let __args: [G; IN_236] = [__v_0]; let __cu = unconstrained; if let Some(result) = record.function_queries[236].get_mut(&__args[..]) { if !__cu && *result.multiplicity == G::ZERO { aiur_fn_236(__args, record, io_buffer, false)? } else { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_236] = unsafe { *(result.output.as_ptr() as *const [G; OUT_236]) }; __ret } } else { aiur_fn_236(__args, record, io_buffer, __cu)? } }; + let __r_arr: [G; OUT_232] = { let __args: [G; IN_232] = [__v_0]; let __cu = unconstrained; if let Some(result) = record.function_queries[232].get_mut(&__args[..]) { if !__cu && *result.multiplicity == G::ZERO { aiur_fn_232(__args, record, io_buffer, false)? } else { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_232] = unsafe { *(result.output.as_ptr() as *const [G; OUT_232]) }; __ret } } else { aiur_fn_232(__args, record, io_buffer, __cu)? } }; let __v_2: G = __r_arr[0]; let __v_3: G = __r_arr[1]; match __v_2.as_canonical_u64() { 1u64 => { let __v_4: G = G::from_u64(1); - let __ret: [G; OUT_235] = [__v_4, __v_3]; - if let Some(result) = record.function_queries[235].get_mut(&inp[..]) { debug_assert_eq!(result.output, &__ret[..]); if !unconstrained { *result.multiplicity += G::ONE; } } else { record.function_queries[235].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained)); }; + let __ret: [G; OUT_231] = [__v_4, __v_3]; + if let Some(result) = record.function_queries[231].get_mut(&inp[..]) { debug_assert_eq!(result.output, &__ret[..]); if !unconstrained { *result.multiplicity += G::ONE; } } else { record.function_queries[231].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained)); }; return Ok(__ret); }, _ => { - let __r_arr: [G; OUT_418] = { let __args: [G; IN_418] = [__v_0, __v_1]; let __cu = unconstrained; if let Some(result) = record.function_queries[418].get_mut(&__args[..]) { if !__cu && *result.multiplicity == G::ZERO { aiur_fn_418(__args, record, io_buffer, false)? } else { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_418] = unsafe { *(result.output.as_ptr() as *const [G; OUT_418]) }; __ret } } else { aiur_fn_418(__args, record, io_buffer, __cu)? } }; + let __r_arr: [G; OUT_414] = { let __args: [G; IN_414] = [__v_0, __v_1]; let __cu = unconstrained; if let Some(result) = record.function_queries[414].get_mut(&__args[..]) { if !__cu && *result.multiplicity == G::ZERO { aiur_fn_414(__args, record, io_buffer, false)? } else { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_414] = unsafe { *(result.output.as_ptr() as *const [G; OUT_414]) }; __ret } } else { aiur_fn_414(__args, record, io_buffer, __cu)? } }; let __v_4: G = __r_arr[0]; - let __r_arr: [G; OUT_236] = { let __args: [G; IN_236] = [__v_4]; let __cu = unconstrained; if let Some(result) = record.function_queries[236].get_mut(&__args[..]) { if !__cu && *result.multiplicity == G::ZERO { aiur_fn_236(__args, record, io_buffer, false)? } else { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_236] = unsafe { *(result.output.as_ptr() as *const [G; OUT_236]) }; __ret } } else { aiur_fn_236(__args, record, io_buffer, __cu)? } }; + let __r_arr: [G; OUT_232] = { let __args: [G; IN_232] = [__v_4]; let __cu = unconstrained; if let Some(result) = record.function_queries[232].get_mut(&__args[..]) { if !__cu && *result.multiplicity == G::ZERO { aiur_fn_232(__args, record, io_buffer, false)? } else { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_232] = unsafe { *(result.output.as_ptr() as *const [G; OUT_232]) }; __ret } } else { aiur_fn_232(__args, record, io_buffer, __cu)? } }; let __v_5: G = __r_arr[0]; let __v_6: G = __r_arr[1]; - let __ret: [G; OUT_235] = [__v_5, __v_6]; - if let Some(result) = record.function_queries[235].get_mut(&inp[..]) { debug_assert_eq!(result.output, &__ret[..]); if !unconstrained { *result.multiplicity += G::ONE; } } else { record.function_queries[235].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained)); }; + let __ret: [G; OUT_231] = [__v_5, __v_6]; + if let Some(result) = record.function_queries[231].get_mut(&inp[..]) { debug_assert_eq!(result.output, &__ret[..]); if !unconstrained { *result.multiplicity += G::ONE; } } else { record.function_queries[231].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained)); }; return Ok(__ret); }, } }) } -const INPUT_SIZE_236: usize = 1; -const IN_236: usize = 1; -const OUT_236: usize = 2; -fn aiur_fn_236( - inp: [G; IN_236], +const INPUT_SIZE_232: usize = 1; +const IN_232: usize = 1; +const OUT_232: usize = 2; +fn aiur_fn_232( + inp: [G; IN_232], record: &mut QueryRecord, io_buffer: &mut IOBuffer, unconstrained: bool, -) -> Result<[G; OUT_236], ExecError> { +) -> Result<[G; OUT_232], ExecError> { stacker::maybe_grow(64 * 1024, 4 * 1024 * 1024, || { let __v_0: G = inp[0]; let __loaded: [G; 4] = { let __mq = record.memory_queries.get_mut(&4).ok_or(ExecError::InvalidMemorySize(4))?; let __ptr_u64 = __v_0.as_canonical_u64(); let __ptr_usize = usize::try_from(__ptr_u64).ok().ok_or(ExecError::PointerTooLarge(__ptr_u64))?; let (__args, __mult) = __mq.get_index_mut(__ptr_usize).ok_or(ExecError::UnboundPointer { ptr: __ptr_u64, size: 4 })?; if !unconstrained { *__mult += G::ONE; } let __arr: [G; 4] = __args[..4].try_into().unwrap(); __arr }; @@ -22255,7 +21981,7 @@ fn aiur_fn_236( let __v_8: G = __loaded[3]; match __v_5.as_canonical_u64() { 2u64 => { - let __r_arr: [G; OUT_209] = { let __args: [G; IN_209] = []; let __cu = unconstrained; if let Some(result) = record.function_queries[209].get_mut(&__args[..]) { if !__cu && *result.multiplicity == G::ZERO { aiur_fn_209(__args, record, io_buffer, false)? } else { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_209] = unsafe { *(result.output.as_ptr() as *const [G; OUT_209]) }; __ret } } else { aiur_fn_209(__args, record, io_buffer, __cu)? } }; + let __r_arr: [G; OUT_205] = { let __args: [G; IN_205] = []; let __cu = unconstrained; if let Some(result) = record.function_queries[205].get_mut(&__args[..]) { if !__cu && *result.multiplicity == G::ZERO { aiur_fn_205(__args, record, io_buffer, false)? } else { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_205] = unsafe { *(result.output.as_ptr() as *const [G; OUT_205]) }; __ret } } else { aiur_fn_205(__args, record, io_buffer, __cu)? } }; let __v_9: G = __r_arr[0]; let __r_arr: [G; OUT_1] = { let __args: [G; IN_1] = [__v_6, __v_9]; let __cu = unconstrained; if let Some(result) = record.function_queries[1].get_mut(&__args[..]) { if !__cu && *result.multiplicity == G::ZERO { aiur_fn_1(__args, record, io_buffer, false)? } else { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_1] = unsafe { *(result.output.as_ptr() as *const [G; OUT_1]) }; __ret } } else { aiur_fn_1(__args, record, io_buffer, __cu)? } }; let __v_10: G = __r_arr[0]; @@ -22263,8 +21989,8 @@ fn aiur_fn_236( 0u64 => { let __v_11: G = G::from_u64(0); let __v_12: G = G::from_u64(0); - let __ret: [G; OUT_236] = [__v_11, __v_12]; - if let Some(result) = record.function_queries[236].get_mut(&inp[..]) { debug_assert_eq!(result.output, &__ret[..]); if !unconstrained { *result.multiplicity += G::ONE; } } else { record.function_queries[236].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained)); }; + let __ret: [G; OUT_232] = [__v_11, __v_12]; + if let Some(result) = record.function_queries[232].get_mut(&inp[..]) { debug_assert_eq!(result.output, &__ret[..]); if !unconstrained { *result.multiplicity += G::ONE; } } else { record.function_queries[232].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained)); }; return Ok(__ret); }, _ => { @@ -22277,18 +22003,18 @@ fn aiur_fn_236( 7u64 => { match __v_12.as_canonical_u64() { 0u64 => { - let __r_arr: [G; OUT_237] = { let __args: [G; IN_237] = [__v_13]; let __cu = unconstrained; if let Some(result) = record.function_queries[237].get_mut(&__args[..]) { if !__cu && *result.multiplicity == G::ZERO { aiur_fn_237(__args, record, io_buffer, false)? } else { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_237] = unsafe { *(result.output.as_ptr() as *const [G; OUT_237]) }; __ret } } else { aiur_fn_237(__args, record, io_buffer, __cu)? } }; + let __r_arr: [G; OUT_233] = { let __args: [G; IN_233] = [__v_13]; let __cu = unconstrained; if let Some(result) = record.function_queries[233].get_mut(&__args[..]) { if !__cu && *result.multiplicity == G::ZERO { aiur_fn_233(__args, record, io_buffer, false)? } else { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_233] = unsafe { *(result.output.as_ptr() as *const [G; OUT_233]) }; __ret } } else { aiur_fn_233(__args, record, io_buffer, __cu)? } }; let __v_15: G = __r_arr[0]; let __v_16: G = __r_arr[1]; - let __ret: [G; OUT_236] = [__v_15, __v_16]; - if let Some(result) = record.function_queries[236].get_mut(&inp[..]) { debug_assert_eq!(result.output, &__ret[..]); if !unconstrained { *result.multiplicity += G::ONE; } } else { record.function_queries[236].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained)); }; + let __ret: [G; OUT_232] = [__v_15, __v_16]; + if let Some(result) = record.function_queries[232].get_mut(&inp[..]) { debug_assert_eq!(result.output, &__ret[..]); if !unconstrained { *result.multiplicity += G::ONE; } } else { record.function_queries[232].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained)); }; return Ok(__ret); }, _ => { let __v_15: G = G::from_u64(0); let __v_16: G = G::from_u64(0); - let __ret: [G; OUT_236] = [__v_15, __v_16]; - if let Some(result) = record.function_queries[236].get_mut(&inp[..]) { debug_assert_eq!(result.output, &__ret[..]); if !unconstrained { *result.multiplicity += G::ONE; } } else { record.function_queries[236].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained)); }; + let __ret: [G; OUT_232] = [__v_15, __v_16]; + if let Some(result) = record.function_queries[232].get_mut(&inp[..]) { debug_assert_eq!(result.output, &__ret[..]); if !unconstrained { *result.multiplicity += G::ONE; } } else { record.function_queries[232].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained)); }; return Ok(__ret); }, } @@ -22296,8 +22022,8 @@ fn aiur_fn_236( _ => { let __v_15: G = G::from_u64(0); let __v_16: G = G::from_u64(0); - let __ret: [G; OUT_236] = [__v_15, __v_16]; - if let Some(result) = record.function_queries[236].get_mut(&inp[..]) { debug_assert_eq!(result.output, &__ret[..]); if !unconstrained { *result.multiplicity += G::ONE; } } else { record.function_queries[236].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained)); }; + let __ret: [G; OUT_232] = [__v_15, __v_16]; + if let Some(result) = record.function_queries[232].get_mut(&inp[..]) { debug_assert_eq!(result.output, &__ret[..]); if !unconstrained { *result.multiplicity += G::ONE; } } else { record.function_queries[232].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained)); }; return Ok(__ret); }, } @@ -22307,8 +22033,8 @@ fn aiur_fn_236( _ => { let __v_9: G = G::from_u64(0); let __v_10: G = G::from_u64(0); - let __ret: [G; OUT_236] = [__v_9, __v_10]; - if let Some(result) = record.function_queries[236].get_mut(&inp[..]) { debug_assert_eq!(result.output, &__ret[..]); if !unconstrained { *result.multiplicity += G::ONE; } } else { record.function_queries[236].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained)); }; + let __ret: [G; OUT_232] = [__v_9, __v_10]; + if let Some(result) = record.function_queries[232].get_mut(&inp[..]) { debug_assert_eq!(result.output, &__ret[..]); if !unconstrained { *result.multiplicity += G::ONE; } } else { record.function_queries[232].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained)); }; return Ok(__ret); }, } @@ -22316,23 +22042,23 @@ fn aiur_fn_236( _ => { let __v_5: G = G::from_u64(0); let __v_6: G = G::from_u64(0); - let __ret: [G; OUT_236] = [__v_5, __v_6]; - if let Some(result) = record.function_queries[236].get_mut(&inp[..]) { debug_assert_eq!(result.output, &__ret[..]); if !unconstrained { *result.multiplicity += G::ONE; } } else { record.function_queries[236].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained)); }; + let __ret: [G; OUT_232] = [__v_5, __v_6]; + if let Some(result) = record.function_queries[232].get_mut(&inp[..]) { debug_assert_eq!(result.output, &__ret[..]); if !unconstrained { *result.multiplicity += G::ONE; } } else { record.function_queries[232].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained)); }; return Ok(__ret); }, } }) } -const INPUT_SIZE_237: usize = 1; -const IN_237: usize = 1; -const OUT_237: usize = 2; -fn aiur_fn_237( - inp: [G; IN_237], +const INPUT_SIZE_233: usize = 1; +const IN_233: usize = 1; +const OUT_233: usize = 2; +fn aiur_fn_233( + inp: [G; IN_233], record: &mut QueryRecord, io_buffer: &mut IOBuffer, unconstrained: bool, -) -> Result<[G; OUT_237], ExecError> { +) -> Result<[G; OUT_233], ExecError> { stacker::maybe_grow(64 * 1024, 4 * 1024 * 1024, || { let __v_0: G = inp[0]; let __loaded: [G; 10] = { let __mq = record.memory_queries.get_mut(&10).ok_or(ExecError::InvalidMemorySize(10))?; let __ptr_u64 = __v_0.as_canonical_u64(); let __ptr_usize = usize::try_from(__ptr_u64).ok().ok_or(ExecError::PointerTooLarge(__ptr_u64))?; let (__args, __mult) = __mq.get_index_mut(__ptr_usize).ok_or(ExecError::UnboundPointer { ptr: __ptr_u64, size: 10 })?; if !unconstrained { *__mult += G::ONE; } let __arr: [G; 10] = __args[..10].try_into().unwrap(); __arr }; @@ -22370,8 +22096,8 @@ fn aiur_fn_237( 0u64 => { let __v_26: G = G::from_u64(0); let __v_27: G = G::from_u64(0); - let __ret: [G; OUT_237] = [__v_26, __v_27]; - if let Some(result) = record.function_queries[237].get_mut(&inp[..]) { debug_assert_eq!(result.output, &__ret[..]); if !unconstrained { *result.multiplicity += G::ONE; } } else { record.function_queries[237].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained)); }; + let __ret: [G; OUT_233] = [__v_26, __v_27]; + if let Some(result) = record.function_queries[233].get_mut(&inp[..]) { debug_assert_eq!(result.output, &__ret[..]); if !unconstrained { *result.multiplicity += G::ONE; } } else { record.function_queries[233].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained)); }; return Ok(__ret); }, _ => { @@ -22386,8 +22112,8 @@ fn aiur_fn_237( match __v_33.as_canonical_u64() { 1u64 => { let __v_34: G = G::from_u64(1); - let __ret: [G; OUT_237] = [__v_34, __v_31]; - if let Some(result) = record.function_queries[237].get_mut(&inp[..]) { debug_assert_eq!(result.output, &__ret[..]); if !unconstrained { *result.multiplicity += G::ONE; } } else { record.function_queries[237].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained)); }; + let __ret: [G; OUT_233] = [__v_34, __v_31]; + if let Some(result) = record.function_queries[233].get_mut(&inp[..]) { debug_assert_eq!(result.output, &__ret[..]); if !unconstrained { *result.multiplicity += G::ONE; } } else { record.function_queries[233].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained)); }; return Ok(__ret); }, _ => { @@ -22397,8 +22123,8 @@ fn aiur_fn_237( 0u64 => { let __v_36: G = G::from_u64(0); let __v_37: G = G::from_u64(0); - let __ret: [G; OUT_237] = [__v_36, __v_37]; - if let Some(result) = record.function_queries[237].get_mut(&inp[..]) { debug_assert_eq!(result.output, &__ret[..]); if !unconstrained { *result.multiplicity += G::ONE; } } else { record.function_queries[237].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained)); }; + let __ret: [G; OUT_233] = [__v_36, __v_37]; + if let Some(result) = record.function_queries[233].get_mut(&inp[..]) { debug_assert_eq!(result.output, &__ret[..]); if !unconstrained { *result.multiplicity += G::ONE; } } else { record.function_queries[233].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained)); }; return Ok(__ret); }, _ => { @@ -22407,15 +22133,15 @@ fn aiur_fn_237( match __v_37.as_canonical_u64() { 1u64 => { let __v_38: G = G::from_u64(1); - let __ret: [G; OUT_237] = [__v_38, __v_31]; - if let Some(result) = record.function_queries[237].get_mut(&inp[..]) { debug_assert_eq!(result.output, &__ret[..]); if !unconstrained { *result.multiplicity += G::ONE; } } else { record.function_queries[237].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained)); }; + let __ret: [G; OUT_233] = [__v_38, __v_31]; + if let Some(result) = record.function_queries[233].get_mut(&inp[..]) { debug_assert_eq!(result.output, &__ret[..]); if !unconstrained { *result.multiplicity += G::ONE; } } else { record.function_queries[233].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained)); }; return Ok(__ret); }, _ => { let __v_38: G = G::from_u64(0); let __v_39: G = G::from_u64(0); - let __ret: [G; OUT_237] = [__v_38, __v_39]; - if let Some(result) = record.function_queries[237].get_mut(&inp[..]) { debug_assert_eq!(result.output, &__ret[..]); if !unconstrained { *result.multiplicity += G::ONE; } } else { record.function_queries[237].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained)); }; + let __ret: [G; OUT_233] = [__v_38, __v_39]; + if let Some(result) = record.function_queries[233].get_mut(&inp[..]) { debug_assert_eq!(result.output, &__ret[..]); if !unconstrained { *result.multiplicity += G::ONE; } } else { record.function_queries[233].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained)); }; return Ok(__ret); }, } @@ -22429,8 +22155,8 @@ fn aiur_fn_237( _ => { let __v_21: G = G::from_u64(0); let __v_22: G = G::from_u64(0); - let __ret: [G; OUT_237] = [__v_21, __v_22]; - if let Some(result) = record.function_queries[237].get_mut(&inp[..]) { debug_assert_eq!(result.output, &__ret[..]); if !unconstrained { *result.multiplicity += G::ONE; } } else { record.function_queries[237].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained)); }; + let __ret: [G; OUT_233] = [__v_21, __v_22]; + if let Some(result) = record.function_queries[233].get_mut(&inp[..]) { debug_assert_eq!(result.output, &__ret[..]); if !unconstrained { *result.multiplicity += G::ONE; } } else { record.function_queries[233].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained)); }; return Ok(__ret); }, } @@ -22438,23 +22164,23 @@ fn aiur_fn_237( _ => { let __v_11: G = G::from_u64(0); let __v_12: G = G::from_u64(0); - let __ret: [G; OUT_237] = [__v_11, __v_12]; - if let Some(result) = record.function_queries[237].get_mut(&inp[..]) { debug_assert_eq!(result.output, &__ret[..]); if !unconstrained { *result.multiplicity += G::ONE; } } else { record.function_queries[237].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained)); }; + let __ret: [G; OUT_233] = [__v_11, __v_12]; + if let Some(result) = record.function_queries[233].get_mut(&inp[..]) { debug_assert_eq!(result.output, &__ret[..]); if !unconstrained { *result.multiplicity += G::ONE; } } else { record.function_queries[233].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained)); }; return Ok(__ret); }, } }) } -const INPUT_SIZE_238: usize = 2; -const IN_238: usize = 2; -const OUT_238: usize = 2; -fn aiur_fn_238( - inp: [G; IN_238], +const INPUT_SIZE_234: usize = 2; +const IN_234: usize = 2; +const OUT_234: usize = 2; +fn aiur_fn_234( + inp: [G; IN_234], record: &mut QueryRecord, io_buffer: &mut IOBuffer, unconstrained: bool, -) -> Result<[G; OUT_238], ExecError> { +) -> Result<[G; OUT_234], ExecError> { stacker::maybe_grow(64 * 1024, 4 * 1024 * 1024, || { let __v_0: G = inp[0]; let __v_1: G = inp[1]; @@ -22462,8 +22188,8 @@ fn aiur_fn_238( let __v_3: G = { let __a_val = __v_0.as_canonical_u64(); let __b_val = __v_2.as_canonical_u64(); let __a_u32 = u32::try_from(__a_val).ok().ok_or(ExecError::U32OutOfRange(__a_val))?; let __b_u32 = u32::try_from(__b_val).ok().ok_or(ExecError::U32OutOfRange(__b_val))?; let __result = G::from_bool(__a_u32 < __b_u32); if !unconstrained { let __x_bytes = __a_u32.to_le_bytes(); let __z_bytes = __b_u32.to_le_bytes(); let __c_u32 = __b_u32.wrapping_sub(__a_u32).wrapping_sub(1); let __y_bytes = __c_u32.to_le_bytes(); record.bytes2_queries.bump_range_check(&G::from_u8(__x_bytes[0]), &G::from_u8(__x_bytes[1])); record.bytes2_queries.bump_range_check(&G::from_u8(__x_bytes[2]), &G::from_u8(__x_bytes[3])); record.bytes2_queries.bump_range_check(&G::from_u8(__y_bytes[0]), &G::from_u8(__y_bytes[1])); record.bytes2_queries.bump_range_check(&G::from_u8(__y_bytes[2]), &G::from_u8(__y_bytes[3])); record.bytes2_queries.bump_range_check(&G::from_u8(__z_bytes[0]), &G::from_u8(__z_bytes[1])); record.bytes2_queries.bump_range_check(&G::from_u8(__z_bytes[2]), &G::from_u8(__z_bytes[3])); } __result }; match __v_3.as_canonical_u64() { 1u64 => { - let __ret: [G; OUT_238] = [__v_0, __v_1]; - if let Some(result) = record.function_queries[238].get_mut(&inp[..]) { debug_assert_eq!(result.output, &__ret[..]); if !unconstrained { *result.multiplicity += G::ONE; } } else { record.function_queries[238].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained)); }; + let __ret: [G; OUT_234] = [__v_0, __v_1]; + if let Some(result) = record.function_queries[234].get_mut(&inp[..]) { debug_assert_eq!(result.output, &__ret[..]); if !unconstrained { *result.multiplicity += G::ONE; } } else { record.function_queries[234].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained)); }; return Ok(__ret); }, _ => { @@ -22471,59 +22197,59 @@ fn aiur_fn_238( let __v_5: G = (__v_0 - __v_4); let __v_6: G = G::from_u64(1); let __v_7: G = (__v_1 + __v_6); - let __r_arr: [G; OUT_238] = { let __args: [G; IN_238] = [__v_5, __v_7]; let __cu = unconstrained; if let Some(result) = record.function_queries[238].get_mut(&__args[..]) { if !__cu && *result.multiplicity == G::ZERO { aiur_fn_238(__args, record, io_buffer, false)? } else { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_238] = unsafe { *(result.output.as_ptr() as *const [G; OUT_238]) }; __ret } } else { aiur_fn_238(__args, record, io_buffer, __cu)? } }; + let __r_arr: [G; OUT_234] = { let __args: [G; IN_234] = [__v_5, __v_7]; let __cu = unconstrained; if let Some(result) = record.function_queries[234].get_mut(&__args[..]) { if !__cu && *result.multiplicity == G::ZERO { aiur_fn_234(__args, record, io_buffer, false)? } else { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_234] = unsafe { *(result.output.as_ptr() as *const [G; OUT_234]) }; __ret } } else { aiur_fn_234(__args, record, io_buffer, __cu)? } }; let __v_8: G = __r_arr[0]; let __v_9: G = __r_arr[1]; - let __ret: [G; OUT_238] = [__v_8, __v_9]; - if let Some(result) = record.function_queries[238].get_mut(&inp[..]) { debug_assert_eq!(result.output, &__ret[..]); if !unconstrained { *result.multiplicity += G::ONE; } } else { record.function_queries[238].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained)); }; + let __ret: [G; OUT_234] = [__v_8, __v_9]; + if let Some(result) = record.function_queries[234].get_mut(&inp[..]) { debug_assert_eq!(result.output, &__ret[..]); if !unconstrained { *result.multiplicity += G::ONE; } } else { record.function_queries[234].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained)); }; return Ok(__ret); }, } }) } -const INPUT_SIZE_239: usize = 1; -const IN_239: usize = 1; -const OUT_239: usize = 4; -fn aiur_fn_239( - inp: [G; IN_239], +const INPUT_SIZE_235: usize = 1; +const IN_235: usize = 1; +const OUT_235: usize = 4; +fn aiur_fn_235( + inp: [G; IN_235], record: &mut QueryRecord, io_buffer: &mut IOBuffer, unconstrained: bool, -) -> Result<[G; OUT_239], ExecError> { +) -> Result<[G; OUT_235], ExecError> { stacker::maybe_grow(64 * 1024, 4 * 1024 * 1024, || { let __v_0: G = inp[0]; let __v_1: G = G::from_u64(0); - let __r_arr: [G; OUT_238] = { let __args: [G; IN_238] = [__v_0, __v_1]; let __cu = unconstrained; if let Some(result) = record.function_queries[238].get_mut(&__args[..]) { if !__cu && *result.multiplicity == G::ZERO { aiur_fn_238(__args, record, io_buffer, false)? } else { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_238] = unsafe { *(result.output.as_ptr() as *const [G; OUT_238]) }; __ret } } else { aiur_fn_238(__args, record, io_buffer, __cu)? } }; + let __r_arr: [G; OUT_234] = { let __args: [G; IN_234] = [__v_0, __v_1]; let __cu = unconstrained; if let Some(result) = record.function_queries[234].get_mut(&__args[..]) { if !__cu && *result.multiplicity == G::ZERO { aiur_fn_234(__args, record, io_buffer, false)? } else { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_234] = unsafe { *(result.output.as_ptr() as *const [G; OUT_234]) }; __ret } } else { aiur_fn_234(__args, record, io_buffer, __cu)? } }; let __v_2: G = __r_arr[0]; let __v_3: G = __r_arr[1]; let __v_4: G = G::from_u64(0); - let __r_arr: [G; OUT_238] = { let __args: [G; IN_238] = [__v_3, __v_4]; let __cu = unconstrained; if let Some(result) = record.function_queries[238].get_mut(&__args[..]) { if !__cu && *result.multiplicity == G::ZERO { aiur_fn_238(__args, record, io_buffer, false)? } else { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_238] = unsafe { *(result.output.as_ptr() as *const [G; OUT_238]) }; __ret } } else { aiur_fn_238(__args, record, io_buffer, __cu)? } }; + let __r_arr: [G; OUT_234] = { let __args: [G; IN_234] = [__v_3, __v_4]; let __cu = unconstrained; if let Some(result) = record.function_queries[234].get_mut(&__args[..]) { if !__cu && *result.multiplicity == G::ZERO { aiur_fn_234(__args, record, io_buffer, false)? } else { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_234] = unsafe { *(result.output.as_ptr() as *const [G; OUT_234]) }; __ret } } else { aiur_fn_234(__args, record, io_buffer, __cu)? } }; let __v_5: G = __r_arr[0]; let __v_6: G = __r_arr[1]; let __v_7: G = G::from_u64(0); - let __r_arr: [G; OUT_238] = { let __args: [G; IN_238] = [__v_6, __v_7]; let __cu = unconstrained; if let Some(result) = record.function_queries[238].get_mut(&__args[..]) { if !__cu && *result.multiplicity == G::ZERO { aiur_fn_238(__args, record, io_buffer, false)? } else { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_238] = unsafe { *(result.output.as_ptr() as *const [G; OUT_238]) }; __ret } } else { aiur_fn_238(__args, record, io_buffer, __cu)? } }; + let __r_arr: [G; OUT_234] = { let __args: [G; IN_234] = [__v_6, __v_7]; let __cu = unconstrained; if let Some(result) = record.function_queries[234].get_mut(&__args[..]) { if !__cu && *result.multiplicity == G::ZERO { aiur_fn_234(__args, record, io_buffer, false)? } else { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_234] = unsafe { *(result.output.as_ptr() as *const [G; OUT_234]) }; __ret } } else { aiur_fn_234(__args, record, io_buffer, __cu)? } }; let __v_8: G = __r_arr[0]; let __v_9: G = __r_arr[1]; - let __ret: [G; OUT_239] = [__v_2, __v_5, __v_8, __v_9]; - if let Some(result) = record.function_queries[239].get_mut(&inp[..]) { debug_assert_eq!(result.output, &__ret[..]); if !unconstrained { *result.multiplicity += G::ONE; } } else { record.function_queries[239].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained)); }; + let __ret: [G; OUT_235] = [__v_2, __v_5, __v_8, __v_9]; + if let Some(result) = record.function_queries[235].get_mut(&inp[..]) { debug_assert_eq!(result.output, &__ret[..]); if !unconstrained { *result.multiplicity += G::ONE; } } else { record.function_queries[235].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained)); }; return Ok(__ret); }) } -const INPUT_SIZE_240: usize = 2; -const IN_240: usize = 2; -const OUT_240: usize = 1; -fn aiur_fn_240( - inp: [G; IN_240], +const INPUT_SIZE_236: usize = 2; +const IN_236: usize = 2; +const OUT_236: usize = 1; +fn aiur_fn_236( + inp: [G; IN_236], record: &mut QueryRecord, io_buffer: &mut IOBuffer, unconstrained: bool, -) -> Result<[G; OUT_240], ExecError> { +) -> Result<[G; OUT_236], ExecError> { stacker::maybe_grow(64 * 1024, 4 * 1024 * 1024, || { let __v_0: G = inp[0]; let __v_1: G = inp[1]; - let __r_arr: [G; OUT_239] = { let __args: [G; IN_239] = [__v_0]; let __cu = true; if let Some(result) = record.function_queries[239].get_mut(&__args[..]) { if !__cu && *result.multiplicity == G::ZERO { aiur_fn_239(__args, record, io_buffer, false)? } else { let __ret: [G; OUT_239] = unsafe { *(result.output.as_ptr() as *const [G; OUT_239]) }; __ret } } else { aiur_fn_239(__args, record, io_buffer, __cu)? } }; + let __r_arr: [G; OUT_235] = { let __args: [G; IN_235] = [__v_0]; let __cu = true; if let Some(result) = record.function_queries[235].get_mut(&__args[..]) { if !__cu && *result.multiplicity == G::ZERO { aiur_fn_235(__args, record, io_buffer, false)? } else { let __ret: [G; OUT_235] = unsafe { *(result.output.as_ptr() as *const [G; OUT_235]) }; __ret } } else { aiur_fn_235(__args, record, io_buffer, __cu)? } }; let __v_2: G = __r_arr[0]; let __v_3: G = __r_arr[1]; let __v_4: G = __r_arr[2]; @@ -22578,8 +22304,8 @@ fn aiur_fn_240( 1u64 => { let __v_37: G = G::from_u64(0); let __v_38: G = { let __values: [G; 3] = [__v_37, __v_0, __v_1]; let __mq = record.memory_queries.get_mut(&3).ok_or(ExecError::InvalidMemorySize(3))?; if let Some(result) = __mq.get_mut(&__values[..]) { if !unconstrained { *result.multiplicity += G::ONE; } result.output[0] } else { let __ptr = G::from_usize(__mq.len()); __mq.insert(&__values[..], &[__ptr], G::from_bool(!unconstrained)); __ptr } }; - let __ret: [G; OUT_240] = [__v_38]; - if let Some(result) = record.function_queries[240].get_mut(&inp[..]) { debug_assert_eq!(result.output, &__ret[..]); if !unconstrained { *result.multiplicity += G::ONE; } } else { record.function_queries[240].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained)); }; + let __ret: [G; OUT_236] = [__v_38]; + if let Some(result) = record.function_queries[236].get_mut(&inp[..]) { debug_assert_eq!(result.output, &__ret[..]); if !unconstrained { *result.multiplicity += G::ONE; } } else { record.function_queries[236].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained)); }; return Ok(__ret); }, _ => { @@ -22595,8 +22321,8 @@ fn aiur_fn_240( let __v_44: G = G::from_u64(0); let __v_45: G = { let __values: [G; 3] = [__v_44, __v_40, __v_1]; let __mq = record.memory_queries.get_mut(&3).ok_or(ExecError::InvalidMemorySize(3))?; if let Some(result) = __mq.get_mut(&__values[..]) { if !unconstrained { *result.multiplicity += G::ONE; } result.output[0] } else { let __ptr = G::from_usize(__mq.len()); __mq.insert(&__values[..], &[__ptr], G::from_bool(!unconstrained)); __ptr } }; let __v_46: G = { let __values: [G; 3] = [__v_43, __v_42, __v_45]; let __mq = record.memory_queries.get_mut(&3).ok_or(ExecError::InvalidMemorySize(3))?; if let Some(result) = __mq.get_mut(&__values[..]) { if !unconstrained { *result.multiplicity += G::ONE; } result.output[0] } else { let __ptr = G::from_usize(__mq.len()); __mq.insert(&__values[..], &[__ptr], G::from_bool(!unconstrained)); __ptr } }; - let __ret: [G; OUT_240] = [__v_46]; - if let Some(result) = record.function_queries[240].get_mut(&inp[..]) { debug_assert_eq!(result.output, &__ret[..]); if !unconstrained { *result.multiplicity += G::ONE; } } else { record.function_queries[240].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained)); }; + let __ret: [G; OUT_236] = [__v_46]; + if let Some(result) = record.function_queries[236].get_mut(&inp[..]) { debug_assert_eq!(result.output, &__ret[..]); if !unconstrained { *result.multiplicity += G::ONE; } } else { record.function_queries[236].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained)); }; return Ok(__ret); }, _ => { @@ -22616,8 +22342,8 @@ fn aiur_fn_240( let __v_50: G = { let __values: [G; 3] = [__v_49, __v_42, __v_1]; let __mq = record.memory_queries.get_mut(&3).ok_or(ExecError::InvalidMemorySize(3))?; if let Some(result) = __mq.get_mut(&__values[..]) { if !unconstrained { *result.multiplicity += G::ONE; } result.output[0] } else { let __ptr = G::from_usize(__mq.len()); __mq.insert(&__values[..], &[__ptr], G::from_bool(!unconstrained)); __ptr } }; let __v_51: G = { let __values: [G; 3] = [__v_48, __v_44, __v_50]; let __mq = record.memory_queries.get_mut(&3).ok_or(ExecError::InvalidMemorySize(3))?; if let Some(result) = __mq.get_mut(&__values[..]) { if !unconstrained { *result.multiplicity += G::ONE; } result.output[0] } else { let __ptr = G::from_usize(__mq.len()); __mq.insert(&__values[..], &[__ptr], G::from_bool(!unconstrained)); __ptr } }; let __v_52: G = { let __values: [G; 3] = [__v_47, __v_46, __v_51]; let __mq = record.memory_queries.get_mut(&3).ok_or(ExecError::InvalidMemorySize(3))?; if let Some(result) = __mq.get_mut(&__values[..]) { if !unconstrained { *result.multiplicity += G::ONE; } result.output[0] } else { let __ptr = G::from_usize(__mq.len()); __mq.insert(&__values[..], &[__ptr], G::from_bool(!unconstrained)); __ptr } }; - let __ret: [G; OUT_240] = [__v_52]; - if let Some(result) = record.function_queries[240].get_mut(&inp[..]) { debug_assert_eq!(result.output, &__ret[..]); if !unconstrained { *result.multiplicity += G::ONE; } } else { record.function_queries[240].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained)); }; + let __ret: [G; OUT_236] = [__v_52]; + if let Some(result) = record.function_queries[236].get_mut(&inp[..]) { debug_assert_eq!(result.output, &__ret[..]); if !unconstrained { *result.multiplicity += G::ONE; } } else { record.function_queries[236].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained)); }; return Ok(__ret); }, _ => { @@ -22637,8 +22363,8 @@ fn aiur_fn_240( let __v_54: G = { let __values: [G; 3] = [__v_51, __v_44, __v_53]; let __mq = record.memory_queries.get_mut(&3).ok_or(ExecError::InvalidMemorySize(3))?; if let Some(result) = __mq.get_mut(&__values[..]) { if !unconstrained { *result.multiplicity += G::ONE; } result.output[0] } else { let __ptr = G::from_usize(__mq.len()); __mq.insert(&__values[..], &[__ptr], G::from_bool(!unconstrained)); __ptr } }; let __v_55: G = { let __values: [G; 3] = [__v_50, __v_46, __v_54]; let __mq = record.memory_queries.get_mut(&3).ok_or(ExecError::InvalidMemorySize(3))?; if let Some(result) = __mq.get_mut(&__values[..]) { if !unconstrained { *result.multiplicity += G::ONE; } result.output[0] } else { let __ptr = G::from_usize(__mq.len()); __mq.insert(&__values[..], &[__ptr], G::from_bool(!unconstrained)); __ptr } }; let __v_56: G = { let __values: [G; 3] = [__v_49, __v_48, __v_55]; let __mq = record.memory_queries.get_mut(&3).ok_or(ExecError::InvalidMemorySize(3))?; if let Some(result) = __mq.get_mut(&__values[..]) { if !unconstrained { *result.multiplicity += G::ONE; } result.output[0] } else { let __ptr = G::from_usize(__mq.len()); __mq.insert(&__values[..], &[__ptr], G::from_bool(!unconstrained)); __ptr } }; - let __ret: [G; OUT_240] = [__v_56]; - if let Some(result) = record.function_queries[240].get_mut(&inp[..]) { debug_assert_eq!(result.output, &__ret[..]); if !unconstrained { *result.multiplicity += G::ONE; } } else { record.function_queries[240].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained)); }; + let __ret: [G; OUT_236] = [__v_56]; + if let Some(result) = record.function_queries[236].get_mut(&inp[..]) { debug_assert_eq!(result.output, &__ret[..]); if !unconstrained { *result.multiplicity += G::ONE; } } else { record.function_queries[236].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained)); }; return Ok(__ret); }, } @@ -22649,15 +22375,15 @@ fn aiur_fn_240( }) } -const INPUT_SIZE_241: usize = 1; -const IN_241: usize = 1; -const OUT_241: usize = 1; -fn aiur_fn_241( - inp: [G; IN_241], +const INPUT_SIZE_237: usize = 1; +const IN_237: usize = 1; +const OUT_237: usize = 1; +fn aiur_fn_237( + inp: [G; IN_237], record: &mut QueryRecord, io_buffer: &mut IOBuffer, unconstrained: bool, -) -> Result<[G; OUT_241], ExecError> { +) -> Result<[G; OUT_237], ExecError> { stacker::maybe_grow(64 * 1024, 4 * 1024 * 1024, || { let __v_0: G = inp[0]; let __r_arr: [G; OUT_144] = { let __args: [G; IN_144] = []; let __cu = unconstrained; if let Some(result) = record.function_queries[144].get_mut(&__args[..]) { if !__cu && *result.multiplicity == G::ZERO { aiur_fn_144(__args, record, io_buffer, false)? } else { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_144] = unsafe { *(result.output.as_ptr() as *const [G; OUT_144]) }; __ret } } else { aiur_fn_144(__args, record, io_buffer, __cu)? } }; @@ -22667,8 +22393,8 @@ fn aiur_fn_241( match __v_2.as_canonical_u64() { 1u64 => { let __v_3: G = G::from_u64(1); - let __ret: [G; OUT_241] = [__v_3]; - if let Some(result) = record.function_queries[241].get_mut(&inp[..]) { debug_assert_eq!(result.output, &__ret[..]); if !unconstrained { *result.multiplicity += G::ONE; } } else { record.function_queries[241].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained)); }; + let __ret: [G; OUT_237] = [__v_3]; + if let Some(result) = record.function_queries[237].get_mut(&inp[..]) { debug_assert_eq!(result.output, &__ret[..]); if !unconstrained { *result.multiplicity += G::ONE; } } else { record.function_queries[237].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained)); }; return Ok(__ret); }, _ => { @@ -22679,8 +22405,8 @@ fn aiur_fn_241( match __v_4.as_canonical_u64() { 1u64 => { let __v_5: G = G::from_u64(1); - let __ret: [G; OUT_241] = [__v_5]; - if let Some(result) = record.function_queries[241].get_mut(&inp[..]) { debug_assert_eq!(result.output, &__ret[..]); if !unconstrained { *result.multiplicity += G::ONE; } } else { record.function_queries[241].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained)); }; + let __ret: [G; OUT_237] = [__v_5]; + if let Some(result) = record.function_queries[237].get_mut(&inp[..]) { debug_assert_eq!(result.output, &__ret[..]); if !unconstrained { *result.multiplicity += G::ONE; } } else { record.function_queries[237].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained)); }; return Ok(__ret); }, _ => { @@ -22691,8 +22417,8 @@ fn aiur_fn_241( match __v_6.as_canonical_u64() { 1u64 => { let __v_7: G = G::from_u64(1); - let __ret: [G; OUT_241] = [__v_7]; - if let Some(result) = record.function_queries[241].get_mut(&inp[..]) { debug_assert_eq!(result.output, &__ret[..]); if !unconstrained { *result.multiplicity += G::ONE; } } else { record.function_queries[241].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained)); }; + let __ret: [G; OUT_237] = [__v_7]; + if let Some(result) = record.function_queries[237].get_mut(&inp[..]) { debug_assert_eq!(result.output, &__ret[..]); if !unconstrained { *result.multiplicity += G::ONE; } } else { record.function_queries[237].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained)); }; return Ok(__ret); }, _ => { @@ -22703,8 +22429,8 @@ fn aiur_fn_241( match __v_8.as_canonical_u64() { 1u64 => { let __v_9: G = G::from_u64(1); - let __ret: [G; OUT_241] = [__v_9]; - if let Some(result) = record.function_queries[241].get_mut(&inp[..]) { debug_assert_eq!(result.output, &__ret[..]); if !unconstrained { *result.multiplicity += G::ONE; } } else { record.function_queries[241].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained)); }; + let __ret: [G; OUT_237] = [__v_9]; + if let Some(result) = record.function_queries[237].get_mut(&inp[..]) { debug_assert_eq!(result.output, &__ret[..]); if !unconstrained { *result.multiplicity += G::ONE; } } else { record.function_queries[237].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained)); }; return Ok(__ret); }, _ => { @@ -22715,8 +22441,8 @@ fn aiur_fn_241( match __v_10.as_canonical_u64() { 1u64 => { let __v_11: G = G::from_u64(1); - let __ret: [G; OUT_241] = [__v_11]; - if let Some(result) = record.function_queries[241].get_mut(&inp[..]) { debug_assert_eq!(result.output, &__ret[..]); if !unconstrained { *result.multiplicity += G::ONE; } } else { record.function_queries[241].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained)); }; + let __ret: [G; OUT_237] = [__v_11]; + if let Some(result) = record.function_queries[237].get_mut(&inp[..]) { debug_assert_eq!(result.output, &__ret[..]); if !unconstrained { *result.multiplicity += G::ONE; } } else { record.function_queries[237].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained)); }; return Ok(__ret); }, _ => { @@ -22727,8 +22453,8 @@ fn aiur_fn_241( match __v_12.as_canonical_u64() { 1u64 => { let __v_13: G = G::from_u64(1); - let __ret: [G; OUT_241] = [__v_13]; - if let Some(result) = record.function_queries[241].get_mut(&inp[..]) { debug_assert_eq!(result.output, &__ret[..]); if !unconstrained { *result.multiplicity += G::ONE; } } else { record.function_queries[241].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained)); }; + let __ret: [G; OUT_237] = [__v_13]; + if let Some(result) = record.function_queries[237].get_mut(&inp[..]) { debug_assert_eq!(result.output, &__ret[..]); if !unconstrained { *result.multiplicity += G::ONE; } } else { record.function_queries[237].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained)); }; return Ok(__ret); }, _ => { @@ -22739,8 +22465,8 @@ fn aiur_fn_241( match __v_14.as_canonical_u64() { 1u64 => { let __v_15: G = G::from_u64(1); - let __ret: [G; OUT_241] = [__v_15]; - if let Some(result) = record.function_queries[241].get_mut(&inp[..]) { debug_assert_eq!(result.output, &__ret[..]); if !unconstrained { *result.multiplicity += G::ONE; } } else { record.function_queries[241].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained)); }; + let __ret: [G; OUT_237] = [__v_15]; + if let Some(result) = record.function_queries[237].get_mut(&inp[..]) { debug_assert_eq!(result.output, &__ret[..]); if !unconstrained { *result.multiplicity += G::ONE; } } else { record.function_queries[237].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained)); }; return Ok(__ret); }, _ => { @@ -22751,8 +22477,8 @@ fn aiur_fn_241( match __v_16.as_canonical_u64() { 1u64 => { let __v_17: G = G::from_u64(1); - let __ret: [G; OUT_241] = [__v_17]; - if let Some(result) = record.function_queries[241].get_mut(&inp[..]) { debug_assert_eq!(result.output, &__ret[..]); if !unconstrained { *result.multiplicity += G::ONE; } } else { record.function_queries[241].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained)); }; + let __ret: [G; OUT_237] = [__v_17]; + if let Some(result) = record.function_queries[237].get_mut(&inp[..]) { debug_assert_eq!(result.output, &__ret[..]); if !unconstrained { *result.multiplicity += G::ONE; } } else { record.function_queries[237].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained)); }; return Ok(__ret); }, _ => { @@ -22763,8 +22489,8 @@ fn aiur_fn_241( match __v_18.as_canonical_u64() { 1u64 => { let __v_19: G = G::from_u64(1); - let __ret: [G; OUT_241] = [__v_19]; - if let Some(result) = record.function_queries[241].get_mut(&inp[..]) { debug_assert_eq!(result.output, &__ret[..]); if !unconstrained { *result.multiplicity += G::ONE; } } else { record.function_queries[241].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained)); }; + let __ret: [G; OUT_237] = [__v_19]; + if let Some(result) = record.function_queries[237].get_mut(&inp[..]) { debug_assert_eq!(result.output, &__ret[..]); if !unconstrained { *result.multiplicity += G::ONE; } } else { record.function_queries[237].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained)); }; return Ok(__ret); }, _ => { @@ -22775,8 +22501,8 @@ fn aiur_fn_241( match __v_20.as_canonical_u64() { 1u64 => { let __v_21: G = G::from_u64(1); - let __ret: [G; OUT_241] = [__v_21]; - if let Some(result) = record.function_queries[241].get_mut(&inp[..]) { debug_assert_eq!(result.output, &__ret[..]); if !unconstrained { *result.multiplicity += G::ONE; } } else { record.function_queries[241].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained)); }; + let __ret: [G; OUT_237] = [__v_21]; + if let Some(result) = record.function_queries[237].get_mut(&inp[..]) { debug_assert_eq!(result.output, &__ret[..]); if !unconstrained { *result.multiplicity += G::ONE; } } else { record.function_queries[237].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained)); }; return Ok(__ret); }, _ => { @@ -22787,8 +22513,8 @@ fn aiur_fn_241( match __v_22.as_canonical_u64() { 1u64 => { let __v_23: G = G::from_u64(1); - let __ret: [G; OUT_241] = [__v_23]; - if let Some(result) = record.function_queries[241].get_mut(&inp[..]) { debug_assert_eq!(result.output, &__ret[..]); if !unconstrained { *result.multiplicity += G::ONE; } } else { record.function_queries[241].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained)); }; + let __ret: [G; OUT_237] = [__v_23]; + if let Some(result) = record.function_queries[237].get_mut(&inp[..]) { debug_assert_eq!(result.output, &__ret[..]); if !unconstrained { *result.multiplicity += G::ONE; } } else { record.function_queries[237].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained)); }; return Ok(__ret); }, _ => { @@ -22799,8 +22525,8 @@ fn aiur_fn_241( match __v_24.as_canonical_u64() { 1u64 => { let __v_25: G = G::from_u64(1); - let __ret: [G; OUT_241] = [__v_25]; - if let Some(result) = record.function_queries[241].get_mut(&inp[..]) { debug_assert_eq!(result.output, &__ret[..]); if !unconstrained { *result.multiplicity += G::ONE; } } else { record.function_queries[241].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained)); }; + let __ret: [G; OUT_237] = [__v_25]; + if let Some(result) = record.function_queries[237].get_mut(&inp[..]) { debug_assert_eq!(result.output, &__ret[..]); if !unconstrained { *result.multiplicity += G::ONE; } } else { record.function_queries[237].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained)); }; return Ok(__ret); }, _ => { @@ -22811,8 +22537,8 @@ fn aiur_fn_241( match __v_26.as_canonical_u64() { 1u64 => { let __v_27: G = G::from_u64(1); - let __ret: [G; OUT_241] = [__v_27]; - if let Some(result) = record.function_queries[241].get_mut(&inp[..]) { debug_assert_eq!(result.output, &__ret[..]); if !unconstrained { *result.multiplicity += G::ONE; } } else { record.function_queries[241].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained)); }; + let __ret: [G; OUT_237] = [__v_27]; + if let Some(result) = record.function_queries[237].get_mut(&inp[..]) { debug_assert_eq!(result.output, &__ret[..]); if !unconstrained { *result.multiplicity += G::ONE; } } else { record.function_queries[237].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained)); }; return Ok(__ret); }, _ => { @@ -22823,8 +22549,8 @@ fn aiur_fn_241( match __v_28.as_canonical_u64() { 1u64 => { let __v_29: G = G::from_u64(1); - let __ret: [G; OUT_241] = [__v_29]; - if let Some(result) = record.function_queries[241].get_mut(&inp[..]) { debug_assert_eq!(result.output, &__ret[..]); if !unconstrained { *result.multiplicity += G::ONE; } } else { record.function_queries[241].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained)); }; + let __ret: [G; OUT_237] = [__v_29]; + if let Some(result) = record.function_queries[237].get_mut(&inp[..]) { debug_assert_eq!(result.output, &__ret[..]); if !unconstrained { *result.multiplicity += G::ONE; } } else { record.function_queries[237].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained)); }; return Ok(__ret); }, _ => { @@ -22835,8 +22561,8 @@ fn aiur_fn_241( match __v_30.as_canonical_u64() { 1u64 => { let __v_31: G = G::from_u64(1); - let __ret: [G; OUT_241] = [__v_31]; - if let Some(result) = record.function_queries[241].get_mut(&inp[..]) { debug_assert_eq!(result.output, &__ret[..]); if !unconstrained { *result.multiplicity += G::ONE; } } else { record.function_queries[241].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained)); }; + let __ret: [G; OUT_237] = [__v_31]; + if let Some(result) = record.function_queries[237].get_mut(&inp[..]) { debug_assert_eq!(result.output, &__ret[..]); if !unconstrained { *result.multiplicity += G::ONE; } } else { record.function_queries[237].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained)); }; return Ok(__ret); }, _ => { @@ -22847,14 +22573,14 @@ fn aiur_fn_241( match __v_32.as_canonical_u64() { 1u64 => { let __v_33: G = G::from_u64(1); - let __ret: [G; OUT_241] = [__v_33]; - if let Some(result) = record.function_queries[241].get_mut(&inp[..]) { debug_assert_eq!(result.output, &__ret[..]); if !unconstrained { *result.multiplicity += G::ONE; } } else { record.function_queries[241].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained)); }; + let __ret: [G; OUT_237] = [__v_33]; + if let Some(result) = record.function_queries[237].get_mut(&inp[..]) { debug_assert_eq!(result.output, &__ret[..]); if !unconstrained { *result.multiplicity += G::ONE; } } else { record.function_queries[237].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained)); }; return Ok(__ret); }, _ => { let __v_33: G = G::from_u64(0); - let __ret: [G; OUT_241] = [__v_33]; - if let Some(result) = record.function_queries[241].get_mut(&inp[..]) { debug_assert_eq!(result.output, &__ret[..]); if !unconstrained { *result.multiplicity += G::ONE; } } else { record.function_queries[241].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained)); }; + let __ret: [G; OUT_237] = [__v_33]; + if let Some(result) = record.function_queries[237].get_mut(&inp[..]) { debug_assert_eq!(result.output, &__ret[..]); if !unconstrained { *result.multiplicity += G::ONE; } } else { record.function_queries[237].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained)); }; return Ok(__ret); }, } @@ -22891,15 +22617,15 @@ fn aiur_fn_241( }) } -const INPUT_SIZE_242: usize = 1; -const IN_242: usize = 1; -const OUT_242: usize = 1; -fn aiur_fn_242( - inp: [G; IN_242], +const INPUT_SIZE_238: usize = 1; +const IN_238: usize = 1; +const OUT_238: usize = 1; +fn aiur_fn_238( + inp: [G; IN_238], record: &mut QueryRecord, io_buffer: &mut IOBuffer, unconstrained: bool, -) -> Result<[G; OUT_242], ExecError> { +) -> Result<[G; OUT_238], ExecError> { stacker::maybe_grow(64 * 1024, 4 * 1024 * 1024, || { let __v_0: G = inp[0]; let __r_arr: [G; OUT_148] = { let __args: [G; IN_148] = []; let __cu = unconstrained; if let Some(result) = record.function_queries[148].get_mut(&__args[..]) { if !__cu && *result.multiplicity == G::ZERO { aiur_fn_148(__args, record, io_buffer, false)? } else { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_148] = unsafe { *(result.output.as_ptr() as *const [G; OUT_148]) }; __ret } } else { aiur_fn_148(__args, record, io_buffer, __cu)? } }; @@ -22951,21 +22677,21 @@ fn aiur_fn_242( let __v_27: G = (__v_6 + __v_26); let __v_28: G = (__v_4 + __v_27); let __v_29: G = (__v_2 + __v_28); - let __ret: [G; OUT_242] = [__v_29]; - if let Some(result) = record.function_queries[242].get_mut(&inp[..]) { debug_assert_eq!(result.output, &__ret[..]); if !unconstrained { *result.multiplicity += G::ONE; } } else { record.function_queries[242].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained)); }; + let __ret: [G; OUT_238] = [__v_29]; + if let Some(result) = record.function_queries[238].get_mut(&inp[..]) { debug_assert_eq!(result.output, &__ret[..]); if !unconstrained { *result.multiplicity += G::ONE; } } else { record.function_queries[238].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained)); }; return Ok(__ret); }) } -const INPUT_SIZE_243: usize = 1; -const IN_243: usize = 1; -const OUT_243: usize = 2; -fn aiur_fn_243( - inp: [G; IN_243], +const INPUT_SIZE_239: usize = 1; +const IN_239: usize = 1; +const OUT_239: usize = 2; +fn aiur_fn_239( + inp: [G; IN_239], record: &mut QueryRecord, io_buffer: &mut IOBuffer, unconstrained: bool, -) -> Result<[G; OUT_243], ExecError> { +) -> Result<[G; OUT_239], ExecError> { stacker::maybe_grow(64 * 1024, 4 * 1024 * 1024, || { let __v_0: G = inp[0]; let __loaded: [G; 4] = { let __mq = record.memory_queries.get_mut(&4).ok_or(ExecError::InvalidMemorySize(4))?; let __ptr_u64 = __v_0.as_canonical_u64(); let __ptr_usize = usize::try_from(__ptr_u64).ok().ok_or(ExecError::PointerTooLarge(__ptr_u64))?; let (__args, __mult) = __mq.get_index_mut(__ptr_usize).ok_or(ExecError::UnboundPointer { ptr: __ptr_u64, size: 4 })?; if !unconstrained { *__mult += G::ONE; } let __arr: [G; 4] = __args[..4].try_into().unwrap(); __arr }; @@ -22978,8 +22704,8 @@ fn aiur_fn_243( match __v_2.as_canonical_u64() { 0u64 => { let __v_5: G = G::from_u64(1); - let __ret: [G; OUT_243] = [__v_5, __v_3]; - if let Some(result) = record.function_queries[243].get_mut(&inp[..]) { debug_assert_eq!(result.output, &__ret[..]); if !unconstrained { *result.multiplicity += G::ONE; } } else { record.function_queries[243].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained)); }; + let __ret: [G; OUT_239] = [__v_5, __v_3]; + if let Some(result) = record.function_queries[239].get_mut(&inp[..]) { debug_assert_eq!(result.output, &__ret[..]); if !unconstrained { *result.multiplicity += G::ONE; } } else { record.function_queries[239].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained)); }; return Ok(__ret); }, _ => { @@ -22987,8 +22713,8 @@ fn aiur_fn_243( let __v_6: G = G::from_u64(1); let __v_7: G = G::from_u64(1); let __v_8: G = { let __values: [G; 10] = [__v_6, __v_7, __v_7, __v_7, __v_7, __v_7, __v_7, __v_7, __v_7, __v_7]; let __mq = record.memory_queries.get_mut(&10).ok_or(ExecError::InvalidMemorySize(10))?; if let Some(result) = __mq.get_mut(&__values[..]) { if !unconstrained { *result.multiplicity += G::ONE; } result.output[0] } else { let __ptr = G::from_usize(__mq.len()); __mq.insert(&__values[..], &[__ptr], G::from_bool(!unconstrained)); __ptr } }; - let __ret: [G; OUT_243] = [__v_5, __v_8]; - if let Some(result) = record.function_queries[243].get_mut(&inp[..]) { debug_assert_eq!(result.output, &__ret[..]); if !unconstrained { *result.multiplicity += G::ONE; } } else { record.function_queries[243].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained)); }; + let __ret: [G; OUT_239] = [__v_5, __v_8]; + if let Some(result) = record.function_queries[239].get_mut(&inp[..]) { debug_assert_eq!(result.output, &__ret[..]); if !unconstrained { *result.multiplicity += G::ONE; } } else { record.function_queries[239].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained)); }; return Ok(__ret); }, } @@ -23004,8 +22730,8 @@ fn aiur_fn_243( let __v_8: G = G::from_u64(1); let __v_9: G = G::from_u64(1); let __v_10: G = { let __values: [G; 10] = [__v_8, __v_9, __v_9, __v_9, __v_9, __v_9, __v_9, __v_9, __v_9, __v_9]; let __mq = record.memory_queries.get_mut(&10).ok_or(ExecError::InvalidMemorySize(10))?; if let Some(result) = __mq.get_mut(&__values[..]) { if !unconstrained { *result.multiplicity += G::ONE; } result.output[0] } else { let __ptr = G::from_usize(__mq.len()); __mq.insert(&__values[..], &[__ptr], G::from_bool(!unconstrained)); __ptr } }; - let __ret: [G; OUT_243] = [__v_7, __v_10]; - if let Some(result) = record.function_queries[243].get_mut(&inp[..]) { debug_assert_eq!(result.output, &__ret[..]); if !unconstrained { *result.multiplicity += G::ONE; } } else { record.function_queries[243].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained)); }; + let __ret: [G; OUT_239] = [__v_7, __v_10]; + if let Some(result) = record.function_queries[239].get_mut(&inp[..]) { debug_assert_eq!(result.output, &__ret[..]); if !unconstrained { *result.multiplicity += G::ONE; } } else { record.function_queries[239].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained)); }; return Ok(__ret); }, _ => { @@ -23013,18 +22739,18 @@ fn aiur_fn_243( let __v_8: G = G::from_u64(1); let __v_9: G = G::from_u64(1); let __v_10: G = { let __values: [G; 10] = [__v_8, __v_9, __v_9, __v_9, __v_9, __v_9, __v_9, __v_9, __v_9, __v_9]; let __mq = record.memory_queries.get_mut(&10).ok_or(ExecError::InvalidMemorySize(10))?; if let Some(result) = __mq.get_mut(&__values[..]) { if !unconstrained { *result.multiplicity += G::ONE; } result.output[0] } else { let __ptr = G::from_usize(__mq.len()); __mq.insert(&__values[..], &[__ptr], G::from_bool(!unconstrained)); __ptr } }; - let __ret: [G; OUT_243] = [__v_7, __v_10]; - if let Some(result) = record.function_queries[243].get_mut(&inp[..]) { debug_assert_eq!(result.output, &__ret[..]); if !unconstrained { *result.multiplicity += G::ONE; } } else { record.function_queries[243].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained)); }; + let __ret: [G; OUT_239] = [__v_7, __v_10]; + if let Some(result) = record.function_queries[239].get_mut(&inp[..]) { debug_assert_eq!(result.output, &__ret[..]); if !unconstrained { *result.multiplicity += G::ONE; } } else { record.function_queries[239].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained)); }; return Ok(__ret); }, } }, 3u64 => { - let __r_arr: [G; OUT_244] = { let __args: [G; IN_244] = [__v_2, __v_3]; let __cu = unconstrained; if let Some(result) = record.function_queries[244].get_mut(&__args[..]) { if !__cu && *result.multiplicity == G::ZERO { aiur_fn_244(__args, record, io_buffer, false)? } else { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_244] = unsafe { *(result.output.as_ptr() as *const [G; OUT_244]) }; __ret } } else { aiur_fn_244(__args, record, io_buffer, __cu)? } }; + let __r_arr: [G; OUT_240] = { let __args: [G; IN_240] = [__v_2, __v_3]; let __cu = unconstrained; if let Some(result) = record.function_queries[240].get_mut(&__args[..]) { if !__cu && *result.multiplicity == G::ZERO { aiur_fn_240(__args, record, io_buffer, false)? } else { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_240] = unsafe { *(result.output.as_ptr() as *const [G; OUT_240]) }; __ret } } else { aiur_fn_240(__args, record, io_buffer, __cu)? } }; let __v_5: G = __r_arr[0]; let __v_6: G = __r_arr[1]; - let __ret: [G; OUT_243] = [__v_5, __v_6]; - if let Some(result) = record.function_queries[243].get_mut(&inp[..]) { debug_assert_eq!(result.output, &__ret[..]); if !unconstrained { *result.multiplicity += G::ONE; } } else { record.function_queries[243].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained)); }; + let __ret: [G; OUT_239] = [__v_5, __v_6]; + if let Some(result) = record.function_queries[239].get_mut(&inp[..]) { debug_assert_eq!(result.output, &__ret[..]); if !unconstrained { *result.multiplicity += G::ONE; } } else { record.function_queries[239].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained)); }; return Ok(__ret); }, _ => { @@ -23032,23 +22758,23 @@ fn aiur_fn_243( let __v_6: G = G::from_u64(1); let __v_7: G = G::from_u64(1); let __v_8: G = { let __values: [G; 10] = [__v_6, __v_7, __v_7, __v_7, __v_7, __v_7, __v_7, __v_7, __v_7, __v_7]; let __mq = record.memory_queries.get_mut(&10).ok_or(ExecError::InvalidMemorySize(10))?; if let Some(result) = __mq.get_mut(&__values[..]) { if !unconstrained { *result.multiplicity += G::ONE; } result.output[0] } else { let __ptr = G::from_usize(__mq.len()); __mq.insert(&__values[..], &[__ptr], G::from_bool(!unconstrained)); __ptr } }; - let __ret: [G; OUT_243] = [__v_5, __v_8]; - if let Some(result) = record.function_queries[243].get_mut(&inp[..]) { debug_assert_eq!(result.output, &__ret[..]); if !unconstrained { *result.multiplicity += G::ONE; } } else { record.function_queries[243].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained)); }; + let __ret: [G; OUT_239] = [__v_5, __v_8]; + if let Some(result) = record.function_queries[239].get_mut(&inp[..]) { debug_assert_eq!(result.output, &__ret[..]); if !unconstrained { *result.multiplicity += G::ONE; } } else { record.function_queries[239].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained)); }; return Ok(__ret); }, } }) } -const INPUT_SIZE_244: usize = 2; -const IN_244: usize = 2; -const OUT_244: usize = 2; -fn aiur_fn_244( - inp: [G; IN_244], +const INPUT_SIZE_240: usize = 2; +const IN_240: usize = 2; +const OUT_240: usize = 2; +fn aiur_fn_240( + inp: [G; IN_240], record: &mut QueryRecord, io_buffer: &mut IOBuffer, unconstrained: bool, -) -> Result<[G; OUT_244], ExecError> { +) -> Result<[G; OUT_240], ExecError> { stacker::maybe_grow(64 * 1024, 4 * 1024 * 1024, || { let __v_0: G = inp[0]; let __v_1: G = inp[1]; @@ -23065,7 +22791,7 @@ fn aiur_fn_244( let __v_7: G = __r_arr[0]; match __v_7.as_canonical_u64() { 1u64 => { - let __r_arr: [G; OUT_243] = { let __args: [G; IN_243] = [__v_1]; let __cu = unconstrained; if let Some(result) = record.function_queries[243].get_mut(&__args[..]) { if !__cu && *result.multiplicity == G::ZERO { aiur_fn_243(__args, record, io_buffer, false)? } else { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_243] = unsafe { *(result.output.as_ptr() as *const [G; OUT_243]) }; __ret } } else { aiur_fn_243(__args, record, io_buffer, __cu)? } }; + let __r_arr: [G; OUT_239] = { let __args: [G; IN_239] = [__v_1]; let __cu = unconstrained; if let Some(result) = record.function_queries[239].get_mut(&__args[..]) { if !__cu && *result.multiplicity == G::ZERO { aiur_fn_239(__args, record, io_buffer, false)? } else { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_239] = unsafe { *(result.output.as_ptr() as *const [G; OUT_239]) }; __ret } } else { aiur_fn_239(__args, record, io_buffer, __cu)? } }; let __v_8: G = __r_arr[0]; let __v_9: G = __r_arr[1]; match __v_8.as_canonical_u64() { @@ -23073,8 +22799,8 @@ fn aiur_fn_244( let __v_10: G = G::from_u64(1); let __r_arr: [G; OUT_112] = { let __args: [G; IN_112] = [__v_9]; let __cu = unconstrained; if let Some(result) = record.function_queries[112].get_mut(&__args[..]) { if !__cu && *result.multiplicity == G::ZERO { aiur_fn_112(__args, record, io_buffer, false)? } else { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_112] = unsafe { *(result.output.as_ptr() as *const [G; OUT_112]) }; __ret } } else { aiur_fn_112(__args, record, io_buffer, __cu)? } }; let __v_11: G = __r_arr[0]; - let __ret: [G; OUT_244] = [__v_10, __v_11]; - if let Some(result) = record.function_queries[244].get_mut(&inp[..]) { debug_assert_eq!(result.output, &__ret[..]); if !unconstrained { *result.multiplicity += G::ONE; } } else { record.function_queries[244].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained)); }; + let __ret: [G; OUT_240] = [__v_10, __v_11]; + if let Some(result) = record.function_queries[240].get_mut(&inp[..]) { debug_assert_eq!(result.output, &__ret[..]); if !unconstrained { *result.multiplicity += G::ONE; } } else { record.function_queries[240].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained)); }; return Ok(__ret); }, _ => { @@ -23082,8 +22808,8 @@ fn aiur_fn_244( let __v_11: G = G::from_u64(1); let __v_12: G = G::from_u64(1); let __v_13: G = { let __values: [G; 10] = [__v_11, __v_12, __v_12, __v_12, __v_12, __v_12, __v_12, __v_12, __v_12, __v_12]; let __mq = record.memory_queries.get_mut(&10).ok_or(ExecError::InvalidMemorySize(10))?; if let Some(result) = __mq.get_mut(&__values[..]) { if !unconstrained { *result.multiplicity += G::ONE; } result.output[0] } else { let __ptr = G::from_usize(__mq.len()); __mq.insert(&__values[..], &[__ptr], G::from_bool(!unconstrained)); __ptr } }; - let __ret: [G; OUT_244] = [__v_10, __v_13]; - if let Some(result) = record.function_queries[244].get_mut(&inp[..]) { debug_assert_eq!(result.output, &__ret[..]); if !unconstrained { *result.multiplicity += G::ONE; } } else { record.function_queries[244].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained)); }; + let __ret: [G; OUT_240] = [__v_10, __v_13]; + if let Some(result) = record.function_queries[240].get_mut(&inp[..]) { debug_assert_eq!(result.output, &__ret[..]); if !unconstrained { *result.multiplicity += G::ONE; } } else { record.function_queries[240].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained)); }; return Ok(__ret); }, } @@ -23093,8 +22819,8 @@ fn aiur_fn_244( let __v_9: G = G::from_u64(1); let __v_10: G = G::from_u64(1); let __v_11: G = { let __values: [G; 10] = [__v_9, __v_10, __v_10, __v_10, __v_10, __v_10, __v_10, __v_10, __v_10, __v_10]; let __mq = record.memory_queries.get_mut(&10).ok_or(ExecError::InvalidMemorySize(10))?; if let Some(result) = __mq.get_mut(&__values[..]) { if !unconstrained { *result.multiplicity += G::ONE; } result.output[0] } else { let __ptr = G::from_usize(__mq.len()); __mq.insert(&__values[..], &[__ptr], G::from_bool(!unconstrained)); __ptr } }; - let __ret: [G; OUT_244] = [__v_8, __v_11]; - if let Some(result) = record.function_queries[244].get_mut(&inp[..]) { debug_assert_eq!(result.output, &__ret[..]); if !unconstrained { *result.multiplicity += G::ONE; } } else { record.function_queries[244].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained)); }; + let __ret: [G; OUT_240] = [__v_8, __v_11]; + if let Some(result) = record.function_queries[240].get_mut(&inp[..]) { debug_assert_eq!(result.output, &__ret[..]); if !unconstrained { *result.multiplicity += G::ONE; } } else { record.function_queries[240].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained)); }; return Ok(__ret); }, } @@ -23104,44 +22830,44 @@ fn aiur_fn_244( let __v_7: G = G::from_u64(1); let __v_8: G = G::from_u64(1); let __v_9: G = { let __values: [G; 10] = [__v_7, __v_8, __v_8, __v_8, __v_8, __v_8, __v_8, __v_8, __v_8, __v_8]; let __mq = record.memory_queries.get_mut(&10).ok_or(ExecError::InvalidMemorySize(10))?; if let Some(result) = __mq.get_mut(&__values[..]) { if !unconstrained { *result.multiplicity += G::ONE; } result.output[0] } else { let __ptr = G::from_usize(__mq.len()); __mq.insert(&__values[..], &[__ptr], G::from_bool(!unconstrained)); __ptr } }; - let __ret: [G; OUT_244] = [__v_6, __v_9]; - if let Some(result) = record.function_queries[244].get_mut(&inp[..]) { debug_assert_eq!(result.output, &__ret[..]); if !unconstrained { *result.multiplicity += G::ONE; } } else { record.function_queries[244].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained)); }; + let __ret: [G; OUT_240] = [__v_6, __v_9]; + if let Some(result) = record.function_queries[240].get_mut(&inp[..]) { debug_assert_eq!(result.output, &__ret[..]); if !unconstrained { *result.multiplicity += G::ONE; } } else { record.function_queries[240].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained)); }; return Ok(__ret); }, } }) } -const INPUT_SIZE_245: usize = 1; -const IN_245: usize = 1; -const OUT_245: usize = 1; -fn aiur_fn_245( - inp: [G; IN_245], +const INPUT_SIZE_241: usize = 1; +const IN_241: usize = 1; +const OUT_241: usize = 1; +fn aiur_fn_241( + inp: [G; IN_241], record: &mut QueryRecord, io_buffer: &mut IOBuffer, unconstrained: bool, -) -> Result<[G; OUT_245], ExecError> { +) -> Result<[G; OUT_241], ExecError> { stacker::maybe_grow(64 * 1024, 4 * 1024 * 1024, || { let __v_0: G = inp[0]; let __v_1: G = G::from_u64(7); let __v_2: G = G::from_u64(0); let __v_3: G = G::from_u64(0); let __v_4: G = { let __values: [G; 4] = [__v_1, __v_2, __v_0, __v_3]; let __mq = record.memory_queries.get_mut(&4).ok_or(ExecError::InvalidMemorySize(4))?; if let Some(result) = __mq.get_mut(&__values[..]) { if !unconstrained { *result.multiplicity += G::ONE; } result.output[0] } else { let __ptr = G::from_usize(__mq.len()); __mq.insert(&__values[..], &[__ptr], G::from_bool(!unconstrained)); __ptr } }; - let __ret: [G; OUT_245] = [__v_4]; - if let Some(result) = record.function_queries[245].get_mut(&inp[..]) { debug_assert_eq!(result.output, &__ret[..]); if !unconstrained { *result.multiplicity += G::ONE; } } else { record.function_queries[245].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained)); }; + let __ret: [G; OUT_241] = [__v_4]; + if let Some(result) = record.function_queries[241].get_mut(&inp[..]) { debug_assert_eq!(result.output, &__ret[..]); if !unconstrained { *result.multiplicity += G::ONE; } } else { record.function_queries[241].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained)); }; return Ok(__ret); }) } -const INPUT_SIZE_246: usize = 1; -const IN_246: usize = 1; -const OUT_246: usize = 3; -fn aiur_fn_246( - inp: [G; IN_246], +const INPUT_SIZE_242: usize = 1; +const IN_242: usize = 1; +const OUT_242: usize = 3; +fn aiur_fn_242( + inp: [G; IN_242], record: &mut QueryRecord, io_buffer: &mut IOBuffer, unconstrained: bool, -) -> Result<[G; OUT_246], ExecError> { +) -> Result<[G; OUT_242], ExecError> { stacker::maybe_grow(64 * 1024, 4 * 1024 * 1024, || { let __v_0: G = inp[0]; let __loaded: [G; 4] = { let __mq = record.memory_queries.get_mut(&4).ok_or(ExecError::InvalidMemorySize(4))?; let __ptr_u64 = __v_0.as_canonical_u64(); let __ptr_usize = usize::try_from(__ptr_u64).ok().ok_or(ExecError::PointerTooLarge(__ptr_u64))?; let (__args, __mult) = __mq.get_index_mut(__ptr_usize).ok_or(ExecError::UnboundPointer { ptr: __ptr_u64, size: 4 })?; if !unconstrained { *__mult += G::ONE; } let __arr: [G; 4] = __args[..4].try_into().unwrap(); __arr }; @@ -23158,7 +22884,7 @@ fn aiur_fn_246( let __v_8: G = __loaded[3]; match __v_5.as_canonical_u64() { 2u64 => { - let __r_arr: [G; OUT_243] = { let __args: [G; IN_243] = [__v_3]; let __cu = unconstrained; if let Some(result) = record.function_queries[243].get_mut(&__args[..]) { if !__cu && *result.multiplicity == G::ZERO { aiur_fn_243(__args, record, io_buffer, false)? } else { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_243] = unsafe { *(result.output.as_ptr() as *const [G; OUT_243]) }; __ret } } else { aiur_fn_243(__args, record, io_buffer, __cu)? } }; + let __r_arr: [G; OUT_239] = { let __args: [G; IN_239] = [__v_3]; let __cu = unconstrained; if let Some(result) = record.function_queries[239].get_mut(&__args[..]) { if !__cu && *result.multiplicity == G::ZERO { aiur_fn_239(__args, record, io_buffer, false)? } else { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_239] = unsafe { *(result.output.as_ptr() as *const [G; OUT_239]) }; __ret } } else { aiur_fn_239(__args, record, io_buffer, __cu)? } }; let __v_9: G = __r_arr[0]; let __v_10: G = __r_arr[1]; match __v_9.as_canonical_u64() { @@ -23173,8 +22899,8 @@ fn aiur_fn_246( let __v_14: G = G::from_u64(0); let __r_arr: [G; OUT_118] = { let __args: [G; IN_118] = [__v_10]; let __cu = unconstrained; if let Some(result) = record.function_queries[118].get_mut(&__args[..]) { if !__cu && *result.multiplicity == G::ZERO { aiur_fn_118(__args, record, io_buffer, false)? } else { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_118] = unsafe { *(result.output.as_ptr() as *const [G; OUT_118]) }; __ret } } else { aiur_fn_118(__args, record, io_buffer, __cu)? } }; let __v_15: G = __r_arr[0]; - let __ret: [G; OUT_246] = [__v_13, __v_14, __v_15]; - if let Some(result) = record.function_queries[246].get_mut(&inp[..]) { debug_assert_eq!(result.output, &__ret[..]); if !unconstrained { *result.multiplicity += G::ONE; } } else { record.function_queries[246].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained)); }; + let __ret: [G; OUT_242] = [__v_13, __v_14, __v_15]; + if let Some(result) = record.function_queries[242].get_mut(&inp[..]) { debug_assert_eq!(result.output, &__ret[..]); if !unconstrained { *result.multiplicity += G::ONE; } } else { record.function_queries[242].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained)); }; return Ok(__ret); }, _ => { @@ -23190,8 +22916,8 @@ fn aiur_fn_246( let __v_17: G = __r_arr[0]; let __r_arr: [G; OUT_118] = { let __args: [G; IN_118] = [__v_17]; let __cu = unconstrained; if let Some(result) = record.function_queries[118].get_mut(&__args[..]) { if !__cu && *result.multiplicity == G::ZERO { aiur_fn_118(__args, record, io_buffer, false)? } else { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_118] = unsafe { *(result.output.as_ptr() as *const [G; OUT_118]) }; __ret } } else { aiur_fn_118(__args, record, io_buffer, __cu)? } }; let __v_18: G = __r_arr[0]; - let __ret: [G; OUT_246] = [__v_15, __v_16, __v_18]; - if let Some(result) = record.function_queries[246].get_mut(&inp[..]) { debug_assert_eq!(result.output, &__ret[..]); if !unconstrained { *result.multiplicity += G::ONE; } } else { record.function_queries[246].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained)); }; + let __ret: [G; OUT_242] = [__v_15, __v_16, __v_18]; + if let Some(result) = record.function_queries[242].get_mut(&inp[..]) { debug_assert_eq!(result.output, &__ret[..]); if !unconstrained { *result.multiplicity += G::ONE; } } else { record.function_queries[242].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained)); }; return Ok(__ret); }, _ => { @@ -23200,8 +22926,8 @@ fn aiur_fn_246( let __v_17: G = G::from_u64(1); let __v_18: G = G::from_u64(1); let __v_19: G = { let __values: [G; 10] = [__v_17, __v_18, __v_18, __v_18, __v_18, __v_18, __v_18, __v_18, __v_18, __v_18]; let __mq = record.memory_queries.get_mut(&10).ok_or(ExecError::InvalidMemorySize(10))?; if let Some(result) = __mq.get_mut(&__values[..]) { if !unconstrained { *result.multiplicity += G::ONE; } result.output[0] } else { let __ptr = G::from_usize(__mq.len()); __mq.insert(&__values[..], &[__ptr], G::from_bool(!unconstrained)); __ptr } }; - let __ret: [G; OUT_246] = [__v_15, __v_16, __v_19]; - if let Some(result) = record.function_queries[246].get_mut(&inp[..]) { debug_assert_eq!(result.output, &__ret[..]); if !unconstrained { *result.multiplicity += G::ONE; } } else { record.function_queries[246].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained)); }; + let __ret: [G; OUT_242] = [__v_15, __v_16, __v_19]; + if let Some(result) = record.function_queries[242].get_mut(&inp[..]) { debug_assert_eq!(result.output, &__ret[..]); if !unconstrained { *result.multiplicity += G::ONE; } } else { record.function_queries[242].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained)); }; return Ok(__ret); }, } @@ -23214,8 +22940,8 @@ fn aiur_fn_246( let __v_13: G = G::from_u64(1); let __v_14: G = G::from_u64(1); let __v_15: G = { let __values: [G; 10] = [__v_13, __v_14, __v_14, __v_14, __v_14, __v_14, __v_14, __v_14, __v_14, __v_14]; let __mq = record.memory_queries.get_mut(&10).ok_or(ExecError::InvalidMemorySize(10))?; if let Some(result) = __mq.get_mut(&__values[..]) { if !unconstrained { *result.multiplicity += G::ONE; } result.output[0] } else { let __ptr = G::from_usize(__mq.len()); __mq.insert(&__values[..], &[__ptr], G::from_bool(!unconstrained)); __ptr } }; - let __ret: [G; OUT_246] = [__v_11, __v_12, __v_15]; - if let Some(result) = record.function_queries[246].get_mut(&inp[..]) { debug_assert_eq!(result.output, &__ret[..]); if !unconstrained { *result.multiplicity += G::ONE; } } else { record.function_queries[246].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained)); }; + let __ret: [G; OUT_242] = [__v_11, __v_12, __v_15]; + if let Some(result) = record.function_queries[242].get_mut(&inp[..]) { debug_assert_eq!(result.output, &__ret[..]); if !unconstrained { *result.multiplicity += G::ONE; } } else { record.function_queries[242].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained)); }; return Ok(__ret); }, } @@ -23226,8 +22952,8 @@ fn aiur_fn_246( let __v_11: G = G::from_u64(1); let __v_12: G = G::from_u64(1); let __v_13: G = { let __values: [G; 10] = [__v_11, __v_12, __v_12, __v_12, __v_12, __v_12, __v_12, __v_12, __v_12, __v_12]; let __mq = record.memory_queries.get_mut(&10).ok_or(ExecError::InvalidMemorySize(10))?; if let Some(result) = __mq.get_mut(&__values[..]) { if !unconstrained { *result.multiplicity += G::ONE; } result.output[0] } else { let __ptr = G::from_usize(__mq.len()); __mq.insert(&__values[..], &[__ptr], G::from_bool(!unconstrained)); __ptr } }; - let __ret: [G; OUT_246] = [__v_9, __v_10, __v_13]; - if let Some(result) = record.function_queries[246].get_mut(&inp[..]) { debug_assert_eq!(result.output, &__ret[..]); if !unconstrained { *result.multiplicity += G::ONE; } } else { record.function_queries[246].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained)); }; + let __ret: [G; OUT_242] = [__v_9, __v_10, __v_13]; + if let Some(result) = record.function_queries[242].get_mut(&inp[..]) { debug_assert_eq!(result.output, &__ret[..]); if !unconstrained { *result.multiplicity += G::ONE; } } else { record.function_queries[242].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained)); }; return Ok(__ret); }, } @@ -23238,23 +22964,23 @@ fn aiur_fn_246( let __v_7: G = G::from_u64(1); let __v_8: G = G::from_u64(1); let __v_9: G = { let __values: [G; 10] = [__v_7, __v_8, __v_8, __v_8, __v_8, __v_8, __v_8, __v_8, __v_8, __v_8]; let __mq = record.memory_queries.get_mut(&10).ok_or(ExecError::InvalidMemorySize(10))?; if let Some(result) = __mq.get_mut(&__values[..]) { if !unconstrained { *result.multiplicity += G::ONE; } result.output[0] } else { let __ptr = G::from_usize(__mq.len()); __mq.insert(&__values[..], &[__ptr], G::from_bool(!unconstrained)); __ptr } }; - let __ret: [G; OUT_246] = [__v_5, __v_6, __v_9]; - if let Some(result) = record.function_queries[246].get_mut(&inp[..]) { debug_assert_eq!(result.output, &__ret[..]); if !unconstrained { *result.multiplicity += G::ONE; } } else { record.function_queries[246].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained)); }; + let __ret: [G; OUT_242] = [__v_5, __v_6, __v_9]; + if let Some(result) = record.function_queries[242].get_mut(&inp[..]) { debug_assert_eq!(result.output, &__ret[..]); if !unconstrained { *result.multiplicity += G::ONE; } } else { record.function_queries[242].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained)); }; return Ok(__ret); }, } }) } -const INPUT_SIZE_247: usize = 2; -const IN_247: usize = 2; -const OUT_247: usize = 1; -fn aiur_fn_247( - inp: [G; IN_247], +const INPUT_SIZE_243: usize = 2; +const IN_243: usize = 2; +const OUT_243: usize = 1; +fn aiur_fn_243( + inp: [G; IN_243], record: &mut QueryRecord, io_buffer: &mut IOBuffer, unconstrained: bool, -) -> Result<[G; OUT_247], ExecError> { +) -> Result<[G; OUT_243], ExecError> { stacker::maybe_grow(64 * 1024, 4 * 1024 * 1024, || { let __v_0: G = inp[0]; let __v_1: G = inp[1]; @@ -23300,25 +23026,25 @@ fn aiur_fn_247( let __v_13: G = { let __values: [G; 3] = [__v_11, __v_12, __v_12]; let __mq = record.memory_queries.get_mut(&3).ok_or(ExecError::InvalidMemorySize(3))?; if let Some(result) = __mq.get_mut(&__values[..]) { if !unconstrained { *result.multiplicity += G::ONE; } result.output[0] } else { let __ptr = G::from_usize(__mq.len()); __mq.insert(&__values[..], &[__ptr], G::from_bool(!unconstrained)); __ptr } }; let __v_14: G = G::from_u64(0); let __v_15: G = { let __values: [G; 4] = [__v_10, __v_7, __v_13, __v_14]; let __mq = record.memory_queries.get_mut(&4).ok_or(ExecError::InvalidMemorySize(4))?; if let Some(result) = __mq.get_mut(&__values[..]) { if !unconstrained { *result.multiplicity += G::ONE; } result.output[0] } else { let __ptr = G::from_usize(__mq.len()); __mq.insert(&__values[..], &[__ptr], G::from_bool(!unconstrained)); __ptr } }; - let __r_arr: [G; OUT_245] = { let __args: [G; IN_245] = [__v_8]; let __cu = unconstrained; if let Some(result) = record.function_queries[245].get_mut(&__args[..]) { if !__cu && *result.multiplicity == G::ZERO { aiur_fn_245(__args, record, io_buffer, false)? } else { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_245] = unsafe { *(result.output.as_ptr() as *const [G; OUT_245]) }; __ret } } else { aiur_fn_245(__args, record, io_buffer, __cu)? } }; + let __r_arr: [G; OUT_241] = { let __args: [G; IN_241] = [__v_8]; let __cu = unconstrained; if let Some(result) = record.function_queries[241].get_mut(&__args[..]) { if !__cu && *result.multiplicity == G::ZERO { aiur_fn_241(__args, record, io_buffer, false)? } else { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_241] = unsafe { *(result.output.as_ptr() as *const [G; OUT_241]) }; __ret } } else { aiur_fn_241(__args, record, io_buffer, __cu)? } }; let __v_16: G = __r_arr[0]; let __v_17: G = G::from_u64(0); let __v_18: G = { let __values: [G; 4] = [__v_9, __v_15, __v_16, __v_17]; let __mq = record.memory_queries.get_mut(&4).ok_or(ExecError::InvalidMemorySize(4))?; if let Some(result) = __mq.get_mut(&__values[..]) { if !unconstrained { *result.multiplicity += G::ONE; } result.output[0] } else { let __ptr = G::from_usize(__mq.len()); __mq.insert(&__values[..], &[__ptr], G::from_bool(!unconstrained)); __ptr } }; - let __ret: [G; OUT_247] = [__v_18]; - if let Some(result) = record.function_queries[247].get_mut(&inp[..]) { debug_assert_eq!(result.output, &__ret[..]); if !unconstrained { *result.multiplicity += G::ONE; } } else { record.function_queries[247].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained)); }; + let __ret: [G; OUT_243] = [__v_18]; + if let Some(result) = record.function_queries[243].get_mut(&inp[..]) { debug_assert_eq!(result.output, &__ret[..]); if !unconstrained { *result.multiplicity += G::ONE; } } else { record.function_queries[243].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained)); }; return Ok(__ret); }) } -const INPUT_SIZE_248: usize = 4; -const IN_248: usize = 4; -const OUT_248: usize = 1; -fn aiur_fn_248( - inp: [G; IN_248], +const INPUT_SIZE_244: usize = 4; +const IN_244: usize = 4; +const OUT_244: usize = 1; +fn aiur_fn_244( + inp: [G; IN_244], record: &mut QueryRecord, io_buffer: &mut IOBuffer, unconstrained: bool, -) -> Result<[G; OUT_248], ExecError> { +) -> Result<[G; OUT_244], ExecError> { stacker::maybe_grow(64 * 1024, 4 * 1024 * 1024, || { let __v_0: G = inp[0]; let __v_1: G = inp[1]; @@ -23329,10 +23055,10 @@ fn aiur_fn_248( 0u64 => { let __r_arr: [G; OUT_114] = { let __args: [G; IN_114] = [__v_1, __v_3]; let __cu = unconstrained; if let Some(result) = record.function_queries[114].get_mut(&__args[..]) { if !__cu && *result.multiplicity == G::ZERO { aiur_fn_114(__args, record, io_buffer, false)? } else { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_114] = unsafe { *(result.output.as_ptr() as *const [G; OUT_114]) }; __ret } } else { aiur_fn_114(__args, record, io_buffer, __cu)? } }; let __v_5: G = __r_arr[0]; - let __r_arr: [G; OUT_247] = { let __args: [G; IN_247] = [__v_0, __v_5]; let __cu = unconstrained; if let Some(result) = record.function_queries[247].get_mut(&__args[..]) { if !__cu && *result.multiplicity == G::ZERO { aiur_fn_247(__args, record, io_buffer, false)? } else { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_247] = unsafe { *(result.output.as_ptr() as *const [G; OUT_247]) }; __ret } } else { aiur_fn_247(__args, record, io_buffer, __cu)? } }; + let __r_arr: [G; OUT_243] = { let __args: [G; IN_243] = [__v_0, __v_5]; let __cu = unconstrained; if let Some(result) = record.function_queries[243].get_mut(&__args[..]) { if !__cu && *result.multiplicity == G::ZERO { aiur_fn_243(__args, record, io_buffer, false)? } else { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_243] = unsafe { *(result.output.as_ptr() as *const [G; OUT_243]) }; __ret } } else { aiur_fn_243(__args, record, io_buffer, __cu)? } }; let __v_6: G = __r_arr[0]; - let __ret: [G; OUT_248] = [__v_6]; - if let Some(result) = record.function_queries[248].get_mut(&inp[..]) { debug_assert_eq!(result.output, &__ret[..]); if !unconstrained { *result.multiplicity += G::ONE; } } else { record.function_queries[248].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained)); }; + let __ret: [G; OUT_244] = [__v_6]; + if let Some(result) = record.function_queries[244].get_mut(&inp[..]) { debug_assert_eq!(result.output, &__ret[..]); if !unconstrained { *result.multiplicity += G::ONE; } } else { record.function_queries[244].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained)); }; return Ok(__ret); }, _ => { @@ -23342,19 +23068,19 @@ fn aiur_fn_248( 1u64 => { let __r_arr: [G; OUT_119] = { let __args: [G; IN_119] = [__v_3, __v_1]; let __cu = unconstrained; if let Some(result) = record.function_queries[119].get_mut(&__args[..]) { if !__cu && *result.multiplicity == G::ZERO { aiur_fn_119(__args, record, io_buffer, false)? } else { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_119] = unsafe { *(result.output.as_ptr() as *const [G; OUT_119]) }; __ret } } else { aiur_fn_119(__args, record, io_buffer, __cu)? } }; let __v_6: G = __r_arr[0]; - let __r_arr: [G; OUT_247] = { let __args: [G; IN_247] = [__v_2, __v_6]; let __cu = unconstrained; if let Some(result) = record.function_queries[247].get_mut(&__args[..]) { if !__cu && *result.multiplicity == G::ZERO { aiur_fn_247(__args, record, io_buffer, false)? } else { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_247] = unsafe { *(result.output.as_ptr() as *const [G; OUT_247]) }; __ret } } else { aiur_fn_247(__args, record, io_buffer, __cu)? } }; + let __r_arr: [G; OUT_243] = { let __args: [G; IN_243] = [__v_2, __v_6]; let __cu = unconstrained; if let Some(result) = record.function_queries[243].get_mut(&__args[..]) { if !__cu && *result.multiplicity == G::ZERO { aiur_fn_243(__args, record, io_buffer, false)? } else { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_243] = unsafe { *(result.output.as_ptr() as *const [G; OUT_243]) }; __ret } } else { aiur_fn_243(__args, record, io_buffer, __cu)? } }; let __v_7: G = __r_arr[0]; - let __ret: [G; OUT_248] = [__v_7]; - if let Some(result) = record.function_queries[248].get_mut(&inp[..]) { debug_assert_eq!(result.output, &__ret[..]); if !unconstrained { *result.multiplicity += G::ONE; } } else { record.function_queries[248].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained)); }; + let __ret: [G; OUT_244] = [__v_7]; + if let Some(result) = record.function_queries[244].get_mut(&inp[..]) { debug_assert_eq!(result.output, &__ret[..]); if !unconstrained { *result.multiplicity += G::ONE; } } else { record.function_queries[244].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained)); }; return Ok(__ret); }, _ => { let __r_arr: [G; OUT_119] = { let __args: [G; IN_119] = [__v_1, __v_3]; let __cu = unconstrained; if let Some(result) = record.function_queries[119].get_mut(&__args[..]) { if !__cu && *result.multiplicity == G::ZERO { aiur_fn_119(__args, record, io_buffer, false)? } else { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_119] = unsafe { *(result.output.as_ptr() as *const [G; OUT_119]) }; __ret } } else { aiur_fn_119(__args, record, io_buffer, __cu)? } }; let __v_6: G = __r_arr[0]; - let __r_arr: [G; OUT_247] = { let __args: [G; IN_247] = [__v_0, __v_6]; let __cu = unconstrained; if let Some(result) = record.function_queries[247].get_mut(&__args[..]) { if !__cu && *result.multiplicity == G::ZERO { aiur_fn_247(__args, record, io_buffer, false)? } else { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_247] = unsafe { *(result.output.as_ptr() as *const [G; OUT_247]) }; __ret } } else { aiur_fn_247(__args, record, io_buffer, __cu)? } }; + let __r_arr: [G; OUT_243] = { let __args: [G; IN_243] = [__v_0, __v_6]; let __cu = unconstrained; if let Some(result) = record.function_queries[243].get_mut(&__args[..]) { if !__cu && *result.multiplicity == G::ZERO { aiur_fn_243(__args, record, io_buffer, false)? } else { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_243] = unsafe { *(result.output.as_ptr() as *const [G; OUT_243]) }; __ret } } else { aiur_fn_243(__args, record, io_buffer, __cu)? } }; let __v_7: G = __r_arr[0]; - let __ret: [G; OUT_248] = [__v_7]; - if let Some(result) = record.function_queries[248].get_mut(&inp[..]) { debug_assert_eq!(result.output, &__ret[..]); if !unconstrained { *result.multiplicity += G::ONE; } } else { record.function_queries[248].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained)); }; + let __ret: [G; OUT_244] = [__v_7]; + if let Some(result) = record.function_queries[244].get_mut(&inp[..]) { debug_assert_eq!(result.output, &__ret[..]); if !unconstrained { *result.multiplicity += G::ONE; } } else { record.function_queries[244].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained)); }; return Ok(__ret); }, } @@ -23363,15 +23089,15 @@ fn aiur_fn_248( }) } -const INPUT_SIZE_249: usize = 3; -const IN_249: usize = 3; -const OUT_249: usize = 1; -fn aiur_fn_249( - inp: [G; IN_249], +const INPUT_SIZE_245: usize = 3; +const IN_245: usize = 3; +const OUT_245: usize = 1; +fn aiur_fn_245( + inp: [G; IN_245], record: &mut QueryRecord, io_buffer: &mut IOBuffer, unconstrained: bool, -) -> Result<[G; OUT_249], ExecError> { +) -> Result<[G; OUT_245], ExecError> { stacker::maybe_grow(64 * 1024, 4 * 1024 * 1024, || { let __v_0: G = inp[0]; let __v_1: G = inp[1]; @@ -23380,10 +23106,10 @@ fn aiur_fn_249( let __v_3: G = __r_arr[0]; match __v_3.as_canonical_u64() { 1u64 => { - let __r_arr: [G; OUT_247] = { let __args: [G; IN_247] = [__v_0, __v_1]; let __cu = unconstrained; if let Some(result) = record.function_queries[247].get_mut(&__args[..]) { if !__cu && *result.multiplicity == G::ZERO { aiur_fn_247(__args, record, io_buffer, false)? } else { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_247] = unsafe { *(result.output.as_ptr() as *const [G; OUT_247]) }; __ret } } else { aiur_fn_247(__args, record, io_buffer, __cu)? } }; + let __r_arr: [G; OUT_243] = { let __args: [G; IN_243] = [__v_0, __v_1]; let __cu = unconstrained; if let Some(result) = record.function_queries[243].get_mut(&__args[..]) { if !__cu && *result.multiplicity == G::ZERO { aiur_fn_243(__args, record, io_buffer, false)? } else { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_243] = unsafe { *(result.output.as_ptr() as *const [G; OUT_243]) }; __ret } } else { aiur_fn_243(__args, record, io_buffer, __cu)? } }; let __v_4: G = __r_arr[0]; - let __ret: [G; OUT_249] = [__v_4]; - if let Some(result) = record.function_queries[249].get_mut(&inp[..]) { debug_assert_eq!(result.output, &__ret[..]); if !unconstrained { *result.multiplicity += G::ONE; } } else { record.function_queries[249].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained)); }; + let __ret: [G; OUT_245] = [__v_4]; + if let Some(result) = record.function_queries[245].get_mut(&inp[..]) { debug_assert_eq!(result.output, &__ret[..]); if !unconstrained { *result.multiplicity += G::ONE; } } else { record.function_queries[245].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained)); }; return Ok(__ret); }, _ => { @@ -23399,18 +23125,18 @@ fn aiur_fn_249( let __v_9: G = G::from_u64(0); let __r_arr: [G; OUT_119] = { let __args: [G; IN_119] = [__v_2, __v_4]; let __cu = unconstrained; if let Some(result) = record.function_queries[119].get_mut(&__args[..]) { if !__cu && *result.multiplicity == G::ZERO { aiur_fn_119(__args, record, io_buffer, false)? } else { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_119] = unsafe { *(result.output.as_ptr() as *const [G; OUT_119]) }; __ret } } else { aiur_fn_119(__args, record, io_buffer, __cu)? } }; let __v_10: G = __r_arr[0]; - let __r_arr: [G; OUT_247] = { let __args: [G; IN_247] = [__v_9, __v_10]; let __cu = unconstrained; if let Some(result) = record.function_queries[247].get_mut(&__args[..]) { if !__cu && *result.multiplicity == G::ZERO { aiur_fn_247(__args, record, io_buffer, false)? } else { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_247] = unsafe { *(result.output.as_ptr() as *const [G; OUT_247]) }; __ret } } else { aiur_fn_247(__args, record, io_buffer, __cu)? } }; + let __r_arr: [G; OUT_243] = { let __args: [G; IN_243] = [__v_9, __v_10]; let __cu = unconstrained; if let Some(result) = record.function_queries[243].get_mut(&__args[..]) { if !__cu && *result.multiplicity == G::ZERO { aiur_fn_243(__args, record, io_buffer, false)? } else { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_243] = unsafe { *(result.output.as_ptr() as *const [G; OUT_243]) }; __ret } } else { aiur_fn_243(__args, record, io_buffer, __cu)? } }; let __v_11: G = __r_arr[0]; - let __ret: [G; OUT_249] = [__v_11]; - if let Some(result) = record.function_queries[249].get_mut(&inp[..]) { debug_assert_eq!(result.output, &__ret[..]); if !unconstrained { *result.multiplicity += G::ONE; } } else { record.function_queries[249].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained)); }; + let __ret: [G; OUT_245] = [__v_11]; + if let Some(result) = record.function_queries[245].get_mut(&inp[..]) { debug_assert_eq!(result.output, &__ret[..]); if !unconstrained { *result.multiplicity += G::ONE; } } else { record.function_queries[245].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained)); }; return Ok(__ret); }, _ => { let __v_9: G = G::from_u64(0); - let __r_arr: [G; OUT_247] = { let __args: [G; IN_247] = [__v_9, __v_4]; let __cu = unconstrained; if let Some(result) = record.function_queries[247].get_mut(&__args[..]) { if !__cu && *result.multiplicity == G::ZERO { aiur_fn_247(__args, record, io_buffer, false)? } else { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_247] = unsafe { *(result.output.as_ptr() as *const [G; OUT_247]) }; __ret } } else { aiur_fn_247(__args, record, io_buffer, __cu)? } }; + let __r_arr: [G; OUT_243] = { let __args: [G; IN_243] = [__v_9, __v_4]; let __cu = unconstrained; if let Some(result) = record.function_queries[243].get_mut(&__args[..]) { if !__cu && *result.multiplicity == G::ZERO { aiur_fn_243(__args, record, io_buffer, false)? } else { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_243] = unsafe { *(result.output.as_ptr() as *const [G; OUT_243]) }; __ret } } else { aiur_fn_243(__args, record, io_buffer, __cu)? } }; let __v_10: G = __r_arr[0]; - let __ret: [G; OUT_249] = [__v_10]; - if let Some(result) = record.function_queries[249].get_mut(&inp[..]) { debug_assert_eq!(result.output, &__ret[..]); if !unconstrained { *result.multiplicity += G::ONE; } } else { record.function_queries[249].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained)); }; + let __ret: [G; OUT_245] = [__v_10]; + if let Some(result) = record.function_queries[245].get_mut(&inp[..]) { debug_assert_eq!(result.output, &__ret[..]); if !unconstrained { *result.multiplicity += G::ONE; } } else { record.function_queries[245].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained)); }; return Ok(__ret); }, } @@ -23419,15 +23145,15 @@ fn aiur_fn_249( }) } -const INPUT_SIZE_250: usize = 4; -const IN_250: usize = 4; -const OUT_250: usize = 1; -fn aiur_fn_250( - inp: [G; IN_250], +const INPUT_SIZE_246: usize = 4; +const IN_246: usize = 4; +const OUT_246: usize = 1; +fn aiur_fn_246( + inp: [G; IN_246], record: &mut QueryRecord, io_buffer: &mut IOBuffer, unconstrained: bool, -) -> Result<[G; OUT_250], ExecError> { +) -> Result<[G; OUT_246], ExecError> { stacker::maybe_grow(64 * 1024, 4 * 1024 * 1024, || { let __v_0: G = inp[0]; let __v_1: G = inp[1]; @@ -23441,10 +23167,10 @@ fn aiur_fn_250( let __v_6: G = G::from_u64(1); let __v_7: G = G::from_u64(1); let __v_8: G = { let __values: [G; 10] = [__v_6, __v_7, __v_7, __v_7, __v_7, __v_7, __v_7, __v_7, __v_7, __v_7]; let __mq = record.memory_queries.get_mut(&10).ok_or(ExecError::InvalidMemorySize(10))?; if let Some(result) = __mq.get_mut(&__values[..]) { if !unconstrained { *result.multiplicity += G::ONE; } result.output[0] } else { let __ptr = G::from_usize(__mq.len()); __mq.insert(&__values[..], &[__ptr], G::from_bool(!unconstrained)); __ptr } }; - let __r_arr: [G; OUT_247] = { let __args: [G; IN_247] = [__v_5, __v_8]; let __cu = unconstrained; if let Some(result) = record.function_queries[247].get_mut(&__args[..]) { if !__cu && *result.multiplicity == G::ZERO { aiur_fn_247(__args, record, io_buffer, false)? } else { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_247] = unsafe { *(result.output.as_ptr() as *const [G; OUT_247]) }; __ret } } else { aiur_fn_247(__args, record, io_buffer, __cu)? } }; + let __r_arr: [G; OUT_243] = { let __args: [G; IN_243] = [__v_5, __v_8]; let __cu = unconstrained; if let Some(result) = record.function_queries[243].get_mut(&__args[..]) { if !__cu && *result.multiplicity == G::ZERO { aiur_fn_243(__args, record, io_buffer, false)? } else { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_243] = unsafe { *(result.output.as_ptr() as *const [G; OUT_243]) }; __ret } } else { aiur_fn_243(__args, record, io_buffer, __cu)? } }; let __v_9: G = __r_arr[0]; - let __ret: [G; OUT_250] = [__v_9]; - if let Some(result) = record.function_queries[250].get_mut(&inp[..]) { debug_assert_eq!(result.output, &__ret[..]); if !unconstrained { *result.multiplicity += G::ONE; } } else { record.function_queries[250].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained)); }; + let __ret: [G; OUT_246] = [__v_9]; + if let Some(result) = record.function_queries[246].get_mut(&inp[..]) { debug_assert_eq!(result.output, &__ret[..]); if !unconstrained { *result.multiplicity += G::ONE; } } else { record.function_queries[246].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained)); }; return Ok(__ret); }, _ => { @@ -23479,25 +23205,25 @@ fn aiur_fn_250( let __v_18: G = __r_arr[0]; let __v_19: G = (__v_17 - __v_18); let __v_20: G = (__v_16 * __v_19); - let __r_arr: [G; OUT_247] = { let __args: [G; IN_247] = [__v_20, __v_11]; let __cu = unconstrained; if let Some(result) = record.function_queries[247].get_mut(&__args[..]) { if !__cu && *result.multiplicity == G::ZERO { aiur_fn_247(__args, record, io_buffer, false)? } else { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_247] = unsafe { *(result.output.as_ptr() as *const [G; OUT_247]) }; __ret } } else { aiur_fn_247(__args, record, io_buffer, __cu)? } }; + let __r_arr: [G; OUT_243] = { let __args: [G; IN_243] = [__v_20, __v_11]; let __cu = unconstrained; if let Some(result) = record.function_queries[243].get_mut(&__args[..]) { if !__cu && *result.multiplicity == G::ZERO { aiur_fn_243(__args, record, io_buffer, false)? } else { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_243] = unsafe { *(result.output.as_ptr() as *const [G; OUT_243]) }; __ret } } else { aiur_fn_243(__args, record, io_buffer, __cu)? } }; let __v_21: G = __r_arr[0]; - let __ret: [G; OUT_250] = [__v_21]; - if let Some(result) = record.function_queries[250].get_mut(&inp[..]) { debug_assert_eq!(result.output, &__ret[..]); if !unconstrained { *result.multiplicity += G::ONE; } } else { record.function_queries[250].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained)); }; + let __ret: [G; OUT_246] = [__v_21]; + if let Some(result) = record.function_queries[246].get_mut(&inp[..]) { debug_assert_eq!(result.output, &__ret[..]); if !unconstrained { *result.multiplicity += G::ONE; } } else { record.function_queries[246].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained)); }; return Ok(__ret); }, } }) } -const INPUT_SIZE_251: usize = 3; -const IN_251: usize = 3; -const OUT_251: usize = 1; -fn aiur_fn_251( - inp: [G; IN_251], +const INPUT_SIZE_247: usize = 3; +const IN_247: usize = 3; +const OUT_247: usize = 1; +fn aiur_fn_247( + inp: [G; IN_247], record: &mut QueryRecord, io_buffer: &mut IOBuffer, unconstrained: bool, -) -> Result<[G; OUT_251], ExecError> { +) -> Result<[G; OUT_247], ExecError> { stacker::maybe_grow(64 * 1024, 4 * 1024 * 1024, || { let __v_0: G = inp[0]; let __v_1: G = inp[1]; @@ -23506,10 +23232,10 @@ fn aiur_fn_251( let __v_3: G = __r_arr[0]; match __v_3.as_canonical_u64() { 1u64 => { - let __r_arr: [G; OUT_247] = { let __args: [G; IN_247] = [__v_0, __v_1]; let __cu = unconstrained; if let Some(result) = record.function_queries[247].get_mut(&__args[..]) { if !__cu && *result.multiplicity == G::ZERO { aiur_fn_247(__args, record, io_buffer, false)? } else { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_247] = unsafe { *(result.output.as_ptr() as *const [G; OUT_247]) }; __ret } } else { aiur_fn_247(__args, record, io_buffer, __cu)? } }; + let __r_arr: [G; OUT_243] = { let __args: [G; IN_243] = [__v_0, __v_1]; let __cu = unconstrained; if let Some(result) = record.function_queries[243].get_mut(&__args[..]) { if !__cu && *result.multiplicity == G::ZERO { aiur_fn_243(__args, record, io_buffer, false)? } else { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_243] = unsafe { *(result.output.as_ptr() as *const [G; OUT_243]) }; __ret } } else { aiur_fn_243(__args, record, io_buffer, __cu)? } }; let __v_4: G = __r_arr[0]; - let __ret: [G; OUT_251] = [__v_4]; - if let Some(result) = record.function_queries[251].get_mut(&inp[..]) { debug_assert_eq!(result.output, &__ret[..]); if !unconstrained { *result.multiplicity += G::ONE; } } else { record.function_queries[251].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained)); }; + let __ret: [G; OUT_247] = [__v_4]; + if let Some(result) = record.function_queries[247].get_mut(&inp[..]) { debug_assert_eq!(result.output, &__ret[..]); if !unconstrained { *result.multiplicity += G::ONE; } } else { record.function_queries[247].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained)); }; return Ok(__ret); }, _ => { @@ -23556,18 +23282,18 @@ fn aiur_fn_251( let __v_26: G = G::from_u64(1); let __r_arr: [G; OUT_119] = { let __args: [G; IN_119] = [__v_2, __v_9]; let __cu = unconstrained; if let Some(result) = record.function_queries[119].get_mut(&__args[..]) { if !__cu && *result.multiplicity == G::ZERO { aiur_fn_119(__args, record, io_buffer, false)? } else { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_119] = unsafe { *(result.output.as_ptr() as *const [G; OUT_119]) }; __ret } } else { aiur_fn_119(__args, record, io_buffer, __cu)? } }; let __v_27: G = __r_arr[0]; - let __r_arr: [G; OUT_247] = { let __args: [G; IN_247] = [__v_26, __v_27]; let __cu = unconstrained; if let Some(result) = record.function_queries[247].get_mut(&__args[..]) { if !__cu && *result.multiplicity == G::ZERO { aiur_fn_247(__args, record, io_buffer, false)? } else { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_247] = unsafe { *(result.output.as_ptr() as *const [G; OUT_247]) }; __ret } } else { aiur_fn_247(__args, record, io_buffer, __cu)? } }; + let __r_arr: [G; OUT_243] = { let __args: [G; IN_243] = [__v_26, __v_27]; let __cu = unconstrained; if let Some(result) = record.function_queries[243].get_mut(&__args[..]) { if !__cu && *result.multiplicity == G::ZERO { aiur_fn_243(__args, record, io_buffer, false)? } else { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_243] = unsafe { *(result.output.as_ptr() as *const [G; OUT_243]) }; __ret } } else { aiur_fn_243(__args, record, io_buffer, __cu)? } }; let __v_28: G = __r_arr[0]; - let __ret: [G; OUT_251] = [__v_28]; - if let Some(result) = record.function_queries[251].get_mut(&inp[..]) { debug_assert_eq!(result.output, &__ret[..]); if !unconstrained { *result.multiplicity += G::ONE; } } else { record.function_queries[251].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained)); }; + let __ret: [G; OUT_247] = [__v_28]; + if let Some(result) = record.function_queries[247].get_mut(&inp[..]) { debug_assert_eq!(result.output, &__ret[..]); if !unconstrained { *result.multiplicity += G::ONE; } } else { record.function_queries[247].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained)); }; return Ok(__ret); }, _ => { let __v_26: G = G::from_u64(0); - let __r_arr: [G; OUT_247] = { let __args: [G; IN_247] = [__v_26, __v_9]; let __cu = unconstrained; if let Some(result) = record.function_queries[247].get_mut(&__args[..]) { if !__cu && *result.multiplicity == G::ZERO { aiur_fn_247(__args, record, io_buffer, false)? } else { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_247] = unsafe { *(result.output.as_ptr() as *const [G; OUT_247]) }; __ret } } else { aiur_fn_247(__args, record, io_buffer, __cu)? } }; + let __r_arr: [G; OUT_243] = { let __args: [G; IN_243] = [__v_26, __v_9]; let __cu = unconstrained; if let Some(result) = record.function_queries[243].get_mut(&__args[..]) { if !__cu && *result.multiplicity == G::ZERO { aiur_fn_243(__args, record, io_buffer, false)? } else { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_243] = unsafe { *(result.output.as_ptr() as *const [G; OUT_243]) }; __ret } } else { aiur_fn_243(__args, record, io_buffer, __cu)? } }; let __v_27: G = __r_arr[0]; - let __ret: [G; OUT_251] = [__v_27]; - if let Some(result) = record.function_queries[251].get_mut(&inp[..]) { debug_assert_eq!(result.output, &__ret[..]); if !unconstrained { *result.multiplicity += G::ONE; } } else { record.function_queries[251].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained)); }; + let __ret: [G; OUT_247] = [__v_27]; + if let Some(result) = record.function_queries[247].get_mut(&inp[..]) { debug_assert_eq!(result.output, &__ret[..]); if !unconstrained { *result.multiplicity += G::ONE; } } else { record.function_queries[247].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained)); }; return Ok(__ret); }, } @@ -23576,15 +23302,15 @@ fn aiur_fn_251( }) } -const INPUT_SIZE_252: usize = 3; -const IN_252: usize = 3; -const OUT_252: usize = 1; -fn aiur_fn_252( - inp: [G; IN_252], +const INPUT_SIZE_248: usize = 3; +const IN_248: usize = 3; +const OUT_248: usize = 1; +fn aiur_fn_248( + inp: [G; IN_248], record: &mut QueryRecord, io_buffer: &mut IOBuffer, unconstrained: bool, -) -> Result<[G; OUT_252], ExecError> { +) -> Result<[G; OUT_248], ExecError> { stacker::maybe_grow(64 * 1024, 4 * 1024 * 1024, || { let __v_0: G = inp[0]; let __v_1: G = inp[1]; @@ -23597,10 +23323,10 @@ fn aiur_fn_252( let __v_5: G = G::from_u64(1); let __v_6: G = G::from_u64(1); let __v_7: G = { let __values: [G; 10] = [__v_5, __v_6, __v_6, __v_6, __v_6, __v_6, __v_6, __v_6, __v_6, __v_6]; let __mq = record.memory_queries.get_mut(&10).ok_or(ExecError::InvalidMemorySize(10))?; if let Some(result) = __mq.get_mut(&__values[..]) { if !unconstrained { *result.multiplicity += G::ONE; } result.output[0] } else { let __ptr = G::from_usize(__mq.len()); __mq.insert(&__values[..], &[__ptr], G::from_bool(!unconstrained)); __ptr } }; - let __r_arr: [G; OUT_247] = { let __args: [G; IN_247] = [__v_4, __v_7]; let __cu = unconstrained; if let Some(result) = record.function_queries[247].get_mut(&__args[..]) { if !__cu && *result.multiplicity == G::ZERO { aiur_fn_247(__args, record, io_buffer, false)? } else { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_247] = unsafe { *(result.output.as_ptr() as *const [G; OUT_247]) }; __ret } } else { aiur_fn_247(__args, record, io_buffer, __cu)? } }; + let __r_arr: [G; OUT_243] = { let __args: [G; IN_243] = [__v_4, __v_7]; let __cu = unconstrained; if let Some(result) = record.function_queries[243].get_mut(&__args[..]) { if !__cu && *result.multiplicity == G::ZERO { aiur_fn_243(__args, record, io_buffer, false)? } else { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_243] = unsafe { *(result.output.as_ptr() as *const [G; OUT_243]) }; __ret } } else { aiur_fn_243(__args, record, io_buffer, __cu)? } }; let __v_8: G = __r_arr[0]; - let __ret: [G; OUT_252] = [__v_8]; - if let Some(result) = record.function_queries[252].get_mut(&inp[..]) { debug_assert_eq!(result.output, &__ret[..]); if !unconstrained { *result.multiplicity += G::ONE; } } else { record.function_queries[252].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained)); }; + let __ret: [G; OUT_248] = [__v_8]; + if let Some(result) = record.function_queries[248].get_mut(&inp[..]) { debug_assert_eq!(result.output, &__ret[..]); if !unconstrained { *result.multiplicity += G::ONE; } } else { record.function_queries[248].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained)); }; return Ok(__ret); }, _ => { @@ -23668,10 +23394,10 @@ fn aiur_fn_252( let __v_35: G = __r_arr[0]; match __v_35.as_canonical_u64() { 0u64 => { - let __r_arr: [G; OUT_247] = { let __args: [G; IN_247] = [__v_19, __v_15]; let __cu = unconstrained; if let Some(result) = record.function_queries[247].get_mut(&__args[..]) { if !__cu && *result.multiplicity == G::ZERO { aiur_fn_247(__args, record, io_buffer, false)? } else { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_247] = unsafe { *(result.output.as_ptr() as *const [G; OUT_247]) }; __ret } } else { aiur_fn_247(__args, record, io_buffer, __cu)? } }; + let __r_arr: [G; OUT_243] = { let __args: [G; IN_243] = [__v_19, __v_15]; let __cu = unconstrained; if let Some(result) = record.function_queries[243].get_mut(&__args[..]) { if !__cu && *result.multiplicity == G::ZERO { aiur_fn_243(__args, record, io_buffer, false)? } else { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_243] = unsafe { *(result.output.as_ptr() as *const [G; OUT_243]) }; __ret } } else { aiur_fn_243(__args, record, io_buffer, __cu)? } }; let __v_36: G = __r_arr[0]; - let __ret: [G; OUT_252] = [__v_36]; - if let Some(result) = record.function_queries[252].get_mut(&inp[..]) { debug_assert_eq!(result.output, &__ret[..]); if !unconstrained { *result.multiplicity += G::ONE; } } else { record.function_queries[252].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained)); }; + let __ret: [G; OUT_248] = [__v_36]; + if let Some(result) = record.function_queries[248].get_mut(&inp[..]) { debug_assert_eq!(result.output, &__ret[..]); if !unconstrained { *result.multiplicity += G::ONE; } } else { record.function_queries[248].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained)); }; return Ok(__ret); }, _ => { @@ -23689,10 +23415,10 @@ fn aiur_fn_252( let __v_47: G = G::from_u64(1); let __v_48: G = { let __values: [G; 10] = [__v_46, __v_47, __v_47, __v_47, __v_47, __v_47, __v_47, __v_47, __v_47, __v_47]; let __mq = record.memory_queries.get_mut(&10).ok_or(ExecError::InvalidMemorySize(10))?; if let Some(result) = __mq.get_mut(&__values[..]) { if !unconstrained { *result.multiplicity += G::ONE; } result.output[0] } else { let __ptr = G::from_usize(__mq.len()); __mq.insert(&__values[..], &[__ptr], G::from_bool(!unconstrained)); __ptr } }; let __v_49: G = { let __values: [G; 10] = [__v_37, __v_38, __v_39, __v_40, __v_41, __v_42, __v_43, __v_44, __v_45, __v_48]; let __mq = record.memory_queries.get_mut(&10).ok_or(ExecError::InvalidMemorySize(10))?; if let Some(result) = __mq.get_mut(&__values[..]) { if !unconstrained { *result.multiplicity += G::ONE; } result.output[0] } else { let __ptr = G::from_usize(__mq.len()); __mq.insert(&__values[..], &[__ptr], G::from_bool(!unconstrained)); __ptr } }; - let __r_arr: [G; OUT_248] = { let __args: [G; IN_248] = [__v_19, __v_15, __v_36, __v_49]; let __cu = unconstrained; if let Some(result) = record.function_queries[248].get_mut(&__args[..]) { if !__cu && *result.multiplicity == G::ZERO { aiur_fn_248(__args, record, io_buffer, false)? } else { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_248] = unsafe { *(result.output.as_ptr() as *const [G; OUT_248]) }; __ret } } else { aiur_fn_248(__args, record, io_buffer, __cu)? } }; + let __r_arr: [G; OUT_244] = { let __args: [G; IN_244] = [__v_19, __v_15, __v_36, __v_49]; let __cu = unconstrained; if let Some(result) = record.function_queries[244].get_mut(&__args[..]) { if !__cu && *result.multiplicity == G::ZERO { aiur_fn_244(__args, record, io_buffer, false)? } else { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_244] = unsafe { *(result.output.as_ptr() as *const [G; OUT_244]) }; __ret } } else { aiur_fn_244(__args, record, io_buffer, __cu)? } }; let __v_50: G = __r_arr[0]; - let __ret: [G; OUT_252] = [__v_50]; - if let Some(result) = record.function_queries[252].get_mut(&inp[..]) { debug_assert_eq!(result.output, &__ret[..]); if !unconstrained { *result.multiplicity += G::ONE; } } else { record.function_queries[252].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained)); }; + let __ret: [G; OUT_248] = [__v_50]; + if let Some(result) = record.function_queries[248].get_mut(&inp[..]) { debug_assert_eq!(result.output, &__ret[..]); if !unconstrained { *result.multiplicity += G::ONE; } } else { record.function_queries[248].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained)); }; return Ok(__ret); }, } @@ -23701,22 +23427,22 @@ fn aiur_fn_252( }) } -const INPUT_SIZE_253: usize = 3; -const IN_253: usize = 3; -const OUT_253: usize = 2; -fn aiur_fn_253( - inp: [G; IN_253], +const INPUT_SIZE_249: usize = 3; +const IN_249: usize = 3; +const OUT_249: usize = 2; +fn aiur_fn_249( + inp: [G; IN_249], record: &mut QueryRecord, io_buffer: &mut IOBuffer, unconstrained: bool, -) -> Result<[G; OUT_253], ExecError> { +) -> Result<[G; OUT_249], ExecError> { stacker::maybe_grow(64 * 1024, 4 * 1024 * 1024, || { let __v_0: G = inp[0]; let __v_1: G = inp[1]; let __v_2: G = inp[2]; - let __r_arr: [G; OUT_388] = { let __args: [G; IN_388] = [__v_1, __v_2]; let __cu = unconstrained; if let Some(result) = record.function_queries[388].get_mut(&__args[..]) { if !__cu && *result.multiplicity == G::ZERO { aiur_fn_388(__args, record, io_buffer, false)? } else { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_388] = unsafe { *(result.output.as_ptr() as *const [G; OUT_388]) }; __ret } } else { aiur_fn_388(__args, record, io_buffer, __cu)? } }; + let __r_arr: [G; OUT_384] = { let __args: [G; IN_384] = [__v_1, __v_2]; let __cu = unconstrained; if let Some(result) = record.function_queries[384].get_mut(&__args[..]) { if !__cu && *result.multiplicity == G::ZERO { aiur_fn_384(__args, record, io_buffer, false)? } else { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_384] = unsafe { *(result.output.as_ptr() as *const [G; OUT_384]) }; __ret } } else { aiur_fn_384(__args, record, io_buffer, __cu)? } }; let __v_3: G = __r_arr[0]; - let __r_arr: [G; OUT_764] = { let __args: [G; IN_764] = [__v_3]; let __cu = unconstrained; if let Some(result) = record.function_queries[764].get_mut(&__args[..]) { if !__cu && *result.multiplicity == G::ZERO { aiur_fn_764(__args, record, io_buffer, false)? } else { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_764] = unsafe { *(result.output.as_ptr() as *const [G; OUT_764]) }; __ret } } else { aiur_fn_764(__args, record, io_buffer, __cu)? } }; + let __r_arr: [G; OUT_760] = { let __args: [G; IN_760] = [__v_3]; let __cu = unconstrained; if let Some(result) = record.function_queries[760].get_mut(&__args[..]) { if !__cu && *result.multiplicity == G::ZERO { aiur_fn_760(__args, record, io_buffer, false)? } else { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_760] = unsafe { *(result.output.as_ptr() as *const [G; OUT_760]) }; __ret } } else { aiur_fn_760(__args, record, io_buffer, __cu)? } }; let __v_4: G = __r_arr[0]; let __r_arr: [G; OUT_151] = { let __args: [G; IN_151] = []; let __cu = unconstrained; if let Some(result) = record.function_queries[151].get_mut(&__args[..]) { if !__cu && *result.multiplicity == G::ZERO { aiur_fn_151(__args, record, io_buffer, false)? } else { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_151] = unsafe { *(result.output.as_ptr() as *const [G; OUT_151]) }; __ret } } else { aiur_fn_151(__args, record, io_buffer, __cu)? } }; let __v_5: G = __r_arr[0]; @@ -23738,15 +23464,15 @@ fn aiur_fn_253( let __v_14: G = G::from_u64(0); let __v_15: G = G::from_u64(0); let __v_16: G = { let __values: [G; 4] = [__v_13, __v_14, __v_15, __v_15]; let __mq = record.memory_queries.get_mut(&4).ok_or(ExecError::InvalidMemorySize(4))?; if let Some(result) = __mq.get_mut(&__values[..]) { if !unconstrained { *result.multiplicity += G::ONE; } result.output[0] } else { let __ptr = G::from_usize(__mq.len()); __mq.insert(&__values[..], &[__ptr], G::from_bool(!unconstrained)); __ptr } }; - let __ret: [G; OUT_253] = [__v_12, __v_16]; - if let Some(result) = record.function_queries[253].get_mut(&inp[..]) { debug_assert_eq!(result.output, &__ret[..]); if !unconstrained { *result.multiplicity += G::ONE; } } else { record.function_queries[253].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained)); }; + let __ret: [G; OUT_249] = [__v_12, __v_16]; + if let Some(result) = record.function_queries[249].get_mut(&inp[..]) { debug_assert_eq!(result.output, &__ret[..]); if !unconstrained { *result.multiplicity += G::ONE; } } else { record.function_queries[249].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained)); }; return Ok(__ret); }, _ => { let __v_12: G = G::from_u64(0); - let __r_arr: [G; OUT_766] = { let __args: [G; IN_766] = [__v_3, __v_12]; let __cu = unconstrained; if let Some(result) = record.function_queries[766].get_mut(&__args[..]) { if !__cu && *result.multiplicity == G::ZERO { aiur_fn_766(__args, record, io_buffer, false)? } else { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_766] = unsafe { *(result.output.as_ptr() as *const [G; OUT_766]) }; __ret } } else { aiur_fn_766(__args, record, io_buffer, __cu)? } }; + let __r_arr: [G; OUT_762] = { let __args: [G; IN_762] = [__v_3, __v_12]; let __cu = unconstrained; if let Some(result) = record.function_queries[762].get_mut(&__args[..]) { if !__cu && *result.multiplicity == G::ZERO { aiur_fn_762(__args, record, io_buffer, false)? } else { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_762] = unsafe { *(result.output.as_ptr() as *const [G; OUT_762]) }; __ret } } else { aiur_fn_762(__args, record, io_buffer, __cu)? } }; let __v_13: G = __r_arr[0]; - let __r_arr: [G; OUT_246] = { let __args: [G; IN_246] = [__v_13]; let __cu = unconstrained; if let Some(result) = record.function_queries[246].get_mut(&__args[..]) { if !__cu && *result.multiplicity == G::ZERO { aiur_fn_246(__args, record, io_buffer, false)? } else { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_246] = unsafe { *(result.output.as_ptr() as *const [G; OUT_246]) }; __ret } } else { aiur_fn_246(__args, record, io_buffer, __cu)? } }; + let __r_arr: [G; OUT_242] = { let __args: [G; IN_242] = [__v_13]; let __cu = unconstrained; if let Some(result) = record.function_queries[242].get_mut(&__args[..]) { if !__cu && *result.multiplicity == G::ZERO { aiur_fn_242(__args, record, io_buffer, false)? } else { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_242] = unsafe { *(result.output.as_ptr() as *const [G; OUT_242]) }; __ret } } else { aiur_fn_242(__args, record, io_buffer, __cu)? } }; let __v_14: G = __r_arr[0]; let __v_15: G = __r_arr[1]; let __v_16: G = __r_arr[2]; @@ -23758,7 +23484,7 @@ fn aiur_fn_253( let __v_18: G = __r_arr[0]; let __mc_out___mc_0: [G; 1] = '__mc_0: { match __v_18.as_canonical_u64() { 1u64 => { - let __r_arr: [G; OUT_245] = { let __args: [G; IN_245] = [__v_16]; let __cu = unconstrained; if let Some(result) = record.function_queries[245].get_mut(&__args[..]) { if !__cu && *result.multiplicity == G::ZERO { aiur_fn_245(__args, record, io_buffer, false)? } else { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_245] = unsafe { *(result.output.as_ptr() as *const [G; OUT_245]) }; __ret } } else { aiur_fn_245(__args, record, io_buffer, __cu)? } }; + let __r_arr: [G; OUT_241] = { let __args: [G; IN_241] = [__v_16]; let __cu = unconstrained; if let Some(result) = record.function_queries[241].get_mut(&__args[..]) { if !__cu && *result.multiplicity == G::ZERO { aiur_fn_241(__args, record, io_buffer, false)? } else { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_241] = unsafe { *(result.output.as_ptr() as *const [G; OUT_241]) }; __ret } } else { aiur_fn_241(__args, record, io_buffer, __cu)? } }; let __v_19: G = __r_arr[0]; break '__mc_0 [__v_19]; }, @@ -23770,7 +23496,7 @@ fn aiur_fn_253( let __v_22: G = __r_arr[0]; let __v_23: G = (__v_21 - __v_22); let __v_24: G = (__v_20 * __v_23); - let __r_arr: [G; OUT_247] = { let __args: [G; IN_247] = [__v_24, __v_16]; let __cu = unconstrained; if let Some(result) = record.function_queries[247].get_mut(&__args[..]) { if !__cu && *result.multiplicity == G::ZERO { aiur_fn_247(__args, record, io_buffer, false)? } else { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_247] = unsafe { *(result.output.as_ptr() as *const [G; OUT_247]) }; __ret } } else { aiur_fn_247(__args, record, io_buffer, __cu)? } }; + let __r_arr: [G; OUT_243] = { let __args: [G; IN_243] = [__v_24, __v_16]; let __cu = unconstrained; if let Some(result) = record.function_queries[243].get_mut(&__args[..]) { if !__cu && *result.multiplicity == G::ZERO { aiur_fn_243(__args, record, io_buffer, false)? } else { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_243] = unsafe { *(result.output.as_ptr() as *const [G; OUT_243]) }; __ret } } else { aiur_fn_243(__args, record, io_buffer, __cu)? } }; let __v_25: G = __r_arr[0]; break '__mc_0 [__v_25]; }, @@ -23779,12 +23505,12 @@ fn aiur_fn_253( let __v_19: G = __mc_out___mc_0[0]; let __v_20: G = G::from_u64(1); let __v_21: G = G::from_u64(1); - let __r_arr: [G; OUT_775] = { let __args: [G; IN_775] = [__v_3, __v_21]; let __cu = unconstrained; if let Some(result) = record.function_queries[775].get_mut(&__args[..]) { if !__cu && *result.multiplicity == G::ZERO { aiur_fn_775(__args, record, io_buffer, false)? } else { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_775] = unsafe { *(result.output.as_ptr() as *const [G; OUT_775]) }; __ret } } else { aiur_fn_775(__args, record, io_buffer, __cu)? } }; + let __r_arr: [G; OUT_771] = { let __args: [G; IN_771] = [__v_3, __v_21]; let __cu = unconstrained; if let Some(result) = record.function_queries[771].get_mut(&__args[..]) { if !__cu && *result.multiplicity == G::ZERO { aiur_fn_771(__args, record, io_buffer, false)? } else { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_771] = unsafe { *(result.output.as_ptr() as *const [G; OUT_771]) }; __ret } } else { aiur_fn_771(__args, record, io_buffer, __cu)? } }; let __v_22: G = __r_arr[0]; - let __r_arr: [G; OUT_255] = { let __args: [G; IN_255] = [__v_19, __v_22]; let __cu = unconstrained; if let Some(result) = record.function_queries[255].get_mut(&__args[..]) { if !__cu && *result.multiplicity == G::ZERO { aiur_fn_255(__args, record, io_buffer, false)? } else { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_255] = unsafe { *(result.output.as_ptr() as *const [G; OUT_255]) }; __ret } } else { aiur_fn_255(__args, record, io_buffer, __cu)? } }; + let __r_arr: [G; OUT_251] = { let __args: [G; IN_251] = [__v_19, __v_22]; let __cu = unconstrained; if let Some(result) = record.function_queries[251].get_mut(&__args[..]) { if !__cu && *result.multiplicity == G::ZERO { aiur_fn_251(__args, record, io_buffer, false)? } else { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_251] = unsafe { *(result.output.as_ptr() as *const [G; OUT_251]) }; __ret } } else { aiur_fn_251(__args, record, io_buffer, __cu)? } }; let __v_23: G = __r_arr[0]; - let __ret: [G; OUT_253] = [__v_20, __v_23]; - if let Some(result) = record.function_queries[253].get_mut(&inp[..]) { debug_assert_eq!(result.output, &__ret[..]); if !unconstrained { *result.multiplicity += G::ONE; } } else { record.function_queries[253].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained)); }; + let __ret: [G; OUT_249] = [__v_20, __v_23]; + if let Some(result) = record.function_queries[249].get_mut(&inp[..]) { debug_assert_eq!(result.output, &__ret[..]); if !unconstrained { *result.multiplicity += G::ONE; } } else { record.function_queries[249].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained)); }; return Ok(__ret); }, _ => { @@ -23793,8 +23519,8 @@ fn aiur_fn_253( let __v_19: G = G::from_u64(0); let __v_20: G = G::from_u64(0); let __v_21: G = { let __values: [G; 4] = [__v_18, __v_19, __v_20, __v_20]; let __mq = record.memory_queries.get_mut(&4).ok_or(ExecError::InvalidMemorySize(4))?; if let Some(result) = __mq.get_mut(&__values[..]) { if !unconstrained { *result.multiplicity += G::ONE; } result.output[0] } else { let __ptr = G::from_usize(__mq.len()); __mq.insert(&__values[..], &[__ptr], G::from_bool(!unconstrained)); __ptr } }; - let __ret: [G; OUT_253] = [__v_17, __v_21]; - if let Some(result) = record.function_queries[253].get_mut(&inp[..]) { debug_assert_eq!(result.output, &__ret[..]); if !unconstrained { *result.multiplicity += G::ONE; } } else { record.function_queries[253].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained)); }; + let __ret: [G; OUT_249] = [__v_17, __v_21]; + if let Some(result) = record.function_queries[249].get_mut(&inp[..]) { debug_assert_eq!(result.output, &__ret[..]); if !unconstrained { *result.multiplicity += G::ONE; } } else { record.function_queries[249].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained)); }; return Ok(__ret); }, } @@ -23811,25 +23537,25 @@ fn aiur_fn_253( let __v_14: G = G::from_u64(0); let __v_15: G = G::from_u64(0); let __v_16: G = { let __values: [G; 4] = [__v_13, __v_14, __v_15, __v_15]; let __mq = record.memory_queries.get_mut(&4).ok_or(ExecError::InvalidMemorySize(4))?; if let Some(result) = __mq.get_mut(&__values[..]) { if !unconstrained { *result.multiplicity += G::ONE; } result.output[0] } else { let __ptr = G::from_usize(__mq.len()); __mq.insert(&__values[..], &[__ptr], G::from_bool(!unconstrained)); __ptr } }; - let __ret: [G; OUT_253] = [__v_12, __v_16]; - if let Some(result) = record.function_queries[253].get_mut(&inp[..]) { debug_assert_eq!(result.output, &__ret[..]); if !unconstrained { *result.multiplicity += G::ONE; } } else { record.function_queries[253].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained)); }; + let __ret: [G; OUT_249] = [__v_12, __v_16]; + if let Some(result) = record.function_queries[249].get_mut(&inp[..]) { debug_assert_eq!(result.output, &__ret[..]); if !unconstrained { *result.multiplicity += G::ONE; } } else { record.function_queries[249].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained)); }; return Ok(__ret); }, _ => { let __v_12: G = G::from_u64(0); - let __r_arr: [G; OUT_766] = { let __args: [G; IN_766] = [__v_3, __v_12]; let __cu = unconstrained; if let Some(result) = record.function_queries[766].get_mut(&__args[..]) { if !__cu && *result.multiplicity == G::ZERO { aiur_fn_766(__args, record, io_buffer, false)? } else { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_766] = unsafe { *(result.output.as_ptr() as *const [G; OUT_766]) }; __ret } } else { aiur_fn_766(__args, record, io_buffer, __cu)? } }; + let __r_arr: [G; OUT_762] = { let __args: [G; IN_762] = [__v_3, __v_12]; let __cu = unconstrained; if let Some(result) = record.function_queries[762].get_mut(&__args[..]) { if !__cu && *result.multiplicity == G::ZERO { aiur_fn_762(__args, record, io_buffer, false)? } else { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_762] = unsafe { *(result.output.as_ptr() as *const [G; OUT_762]) }; __ret } } else { aiur_fn_762(__args, record, io_buffer, __cu)? } }; let __v_13: G = __r_arr[0]; - let __r_arr: [G; OUT_246] = { let __args: [G; IN_246] = [__v_13]; let __cu = unconstrained; if let Some(result) = record.function_queries[246].get_mut(&__args[..]) { if !__cu && *result.multiplicity == G::ZERO { aiur_fn_246(__args, record, io_buffer, false)? } else { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_246] = unsafe { *(result.output.as_ptr() as *const [G; OUT_246]) }; __ret } } else { aiur_fn_246(__args, record, io_buffer, __cu)? } }; + let __r_arr: [G; OUT_242] = { let __args: [G; IN_242] = [__v_13]; let __cu = unconstrained; if let Some(result) = record.function_queries[242].get_mut(&__args[..]) { if !__cu && *result.multiplicity == G::ZERO { aiur_fn_242(__args, record, io_buffer, false)? } else { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_242] = unsafe { *(result.output.as_ptr() as *const [G; OUT_242]) }; __ret } } else { aiur_fn_242(__args, record, io_buffer, __cu)? } }; let __v_14: G = __r_arr[0]; let __v_15: G = __r_arr[1]; let __v_16: G = __r_arr[2]; match __v_14.as_canonical_u64() { 1u64 => { - let __r_arr: [G; OUT_254] = { let __args: [G; IN_254] = [__v_0, __v_3, __v_15, __v_16]; let __cu = unconstrained; if let Some(result) = record.function_queries[254].get_mut(&__args[..]) { if !__cu && *result.multiplicity == G::ZERO { aiur_fn_254(__args, record, io_buffer, false)? } else { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_254] = unsafe { *(result.output.as_ptr() as *const [G; OUT_254]) }; __ret } } else { aiur_fn_254(__args, record, io_buffer, __cu)? } }; + let __r_arr: [G; OUT_250] = { let __args: [G; IN_250] = [__v_0, __v_3, __v_15, __v_16]; let __cu = unconstrained; if let Some(result) = record.function_queries[250].get_mut(&__args[..]) { if !__cu && *result.multiplicity == G::ZERO { aiur_fn_250(__args, record, io_buffer, false)? } else { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_250] = unsafe { *(result.output.as_ptr() as *const [G; OUT_250]) }; __ret } } else { aiur_fn_250(__args, record, io_buffer, __cu)? } }; let __v_17: G = __r_arr[0]; let __v_18: G = __r_arr[1]; - let __ret: [G; OUT_253] = [__v_17, __v_18]; - if let Some(result) = record.function_queries[253].get_mut(&inp[..]) { debug_assert_eq!(result.output, &__ret[..]); if !unconstrained { *result.multiplicity += G::ONE; } } else { record.function_queries[253].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained)); }; + let __ret: [G; OUT_249] = [__v_17, __v_18]; + if let Some(result) = record.function_queries[249].get_mut(&inp[..]) { debug_assert_eq!(result.output, &__ret[..]); if !unconstrained { *result.multiplicity += G::ONE; } } else { record.function_queries[249].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained)); }; return Ok(__ret); }, _ => { @@ -23838,8 +23564,8 @@ fn aiur_fn_253( let __v_19: G = G::from_u64(0); let __v_20: G = G::from_u64(0); let __v_21: G = { let __values: [G; 4] = [__v_18, __v_19, __v_20, __v_20]; let __mq = record.memory_queries.get_mut(&4).ok_or(ExecError::InvalidMemorySize(4))?; if let Some(result) = __mq.get_mut(&__values[..]) { if !unconstrained { *result.multiplicity += G::ONE; } result.output[0] } else { let __ptr = G::from_usize(__mq.len()); __mq.insert(&__values[..], &[__ptr], G::from_bool(!unconstrained)); __ptr } }; - let __ret: [G; OUT_253] = [__v_17, __v_21]; - if let Some(result) = record.function_queries[253].get_mut(&inp[..]) { debug_assert_eq!(result.output, &__ret[..]); if !unconstrained { *result.multiplicity += G::ONE; } } else { record.function_queries[253].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained)); }; + let __ret: [G; OUT_249] = [__v_17, __v_21]; + if let Some(result) = record.function_queries[249].get_mut(&inp[..]) { debug_assert_eq!(result.output, &__ret[..]); if !unconstrained { *result.multiplicity += G::ONE; } } else { record.function_queries[249].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained)); }; return Ok(__ret); }, } @@ -23850,15 +23576,15 @@ fn aiur_fn_253( }) } -const INPUT_SIZE_254: usize = 4; -const IN_254: usize = 4; -const OUT_254: usize = 2; -fn aiur_fn_254( - inp: [G; IN_254], +const INPUT_SIZE_250: usize = 4; +const IN_250: usize = 4; +const OUT_250: usize = 2; +fn aiur_fn_250( + inp: [G; IN_250], record: &mut QueryRecord, io_buffer: &mut IOBuffer, unconstrained: bool, -) -> Result<[G; OUT_254], ExecError> { +) -> Result<[G; OUT_250], ExecError> { stacker::maybe_grow(64 * 1024, 4 * 1024 * 1024, || { let __v_0: G = inp[0]; let __v_1: G = inp[1]; @@ -23881,9 +23607,9 @@ fn aiur_fn_254( match __v_11.as_canonical_u64() { 1u64 => { let __v_12: G = G::from_u64(1); - let __r_arr: [G; OUT_766] = { let __args: [G; IN_766] = [__v_1, __v_12]; let __cu = unconstrained; if let Some(result) = record.function_queries[766].get_mut(&__args[..]) { if !__cu && *result.multiplicity == G::ZERO { aiur_fn_766(__args, record, io_buffer, false)? } else { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_766] = unsafe { *(result.output.as_ptr() as *const [G; OUT_766]) }; __ret } } else { aiur_fn_766(__args, record, io_buffer, __cu)? } }; + let __r_arr: [G; OUT_762] = { let __args: [G; IN_762] = [__v_1, __v_12]; let __cu = unconstrained; if let Some(result) = record.function_queries[762].get_mut(&__args[..]) { if !__cu && *result.multiplicity == G::ZERO { aiur_fn_762(__args, record, io_buffer, false)? } else { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_762] = unsafe { *(result.output.as_ptr() as *const [G; OUT_762]) }; __ret } } else { aiur_fn_762(__args, record, io_buffer, __cu)? } }; let __v_13: G = __r_arr[0]; - let __r_arr: [G; OUT_243] = { let __args: [G; IN_243] = [__v_13]; let __cu = unconstrained; if let Some(result) = record.function_queries[243].get_mut(&__args[..]) { if !__cu && *result.multiplicity == G::ZERO { aiur_fn_243(__args, record, io_buffer, false)? } else { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_243] = unsafe { *(result.output.as_ptr() as *const [G; OUT_243]) }; __ret } } else { aiur_fn_243(__args, record, io_buffer, __cu)? } }; + let __r_arr: [G; OUT_239] = { let __args: [G; IN_239] = [__v_13]; let __cu = unconstrained; if let Some(result) = record.function_queries[239].get_mut(&__args[..]) { if !__cu && *result.multiplicity == G::ZERO { aiur_fn_239(__args, record, io_buffer, false)? } else { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_239] = unsafe { *(result.output.as_ptr() as *const [G; OUT_239]) }; __ret } } else { aiur_fn_239(__args, record, io_buffer, __cu)? } }; let __v_14: G = __r_arr[0]; let __v_15: G = __r_arr[1]; match __v_14.as_canonical_u64() { @@ -23894,7 +23620,7 @@ fn aiur_fn_254( let __v_17: G = __r_arr[0]; let __mc_out___mc_0: [G; 1] = '__mc_0: { match __v_17.as_canonical_u64() { 1u64 => { - let __r_arr: [G; OUT_251] = { let __args: [G; IN_251] = [__v_2, __v_3, __v_15]; let __cu = unconstrained; if let Some(result) = record.function_queries[251].get_mut(&__args[..]) { if !__cu && *result.multiplicity == G::ZERO { aiur_fn_251(__args, record, io_buffer, false)? } else { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_251] = unsafe { *(result.output.as_ptr() as *const [G; OUT_251]) }; __ret } } else { aiur_fn_251(__args, record, io_buffer, __cu)? } }; + let __r_arr: [G; OUT_247] = { let __args: [G; IN_247] = [__v_2, __v_3, __v_15]; let __cu = unconstrained; if let Some(result) = record.function_queries[247].get_mut(&__args[..]) { if !__cu && *result.multiplicity == G::ZERO { aiur_fn_247(__args, record, io_buffer, false)? } else { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_247] = unsafe { *(result.output.as_ptr() as *const [G; OUT_247]) }; __ret } } else { aiur_fn_247(__args, record, io_buffer, __cu)? } }; let __v_18: G = __r_arr[0]; break '__mc_0 [__v_18]; }, @@ -23905,7 +23631,7 @@ fn aiur_fn_254( let __v_19: G = __r_arr[0]; match __v_19.as_canonical_u64() { 1u64 => { - let __r_arr: [G; OUT_252] = { let __args: [G; IN_252] = [__v_2, __v_3, __v_15]; let __cu = unconstrained; if let Some(result) = record.function_queries[252].get_mut(&__args[..]) { if !__cu && *result.multiplicity == G::ZERO { aiur_fn_252(__args, record, io_buffer, false)? } else { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_252] = unsafe { *(result.output.as_ptr() as *const [G; OUT_252]) }; __ret } } else { aiur_fn_252(__args, record, io_buffer, __cu)? } }; + let __r_arr: [G; OUT_248] = { let __args: [G; IN_248] = [__v_2, __v_3, __v_15]; let __cu = unconstrained; if let Some(result) = record.function_queries[248].get_mut(&__args[..]) { if !__cu && *result.multiplicity == G::ZERO { aiur_fn_248(__args, record, io_buffer, false)? } else { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_248] = unsafe { *(result.output.as_ptr() as *const [G; OUT_248]) }; __ret } } else { aiur_fn_248(__args, record, io_buffer, __cu)? } }; let __v_20: G = __r_arr[0]; break '__mc_0 [__v_20]; }, @@ -23932,7 +23658,7 @@ fn aiur_fn_254( let __v_37: G = (__v_2 * __v_36); let __r_arr: [G; OUT_134] = { let __args: [G; IN_134] = [__v_3, __v_15]; let __cu = unconstrained; if let Some(result) = record.function_queries[134].get_mut(&__args[..]) { if !__cu && *result.multiplicity == G::ZERO { aiur_fn_134(__args, record, io_buffer, false)? } else { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_134] = unsafe { *(result.output.as_ptr() as *const [G; OUT_134]) }; __ret } } else { aiur_fn_134(__args, record, io_buffer, __cu)? } }; let __v_38: G = __r_arr[0]; - let __r_arr: [G; OUT_247] = { let __args: [G; IN_247] = [__v_37, __v_38]; let __cu = unconstrained; if let Some(result) = record.function_queries[247].get_mut(&__args[..]) { if !__cu && *result.multiplicity == G::ZERO { aiur_fn_247(__args, record, io_buffer, false)? } else { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_247] = unsafe { *(result.output.as_ptr() as *const [G; OUT_247]) }; __ret } } else { aiur_fn_247(__args, record, io_buffer, __cu)? } }; + let __r_arr: [G; OUT_243] = { let __args: [G; IN_243] = [__v_37, __v_38]; let __cu = unconstrained; if let Some(result) = record.function_queries[243].get_mut(&__args[..]) { if !__cu && *result.multiplicity == G::ZERO { aiur_fn_243(__args, record, io_buffer, false)? } else { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_243] = unsafe { *(result.output.as_ptr() as *const [G; OUT_243]) }; __ret } } else { aiur_fn_243(__args, record, io_buffer, __cu)? } }; let __v_39: G = __r_arr[0]; break '__mc_0 [__v_39]; }, @@ -23943,12 +23669,12 @@ fn aiur_fn_254( let __v_18: G = __mc_out___mc_0[0]; let __v_19: G = G::from_u64(1); let __v_20: G = G::from_u64(2); - let __r_arr: [G; OUT_775] = { let __args: [G; IN_775] = [__v_1, __v_20]; let __cu = unconstrained; if let Some(result) = record.function_queries[775].get_mut(&__args[..]) { if !__cu && *result.multiplicity == G::ZERO { aiur_fn_775(__args, record, io_buffer, false)? } else { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_775] = unsafe { *(result.output.as_ptr() as *const [G; OUT_775]) }; __ret } } else { aiur_fn_775(__args, record, io_buffer, __cu)? } }; + let __r_arr: [G; OUT_771] = { let __args: [G; IN_771] = [__v_1, __v_20]; let __cu = unconstrained; if let Some(result) = record.function_queries[771].get_mut(&__args[..]) { if !__cu && *result.multiplicity == G::ZERO { aiur_fn_771(__args, record, io_buffer, false)? } else { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_771] = unsafe { *(result.output.as_ptr() as *const [G; OUT_771]) }; __ret } } else { aiur_fn_771(__args, record, io_buffer, __cu)? } }; let __v_21: G = __r_arr[0]; - let __r_arr: [G; OUT_255] = { let __args: [G; IN_255] = [__v_18, __v_21]; let __cu = unconstrained; if let Some(result) = record.function_queries[255].get_mut(&__args[..]) { if !__cu && *result.multiplicity == G::ZERO { aiur_fn_255(__args, record, io_buffer, false)? } else { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_255] = unsafe { *(result.output.as_ptr() as *const [G; OUT_255]) }; __ret } } else { aiur_fn_255(__args, record, io_buffer, __cu)? } }; + let __r_arr: [G; OUT_251] = { let __args: [G; IN_251] = [__v_18, __v_21]; let __cu = unconstrained; if let Some(result) = record.function_queries[251].get_mut(&__args[..]) { if !__cu && *result.multiplicity == G::ZERO { aiur_fn_251(__args, record, io_buffer, false)? } else { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_251] = unsafe { *(result.output.as_ptr() as *const [G; OUT_251]) }; __ret } } else { aiur_fn_251(__args, record, io_buffer, __cu)? } }; let __v_22: G = __r_arr[0]; - let __ret: [G; OUT_254] = [__v_19, __v_22]; - if let Some(result) = record.function_queries[254].get_mut(&inp[..]) { debug_assert_eq!(result.output, &__ret[..]); if !unconstrained { *result.multiplicity += G::ONE; } } else { record.function_queries[254].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained)); }; + let __ret: [G; OUT_250] = [__v_19, __v_22]; + if let Some(result) = record.function_queries[250].get_mut(&inp[..]) { debug_assert_eq!(result.output, &__ret[..]); if !unconstrained { *result.multiplicity += G::ONE; } } else { record.function_queries[250].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained)); }; return Ok(__ret); }, _ => { @@ -23957,17 +23683,17 @@ fn aiur_fn_254( let __v_18: G = G::from_u64(0); let __v_19: G = G::from_u64(0); let __v_20: G = { let __values: [G; 4] = [__v_17, __v_18, __v_19, __v_19]; let __mq = record.memory_queries.get_mut(&4).ok_or(ExecError::InvalidMemorySize(4))?; if let Some(result) = __mq.get_mut(&__values[..]) { if !unconstrained { *result.multiplicity += G::ONE; } result.output[0] } else { let __ptr = G::from_usize(__mq.len()); __mq.insert(&__values[..], &[__ptr], G::from_bool(!unconstrained)); __ptr } }; - let __ret: [G; OUT_254] = [__v_16, __v_20]; - if let Some(result) = record.function_queries[254].get_mut(&inp[..]) { debug_assert_eq!(result.output, &__ret[..]); if !unconstrained { *result.multiplicity += G::ONE; } } else { record.function_queries[254].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained)); }; + let __ret: [G; OUT_250] = [__v_16, __v_20]; + if let Some(result) = record.function_queries[250].get_mut(&inp[..]) { debug_assert_eq!(result.output, &__ret[..]); if !unconstrained { *result.multiplicity += G::ONE; } } else { record.function_queries[250].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained)); }; return Ok(__ret); }, } }, _ => { let __v_12: G = G::from_u64(1); - let __r_arr: [G; OUT_766] = { let __args: [G; IN_766] = [__v_1, __v_12]; let __cu = unconstrained; if let Some(result) = record.function_queries[766].get_mut(&__args[..]) { if !__cu && *result.multiplicity == G::ZERO { aiur_fn_766(__args, record, io_buffer, false)? } else { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_766] = unsafe { *(result.output.as_ptr() as *const [G; OUT_766]) }; __ret } } else { aiur_fn_766(__args, record, io_buffer, __cu)? } }; + let __r_arr: [G; OUT_762] = { let __args: [G; IN_762] = [__v_1, __v_12]; let __cu = unconstrained; if let Some(result) = record.function_queries[762].get_mut(&__args[..]) { if !__cu && *result.multiplicity == G::ZERO { aiur_fn_762(__args, record, io_buffer, false)? } else { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_762] = unsafe { *(result.output.as_ptr() as *const [G; OUT_762]) }; __ret } } else { aiur_fn_762(__args, record, io_buffer, __cu)? } }; let __v_13: G = __r_arr[0]; - let __r_arr: [G; OUT_246] = { let __args: [G; IN_246] = [__v_13]; let __cu = unconstrained; if let Some(result) = record.function_queries[246].get_mut(&__args[..]) { if !__cu && *result.multiplicity == G::ZERO { aiur_fn_246(__args, record, io_buffer, false)? } else { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_246] = unsafe { *(result.output.as_ptr() as *const [G; OUT_246]) }; __ret } } else { aiur_fn_246(__args, record, io_buffer, __cu)? } }; + let __r_arr: [G; OUT_242] = { let __args: [G; IN_242] = [__v_13]; let __cu = unconstrained; if let Some(result) = record.function_queries[242].get_mut(&__args[..]) { if !__cu && *result.multiplicity == G::ZERO { aiur_fn_242(__args, record, io_buffer, false)? } else { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_242] = unsafe { *(result.output.as_ptr() as *const [G; OUT_242]) }; __ret } } else { aiur_fn_242(__args, record, io_buffer, __cu)? } }; let __v_14: G = __r_arr[0]; let __v_15: G = __r_arr[1]; let __v_16: G = __r_arr[2]; @@ -23979,7 +23705,7 @@ fn aiur_fn_254( let __v_18: G = __r_arr[0]; let __mc_out___mc_1: [G; 1] = '__mc_1: { match __v_18.as_canonical_u64() { 1u64 => { - let __r_arr: [G; OUT_248] = { let __args: [G; IN_248] = [__v_2, __v_3, __v_15, __v_16]; let __cu = unconstrained; if let Some(result) = record.function_queries[248].get_mut(&__args[..]) { if !__cu && *result.multiplicity == G::ZERO { aiur_fn_248(__args, record, io_buffer, false)? } else { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_248] = unsafe { *(result.output.as_ptr() as *const [G; OUT_248]) }; __ret } } else { aiur_fn_248(__args, record, io_buffer, __cu)? } }; + let __r_arr: [G; OUT_244] = { let __args: [G; IN_244] = [__v_2, __v_3, __v_15, __v_16]; let __cu = unconstrained; if let Some(result) = record.function_queries[244].get_mut(&__args[..]) { if !__cu && *result.multiplicity == G::ZERO { aiur_fn_244(__args, record, io_buffer, false)? } else { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_244] = unsafe { *(result.output.as_ptr() as *const [G; OUT_244]) }; __ret } } else { aiur_fn_244(__args, record, io_buffer, __cu)? } }; let __v_19: G = __r_arr[0]; break '__mc_1 [__v_19]; }, @@ -23997,7 +23723,7 @@ fn aiur_fn_254( let __v_24: G = __r_arr[0]; let __v_25: G = (__v_23 - __v_24); let __v_26: G = (__v_22 * __v_25); - let __r_arr: [G; OUT_248] = { let __args: [G; IN_248] = [__v_2, __v_3, __v_26, __v_16]; let __cu = unconstrained; if let Some(result) = record.function_queries[248].get_mut(&__args[..]) { if !__cu && *result.multiplicity == G::ZERO { aiur_fn_248(__args, record, io_buffer, false)? } else { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_248] = unsafe { *(result.output.as_ptr() as *const [G; OUT_248]) }; __ret } } else { aiur_fn_248(__args, record, io_buffer, __cu)? } }; + let __r_arr: [G; OUT_244] = { let __args: [G; IN_244] = [__v_2, __v_3, __v_26, __v_16]; let __cu = unconstrained; if let Some(result) = record.function_queries[244].get_mut(&__args[..]) { if !__cu && *result.multiplicity == G::ZERO { aiur_fn_244(__args, record, io_buffer, false)? } else { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_244] = unsafe { *(result.output.as_ptr() as *const [G; OUT_244]) }; __ret } } else { aiur_fn_244(__args, record, io_buffer, __cu)? } }; let __v_27: G = __r_arr[0]; break '__mc_1 [__v_27]; }, @@ -24025,7 +23751,7 @@ fn aiur_fn_254( let __v_35: G = (__v_27 * __v_34); let __r_arr: [G; OUT_125] = { let __args: [G; IN_125] = [__v_3, __v_16]; let __cu = unconstrained; if let Some(result) = record.function_queries[125].get_mut(&__args[..]) { if !__cu && *result.multiplicity == G::ZERO { aiur_fn_125(__args, record, io_buffer, false)? } else { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_125] = unsafe { *(result.output.as_ptr() as *const [G; OUT_125]) }; __ret } } else { aiur_fn_125(__args, record, io_buffer, __cu)? } }; let __v_36: G = __r_arr[0]; - let __r_arr: [G; OUT_247] = { let __args: [G; IN_247] = [__v_35, __v_36]; let __cu = unconstrained; if let Some(result) = record.function_queries[247].get_mut(&__args[..]) { if !__cu && *result.multiplicity == G::ZERO { aiur_fn_247(__args, record, io_buffer, false)? } else { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_247] = unsafe { *(result.output.as_ptr() as *const [G; OUT_247]) }; __ret } } else { aiur_fn_247(__args, record, io_buffer, __cu)? } }; + let __r_arr: [G; OUT_243] = { let __args: [G; IN_243] = [__v_35, __v_36]; let __cu = unconstrained; if let Some(result) = record.function_queries[243].get_mut(&__args[..]) { if !__cu && *result.multiplicity == G::ZERO { aiur_fn_243(__args, record, io_buffer, false)? } else { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_243] = unsafe { *(result.output.as_ptr() as *const [G; OUT_243]) }; __ret } } else { aiur_fn_243(__args, record, io_buffer, __cu)? } }; let __v_37: G = __r_arr[0]; break '__mc_1 [__v_37]; }, @@ -24036,12 +23762,12 @@ fn aiur_fn_254( let __v_24: G = __r_arr[0]; match __v_24.as_canonical_u64() { 1u64 => { - let __r_arr: [G; OUT_249] = { let __args: [G; IN_249] = [__v_2, __v_3, __v_16]; let __cu = unconstrained; if let Some(result) = record.function_queries[249].get_mut(&__args[..]) { if !__cu && *result.multiplicity == G::ZERO { aiur_fn_249(__args, record, io_buffer, false)? } else { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_249] = unsafe { *(result.output.as_ptr() as *const [G; OUT_249]) }; __ret } } else { aiur_fn_249(__args, record, io_buffer, __cu)? } }; + let __r_arr: [G; OUT_245] = { let __args: [G; IN_245] = [__v_2, __v_3, __v_16]; let __cu = unconstrained; if let Some(result) = record.function_queries[245].get_mut(&__args[..]) { if !__cu && *result.multiplicity == G::ZERO { aiur_fn_245(__args, record, io_buffer, false)? } else { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_245] = unsafe { *(result.output.as_ptr() as *const [G; OUT_245]) }; __ret } } else { aiur_fn_245(__args, record, io_buffer, __cu)? } }; let __v_25: G = __r_arr[0]; break '__mc_1 [__v_25]; }, _ => { - let __r_arr: [G; OUT_250] = { let __args: [G; IN_250] = [__v_2, __v_3, __v_15, __v_16]; let __cu = unconstrained; if let Some(result) = record.function_queries[250].get_mut(&__args[..]) { if !__cu && *result.multiplicity == G::ZERO { aiur_fn_250(__args, record, io_buffer, false)? } else { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_250] = unsafe { *(result.output.as_ptr() as *const [G; OUT_250]) }; __ret } } else { aiur_fn_250(__args, record, io_buffer, __cu)? } }; + let __r_arr: [G; OUT_246] = { let __args: [G; IN_246] = [__v_2, __v_3, __v_15, __v_16]; let __cu = unconstrained; if let Some(result) = record.function_queries[246].get_mut(&__args[..]) { if !__cu && *result.multiplicity == G::ZERO { aiur_fn_246(__args, record, io_buffer, false)? } else { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_246] = unsafe { *(result.output.as_ptr() as *const [G; OUT_246]) }; __ret } } else { aiur_fn_246(__args, record, io_buffer, __cu)? } }; let __v_25: G = __r_arr[0]; break '__mc_1 [__v_25]; }, @@ -24056,12 +23782,12 @@ fn aiur_fn_254( let __v_19: G = __mc_out___mc_1[0]; let __v_20: G = G::from_u64(1); let __v_21: G = G::from_u64(2); - let __r_arr: [G; OUT_775] = { let __args: [G; IN_775] = [__v_1, __v_21]; let __cu = unconstrained; if let Some(result) = record.function_queries[775].get_mut(&__args[..]) { if !__cu && *result.multiplicity == G::ZERO { aiur_fn_775(__args, record, io_buffer, false)? } else { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_775] = unsafe { *(result.output.as_ptr() as *const [G; OUT_775]) }; __ret } } else { aiur_fn_775(__args, record, io_buffer, __cu)? } }; + let __r_arr: [G; OUT_771] = { let __args: [G; IN_771] = [__v_1, __v_21]; let __cu = unconstrained; if let Some(result) = record.function_queries[771].get_mut(&__args[..]) { if !__cu && *result.multiplicity == G::ZERO { aiur_fn_771(__args, record, io_buffer, false)? } else { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_771] = unsafe { *(result.output.as_ptr() as *const [G; OUT_771]) }; __ret } } else { aiur_fn_771(__args, record, io_buffer, __cu)? } }; let __v_22: G = __r_arr[0]; - let __r_arr: [G; OUT_255] = { let __args: [G; IN_255] = [__v_19, __v_22]; let __cu = unconstrained; if let Some(result) = record.function_queries[255].get_mut(&__args[..]) { if !__cu && *result.multiplicity == G::ZERO { aiur_fn_255(__args, record, io_buffer, false)? } else { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_255] = unsafe { *(result.output.as_ptr() as *const [G; OUT_255]) }; __ret } } else { aiur_fn_255(__args, record, io_buffer, __cu)? } }; + let __r_arr: [G; OUT_251] = { let __args: [G; IN_251] = [__v_19, __v_22]; let __cu = unconstrained; if let Some(result) = record.function_queries[251].get_mut(&__args[..]) { if !__cu && *result.multiplicity == G::ZERO { aiur_fn_251(__args, record, io_buffer, false)? } else { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_251] = unsafe { *(result.output.as_ptr() as *const [G; OUT_251]) }; __ret } } else { aiur_fn_251(__args, record, io_buffer, __cu)? } }; let __v_23: G = __r_arr[0]; - let __ret: [G; OUT_254] = [__v_20, __v_23]; - if let Some(result) = record.function_queries[254].get_mut(&inp[..]) { debug_assert_eq!(result.output, &__ret[..]); if !unconstrained { *result.multiplicity += G::ONE; } } else { record.function_queries[254].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained)); }; + let __ret: [G; OUT_250] = [__v_20, __v_23]; + if let Some(result) = record.function_queries[250].get_mut(&inp[..]) { debug_assert_eq!(result.output, &__ret[..]); if !unconstrained { *result.multiplicity += G::ONE; } } else { record.function_queries[250].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained)); }; return Ok(__ret); }, _ => { @@ -24070,8 +23796,8 @@ fn aiur_fn_254( let __v_19: G = G::from_u64(0); let __v_20: G = G::from_u64(0); let __v_21: G = { let __values: [G; 4] = [__v_18, __v_19, __v_20, __v_20]; let __mq = record.memory_queries.get_mut(&4).ok_or(ExecError::InvalidMemorySize(4))?; if let Some(result) = __mq.get_mut(&__values[..]) { if !unconstrained { *result.multiplicity += G::ONE; } result.output[0] } else { let __ptr = G::from_usize(__mq.len()); __mq.insert(&__values[..], &[__ptr], G::from_bool(!unconstrained)); __ptr } }; - let __ret: [G; OUT_254] = [__v_17, __v_21]; - if let Some(result) = record.function_queries[254].get_mut(&inp[..]) { debug_assert_eq!(result.output, &__ret[..]); if !unconstrained { *result.multiplicity += G::ONE; } } else { record.function_queries[254].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained)); }; + let __ret: [G; OUT_250] = [__v_17, __v_21]; + if let Some(result) = record.function_queries[250].get_mut(&inp[..]) { debug_assert_eq!(result.output, &__ret[..]); if !unconstrained { *result.multiplicity += G::ONE; } } else { record.function_queries[250].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained)); }; return Ok(__ret); }, } @@ -24080,15 +23806,15 @@ fn aiur_fn_254( }) } -const INPUT_SIZE_255: usize = 2; -const IN_255: usize = 2; -const OUT_255: usize = 1; -fn aiur_fn_255( - inp: [G; IN_255], +const INPUT_SIZE_251: usize = 2; +const IN_251: usize = 2; +const OUT_251: usize = 1; +fn aiur_fn_251( + inp: [G; IN_251], record: &mut QueryRecord, io_buffer: &mut IOBuffer, unconstrained: bool, -) -> Result<[G; OUT_255], ExecError> { +) -> Result<[G; OUT_251], ExecError> { stacker::maybe_grow(64 * 1024, 4 * 1024 * 1024, || { let __v_0: G = inp[0]; let __v_1: G = inp[1]; @@ -24098,18 +23824,18 @@ fn aiur_fn_255( let __v_4: G = __loaded[2]; match __v_2.as_canonical_u64() { 1u64 => { - let __ret: [G; OUT_255] = [__v_0]; - if let Some(result) = record.function_queries[255].get_mut(&inp[..]) { debug_assert_eq!(result.output, &__ret[..]); if !unconstrained { *result.multiplicity += G::ONE; } } else { record.function_queries[255].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained)); }; + let __ret: [G; OUT_251] = [__v_0]; + if let Some(result) = record.function_queries[251].get_mut(&inp[..]) { debug_assert_eq!(result.output, &__ret[..]); if !unconstrained { *result.multiplicity += G::ONE; } } else { record.function_queries[251].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained)); }; return Ok(__ret); }, 0u64 => { let __v_5: G = G::from_u64(3); let __v_6: G = G::from_u64(0); let __v_7: G = { let __values: [G; 4] = [__v_5, __v_0, __v_3, __v_6]; let __mq = record.memory_queries.get_mut(&4).ok_or(ExecError::InvalidMemorySize(4))?; if let Some(result) = __mq.get_mut(&__values[..]) { if !unconstrained { *result.multiplicity += G::ONE; } result.output[0] } else { let __ptr = G::from_usize(__mq.len()); __mq.insert(&__values[..], &[__ptr], G::from_bool(!unconstrained)); __ptr } }; - let __r_arr: [G; OUT_255] = { let __args: [G; IN_255] = [__v_7, __v_4]; let __cu = unconstrained; if let Some(result) = record.function_queries[255].get_mut(&__args[..]) { if !__cu && *result.multiplicity == G::ZERO { aiur_fn_255(__args, record, io_buffer, false)? } else { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_255] = unsafe { *(result.output.as_ptr() as *const [G; OUT_255]) }; __ret } } else { aiur_fn_255(__args, record, io_buffer, __cu)? } }; + let __r_arr: [G; OUT_251] = { let __args: [G; IN_251] = [__v_7, __v_4]; let __cu = unconstrained; if let Some(result) = record.function_queries[251].get_mut(&__args[..]) { if !__cu && *result.multiplicity == G::ZERO { aiur_fn_251(__args, record, io_buffer, false)? } else { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_251] = unsafe { *(result.output.as_ptr() as *const [G; OUT_251]) }; __ret } } else { aiur_fn_251(__args, record, io_buffer, __cu)? } }; let __v_8: G = __r_arr[0]; - let __ret: [G; OUT_255] = [__v_8]; - if let Some(result) = record.function_queries[255].get_mut(&inp[..]) { debug_assert_eq!(result.output, &__ret[..]); if !unconstrained { *result.multiplicity += G::ONE; } } else { record.function_queries[255].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained)); }; + let __ret: [G; OUT_251] = [__v_8]; + if let Some(result) = record.function_queries[251].get_mut(&inp[..]) { debug_assert_eq!(result.output, &__ret[..]); if !unconstrained { *result.multiplicity += G::ONE; } } else { record.function_queries[251].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained)); }; return Ok(__ret); }, _ => { @@ -24119,15 +23845,15 @@ fn aiur_fn_255( }) } -const INPUT_SIZE_256: usize = 3; -const IN_256: usize = 3; -const OUT_256: usize = 2; -fn aiur_fn_256( - inp: [G; IN_256], +const INPUT_SIZE_252: usize = 3; +const IN_252: usize = 3; +const OUT_252: usize = 2; +fn aiur_fn_252( + inp: [G; IN_252], record: &mut QueryRecord, io_buffer: &mut IOBuffer, unconstrained: bool, -) -> Result<[G; OUT_256], ExecError> { +) -> Result<[G; OUT_252], ExecError> { stacker::maybe_grow(64 * 1024, 4 * 1024 * 1024, || { let __v_0: G = inp[0]; let __v_1: G = inp[1]; @@ -24143,10 +23869,10 @@ fn aiur_fn_256( let __v_6: G = __r_arr[0]; let __r_arr: [G; OUT_118] = { let __args: [G; IN_118] = [__v_6]; let __cu = unconstrained; if let Some(result) = record.function_queries[118].get_mut(&__args[..]) { if !__cu && *result.multiplicity == G::ZERO { aiur_fn_118(__args, record, io_buffer, false)? } else { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_118] = unsafe { *(result.output.as_ptr() as *const [G; OUT_118]) }; __ret } } else { aiur_fn_118(__args, record, io_buffer, __cu)? } }; let __v_7: G = __r_arr[0]; - let __r_arr: [G; OUT_245] = { let __args: [G; IN_245] = [__v_7]; let __cu = unconstrained; if let Some(result) = record.function_queries[245].get_mut(&__args[..]) { if !__cu && *result.multiplicity == G::ZERO { aiur_fn_245(__args, record, io_buffer, false)? } else { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_245] = unsafe { *(result.output.as_ptr() as *const [G; OUT_245]) }; __ret } } else { aiur_fn_245(__args, record, io_buffer, __cu)? } }; + let __r_arr: [G; OUT_241] = { let __args: [G; IN_241] = [__v_7]; let __cu = unconstrained; if let Some(result) = record.function_queries[241].get_mut(&__args[..]) { if !__cu && *result.multiplicity == G::ZERO { aiur_fn_241(__args, record, io_buffer, false)? } else { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_241] = unsafe { *(result.output.as_ptr() as *const [G; OUT_241]) }; __ret } } else { aiur_fn_241(__args, record, io_buffer, __cu)? } }; let __v_8: G = __r_arr[0]; - let __ret: [G; OUT_256] = [__v_5, __v_8]; - if let Some(result) = record.function_queries[256].get_mut(&inp[..]) { debug_assert_eq!(result.output, &__ret[..]); if !unconstrained { *result.multiplicity += G::ONE; } } else { record.function_queries[256].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained)); }; + let __ret: [G; OUT_252] = [__v_5, __v_8]; + if let Some(result) = record.function_queries[252].get_mut(&inp[..]) { debug_assert_eq!(result.output, &__ret[..]); if !unconstrained { *result.multiplicity += G::ONE; } } else { record.function_queries[252].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained)); }; return Ok(__ret); }, _ => { @@ -24161,10 +23887,10 @@ fn aiur_fn_256( let __v_8: G = __r_arr[0]; let __r_arr: [G; OUT_118] = { let __args: [G; IN_118] = [__v_8]; let __cu = unconstrained; if let Some(result) = record.function_queries[118].get_mut(&__args[..]) { if !__cu && *result.multiplicity == G::ZERO { aiur_fn_118(__args, record, io_buffer, false)? } else { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_118] = unsafe { *(result.output.as_ptr() as *const [G; OUT_118]) }; __ret } } else { aiur_fn_118(__args, record, io_buffer, __cu)? } }; let __v_9: G = __r_arr[0]; - let __r_arr: [G; OUT_245] = { let __args: [G; IN_245] = [__v_9]; let __cu = unconstrained; if let Some(result) = record.function_queries[245].get_mut(&__args[..]) { if !__cu && *result.multiplicity == G::ZERO { aiur_fn_245(__args, record, io_buffer, false)? } else { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_245] = unsafe { *(result.output.as_ptr() as *const [G; OUT_245]) }; __ret } } else { aiur_fn_245(__args, record, io_buffer, __cu)? } }; + let __r_arr: [G; OUT_241] = { let __args: [G; IN_241] = [__v_9]; let __cu = unconstrained; if let Some(result) = record.function_queries[241].get_mut(&__args[..]) { if !__cu && *result.multiplicity == G::ZERO { aiur_fn_241(__args, record, io_buffer, false)? } else { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_241] = unsafe { *(result.output.as_ptr() as *const [G; OUT_241]) }; __ret } } else { aiur_fn_241(__args, record, io_buffer, __cu)? } }; let __v_10: G = __r_arr[0]; - let __ret: [G; OUT_256] = [__v_7, __v_10]; - if let Some(result) = record.function_queries[256].get_mut(&inp[..]) { debug_assert_eq!(result.output, &__ret[..]); if !unconstrained { *result.multiplicity += G::ONE; } } else { record.function_queries[256].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained)); }; + let __ret: [G; OUT_252] = [__v_7, __v_10]; + if let Some(result) = record.function_queries[252].get_mut(&inp[..]) { debug_assert_eq!(result.output, &__ret[..]); if !unconstrained { *result.multiplicity += G::ONE; } } else { record.function_queries[252].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained)); }; return Ok(__ret); }, _ => { @@ -24179,10 +23905,10 @@ fn aiur_fn_256( let __v_10: G = __r_arr[0]; let __r_arr: [G; OUT_118] = { let __args: [G; IN_118] = [__v_10]; let __cu = unconstrained; if let Some(result) = record.function_queries[118].get_mut(&__args[..]) { if !__cu && *result.multiplicity == G::ZERO { aiur_fn_118(__args, record, io_buffer, false)? } else { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_118] = unsafe { *(result.output.as_ptr() as *const [G; OUT_118]) }; __ret } } else { aiur_fn_118(__args, record, io_buffer, __cu)? } }; let __v_11: G = __r_arr[0]; - let __r_arr: [G; OUT_245] = { let __args: [G; IN_245] = [__v_11]; let __cu = unconstrained; if let Some(result) = record.function_queries[245].get_mut(&__args[..]) { if !__cu && *result.multiplicity == G::ZERO { aiur_fn_245(__args, record, io_buffer, false)? } else { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_245] = unsafe { *(result.output.as_ptr() as *const [G; OUT_245]) }; __ret } } else { aiur_fn_245(__args, record, io_buffer, __cu)? } }; + let __r_arr: [G; OUT_241] = { let __args: [G; IN_241] = [__v_11]; let __cu = unconstrained; if let Some(result) = record.function_queries[241].get_mut(&__args[..]) { if !__cu && *result.multiplicity == G::ZERO { aiur_fn_241(__args, record, io_buffer, false)? } else { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_241] = unsafe { *(result.output.as_ptr() as *const [G; OUT_241]) }; __ret } } else { aiur_fn_241(__args, record, io_buffer, __cu)? } }; let __v_12: G = __r_arr[0]; - let __ret: [G; OUT_256] = [__v_9, __v_12]; - if let Some(result) = record.function_queries[256].get_mut(&inp[..]) { debug_assert_eq!(result.output, &__ret[..]); if !unconstrained { *result.multiplicity += G::ONE; } } else { record.function_queries[256].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained)); }; + let __ret: [G; OUT_252] = [__v_9, __v_12]; + if let Some(result) = record.function_queries[252].get_mut(&inp[..]) { debug_assert_eq!(result.output, &__ret[..]); if !unconstrained { *result.multiplicity += G::ONE; } } else { record.function_queries[252].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained)); }; return Ok(__ret); }, _ => { @@ -24197,10 +23923,10 @@ fn aiur_fn_256( let __v_12: G = __r_arr[0]; let __r_arr: [G; OUT_118] = { let __args: [G; IN_118] = [__v_12]; let __cu = unconstrained; if let Some(result) = record.function_queries[118].get_mut(&__args[..]) { if !__cu && *result.multiplicity == G::ZERO { aiur_fn_118(__args, record, io_buffer, false)? } else { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_118] = unsafe { *(result.output.as_ptr() as *const [G; OUT_118]) }; __ret } } else { aiur_fn_118(__args, record, io_buffer, __cu)? } }; let __v_13: G = __r_arr[0]; - let __r_arr: [G; OUT_245] = { let __args: [G; IN_245] = [__v_13]; let __cu = unconstrained; if let Some(result) = record.function_queries[245].get_mut(&__args[..]) { if !__cu && *result.multiplicity == G::ZERO { aiur_fn_245(__args, record, io_buffer, false)? } else { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_245] = unsafe { *(result.output.as_ptr() as *const [G; OUT_245]) }; __ret } } else { aiur_fn_245(__args, record, io_buffer, __cu)? } }; + let __r_arr: [G; OUT_241] = { let __args: [G; IN_241] = [__v_13]; let __cu = unconstrained; if let Some(result) = record.function_queries[241].get_mut(&__args[..]) { if !__cu && *result.multiplicity == G::ZERO { aiur_fn_241(__args, record, io_buffer, false)? } else { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_241] = unsafe { *(result.output.as_ptr() as *const [G; OUT_241]) }; __ret } } else { aiur_fn_241(__args, record, io_buffer, __cu)? } }; let __v_14: G = __r_arr[0]; - let __ret: [G; OUT_256] = [__v_11, __v_14]; - if let Some(result) = record.function_queries[256].get_mut(&inp[..]) { debug_assert_eq!(result.output, &__ret[..]); if !unconstrained { *result.multiplicity += G::ONE; } } else { record.function_queries[256].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained)); }; + let __ret: [G; OUT_252] = [__v_11, __v_14]; + if let Some(result) = record.function_queries[252].get_mut(&inp[..]) { debug_assert_eq!(result.output, &__ret[..]); if !unconstrained { *result.multiplicity += G::ONE; } } else { record.function_queries[252].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained)); }; return Ok(__ret); }, _ => { @@ -24215,10 +23941,10 @@ fn aiur_fn_256( let __v_14: G = __r_arr[0]; let __r_arr: [G; OUT_118] = { let __args: [G; IN_118] = [__v_14]; let __cu = unconstrained; if let Some(result) = record.function_queries[118].get_mut(&__args[..]) { if !__cu && *result.multiplicity == G::ZERO { aiur_fn_118(__args, record, io_buffer, false)? } else { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_118] = unsafe { *(result.output.as_ptr() as *const [G; OUT_118]) }; __ret } } else { aiur_fn_118(__args, record, io_buffer, __cu)? } }; let __v_15: G = __r_arr[0]; - let __r_arr: [G; OUT_245] = { let __args: [G; IN_245] = [__v_15]; let __cu = unconstrained; if let Some(result) = record.function_queries[245].get_mut(&__args[..]) { if !__cu && *result.multiplicity == G::ZERO { aiur_fn_245(__args, record, io_buffer, false)? } else { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_245] = unsafe { *(result.output.as_ptr() as *const [G; OUT_245]) }; __ret } } else { aiur_fn_245(__args, record, io_buffer, __cu)? } }; + let __r_arr: [G; OUT_241] = { let __args: [G; IN_241] = [__v_15]; let __cu = unconstrained; if let Some(result) = record.function_queries[241].get_mut(&__args[..]) { if !__cu && *result.multiplicity == G::ZERO { aiur_fn_241(__args, record, io_buffer, false)? } else { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_241] = unsafe { *(result.output.as_ptr() as *const [G; OUT_241]) }; __ret } } else { aiur_fn_241(__args, record, io_buffer, __cu)? } }; let __v_16: G = __r_arr[0]; - let __ret: [G; OUT_256] = [__v_13, __v_16]; - if let Some(result) = record.function_queries[256].get_mut(&inp[..]) { debug_assert_eq!(result.output, &__ret[..]); if !unconstrained { *result.multiplicity += G::ONE; } } else { record.function_queries[256].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained)); }; + let __ret: [G; OUT_252] = [__v_13, __v_16]; + if let Some(result) = record.function_queries[252].get_mut(&inp[..]) { debug_assert_eq!(result.output, &__ret[..]); if !unconstrained { *result.multiplicity += G::ONE; } } else { record.function_queries[252].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained)); }; return Ok(__ret); }, _ => { @@ -24233,10 +23959,10 @@ fn aiur_fn_256( let __v_16: G = __r_arr[0]; let __r_arr: [G; OUT_118] = { let __args: [G; IN_118] = [__v_16]; let __cu = unconstrained; if let Some(result) = record.function_queries[118].get_mut(&__args[..]) { if !__cu && *result.multiplicity == G::ZERO { aiur_fn_118(__args, record, io_buffer, false)? } else { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_118] = unsafe { *(result.output.as_ptr() as *const [G; OUT_118]) }; __ret } } else { aiur_fn_118(__args, record, io_buffer, __cu)? } }; let __v_17: G = __r_arr[0]; - let __r_arr: [G; OUT_245] = { let __args: [G; IN_245] = [__v_17]; let __cu = unconstrained; if let Some(result) = record.function_queries[245].get_mut(&__args[..]) { if !__cu && *result.multiplicity == G::ZERO { aiur_fn_245(__args, record, io_buffer, false)? } else { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_245] = unsafe { *(result.output.as_ptr() as *const [G; OUT_245]) }; __ret } } else { aiur_fn_245(__args, record, io_buffer, __cu)? } }; + let __r_arr: [G; OUT_241] = { let __args: [G; IN_241] = [__v_17]; let __cu = unconstrained; if let Some(result) = record.function_queries[241].get_mut(&__args[..]) { if !__cu && *result.multiplicity == G::ZERO { aiur_fn_241(__args, record, io_buffer, false)? } else { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_241] = unsafe { *(result.output.as_ptr() as *const [G; OUT_241]) }; __ret } } else { aiur_fn_241(__args, record, io_buffer, __cu)? } }; let __v_18: G = __r_arr[0]; - let __ret: [G; OUT_256] = [__v_15, __v_18]; - if let Some(result) = record.function_queries[256].get_mut(&inp[..]) { debug_assert_eq!(result.output, &__ret[..]); if !unconstrained { *result.multiplicity += G::ONE; } } else { record.function_queries[256].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained)); }; + let __ret: [G; OUT_252] = [__v_15, __v_18]; + if let Some(result) = record.function_queries[252].get_mut(&inp[..]) { debug_assert_eq!(result.output, &__ret[..]); if !unconstrained { *result.multiplicity += G::ONE; } } else { record.function_queries[252].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained)); }; return Ok(__ret); }, _ => { @@ -24251,10 +23977,10 @@ fn aiur_fn_256( let __v_18: G = __r_arr[0]; let __r_arr: [G; OUT_118] = { let __args: [G; IN_118] = [__v_18]; let __cu = unconstrained; if let Some(result) = record.function_queries[118].get_mut(&__args[..]) { if !__cu && *result.multiplicity == G::ZERO { aiur_fn_118(__args, record, io_buffer, false)? } else { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_118] = unsafe { *(result.output.as_ptr() as *const [G; OUT_118]) }; __ret } } else { aiur_fn_118(__args, record, io_buffer, __cu)? } }; let __v_19: G = __r_arr[0]; - let __r_arr: [G; OUT_245] = { let __args: [G; IN_245] = [__v_19]; let __cu = unconstrained; if let Some(result) = record.function_queries[245].get_mut(&__args[..]) { if !__cu && *result.multiplicity == G::ZERO { aiur_fn_245(__args, record, io_buffer, false)? } else { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_245] = unsafe { *(result.output.as_ptr() as *const [G; OUT_245]) }; __ret } } else { aiur_fn_245(__args, record, io_buffer, __cu)? } }; + let __r_arr: [G; OUT_241] = { let __args: [G; IN_241] = [__v_19]; let __cu = unconstrained; if let Some(result) = record.function_queries[241].get_mut(&__args[..]) { if !__cu && *result.multiplicity == G::ZERO { aiur_fn_241(__args, record, io_buffer, false)? } else { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_241] = unsafe { *(result.output.as_ptr() as *const [G; OUT_241]) }; __ret } } else { aiur_fn_241(__args, record, io_buffer, __cu)? } }; let __v_20: G = __r_arr[0]; - let __ret: [G; OUT_256] = [__v_17, __v_20]; - if let Some(result) = record.function_queries[256].get_mut(&inp[..]) { debug_assert_eq!(result.output, &__ret[..]); if !unconstrained { *result.multiplicity += G::ONE; } } else { record.function_queries[256].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained)); }; + let __ret: [G; OUT_252] = [__v_17, __v_20]; + if let Some(result) = record.function_queries[252].get_mut(&inp[..]) { debug_assert_eq!(result.output, &__ret[..]); if !unconstrained { *result.multiplicity += G::ONE; } } else { record.function_queries[252].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained)); }; return Ok(__ret); }, _ => { @@ -24269,10 +23995,10 @@ fn aiur_fn_256( let __v_20: G = __r_arr[0]; let __r_arr: [G; OUT_118] = { let __args: [G; IN_118] = [__v_20]; let __cu = unconstrained; if let Some(result) = record.function_queries[118].get_mut(&__args[..]) { if !__cu && *result.multiplicity == G::ZERO { aiur_fn_118(__args, record, io_buffer, false)? } else { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_118] = unsafe { *(result.output.as_ptr() as *const [G; OUT_118]) }; __ret } } else { aiur_fn_118(__args, record, io_buffer, __cu)? } }; let __v_21: G = __r_arr[0]; - let __r_arr: [G; OUT_245] = { let __args: [G; IN_245] = [__v_21]; let __cu = unconstrained; if let Some(result) = record.function_queries[245].get_mut(&__args[..]) { if !__cu && *result.multiplicity == G::ZERO { aiur_fn_245(__args, record, io_buffer, false)? } else { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_245] = unsafe { *(result.output.as_ptr() as *const [G; OUT_245]) }; __ret } } else { aiur_fn_245(__args, record, io_buffer, __cu)? } }; + let __r_arr: [G; OUT_241] = { let __args: [G; IN_241] = [__v_21]; let __cu = unconstrained; if let Some(result) = record.function_queries[241].get_mut(&__args[..]) { if !__cu && *result.multiplicity == G::ZERO { aiur_fn_241(__args, record, io_buffer, false)? } else { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_241] = unsafe { *(result.output.as_ptr() as *const [G; OUT_241]) }; __ret } } else { aiur_fn_241(__args, record, io_buffer, __cu)? } }; let __v_22: G = __r_arr[0]; - let __ret: [G; OUT_256] = [__v_19, __v_22]; - if let Some(result) = record.function_queries[256].get_mut(&inp[..]) { debug_assert_eq!(result.output, &__ret[..]); if !unconstrained { *result.multiplicity += G::ONE; } } else { record.function_queries[256].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained)); }; + let __ret: [G; OUT_252] = [__v_19, __v_22]; + if let Some(result) = record.function_queries[252].get_mut(&inp[..]) { debug_assert_eq!(result.output, &__ret[..]); if !unconstrained { *result.multiplicity += G::ONE; } } else { record.function_queries[252].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained)); }; return Ok(__ret); }, _ => { @@ -24287,10 +24013,10 @@ fn aiur_fn_256( let __v_22: G = __r_arr[0]; let __r_arr: [G; OUT_118] = { let __args: [G; IN_118] = [__v_22]; let __cu = unconstrained; if let Some(result) = record.function_queries[118].get_mut(&__args[..]) { if !__cu && *result.multiplicity == G::ZERO { aiur_fn_118(__args, record, io_buffer, false)? } else { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_118] = unsafe { *(result.output.as_ptr() as *const [G; OUT_118]) }; __ret } } else { aiur_fn_118(__args, record, io_buffer, __cu)? } }; let __v_23: G = __r_arr[0]; - let __r_arr: [G; OUT_245] = { let __args: [G; IN_245] = [__v_23]; let __cu = unconstrained; if let Some(result) = record.function_queries[245].get_mut(&__args[..]) { if !__cu && *result.multiplicity == G::ZERO { aiur_fn_245(__args, record, io_buffer, false)? } else { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_245] = unsafe { *(result.output.as_ptr() as *const [G; OUT_245]) }; __ret } } else { aiur_fn_245(__args, record, io_buffer, __cu)? } }; + let __r_arr: [G; OUT_241] = { let __args: [G; IN_241] = [__v_23]; let __cu = unconstrained; if let Some(result) = record.function_queries[241].get_mut(&__args[..]) { if !__cu && *result.multiplicity == G::ZERO { aiur_fn_241(__args, record, io_buffer, false)? } else { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_241] = unsafe { *(result.output.as_ptr() as *const [G; OUT_241]) }; __ret } } else { aiur_fn_241(__args, record, io_buffer, __cu)? } }; let __v_24: G = __r_arr[0]; - let __ret: [G; OUT_256] = [__v_21, __v_24]; - if let Some(result) = record.function_queries[256].get_mut(&inp[..]) { debug_assert_eq!(result.output, &__ret[..]); if !unconstrained { *result.multiplicity += G::ONE; } } else { record.function_queries[256].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained)); }; + let __ret: [G; OUT_252] = [__v_21, __v_24]; + if let Some(result) = record.function_queries[252].get_mut(&inp[..]) { debug_assert_eq!(result.output, &__ret[..]); if !unconstrained { *result.multiplicity += G::ONE; } } else { record.function_queries[252].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained)); }; return Ok(__ret); }, _ => { @@ -24305,10 +24031,10 @@ fn aiur_fn_256( let __v_24: G = __r_arr[0]; let __r_arr: [G; OUT_118] = { let __args: [G; IN_118] = [__v_24]; let __cu = unconstrained; if let Some(result) = record.function_queries[118].get_mut(&__args[..]) { if !__cu && *result.multiplicity == G::ZERO { aiur_fn_118(__args, record, io_buffer, false)? } else { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_118] = unsafe { *(result.output.as_ptr() as *const [G; OUT_118]) }; __ret } } else { aiur_fn_118(__args, record, io_buffer, __cu)? } }; let __v_25: G = __r_arr[0]; - let __r_arr: [G; OUT_245] = { let __args: [G; IN_245] = [__v_25]; let __cu = unconstrained; if let Some(result) = record.function_queries[245].get_mut(&__args[..]) { if !__cu && *result.multiplicity == G::ZERO { aiur_fn_245(__args, record, io_buffer, false)? } else { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_245] = unsafe { *(result.output.as_ptr() as *const [G; OUT_245]) }; __ret } } else { aiur_fn_245(__args, record, io_buffer, __cu)? } }; + let __r_arr: [G; OUT_241] = { let __args: [G; IN_241] = [__v_25]; let __cu = unconstrained; if let Some(result) = record.function_queries[241].get_mut(&__args[..]) { if !__cu && *result.multiplicity == G::ZERO { aiur_fn_241(__args, record, io_buffer, false)? } else { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_241] = unsafe { *(result.output.as_ptr() as *const [G; OUT_241]) }; __ret } } else { aiur_fn_241(__args, record, io_buffer, __cu)? } }; let __v_26: G = __r_arr[0]; - let __ret: [G; OUT_256] = [__v_23, __v_26]; - if let Some(result) = record.function_queries[256].get_mut(&inp[..]) { debug_assert_eq!(result.output, &__ret[..]); if !unconstrained { *result.multiplicity += G::ONE; } } else { record.function_queries[256].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained)); }; + let __ret: [G; OUT_252] = [__v_23, __v_26]; + if let Some(result) = record.function_queries[252].get_mut(&inp[..]) { debug_assert_eq!(result.output, &__ret[..]); if !unconstrained { *result.multiplicity += G::ONE; } } else { record.function_queries[252].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained)); }; return Ok(__ret); }, _ => { @@ -24323,10 +24049,10 @@ fn aiur_fn_256( let __v_26: G = __r_arr[0]; let __r_arr: [G; OUT_118] = { let __args: [G; IN_118] = [__v_26]; let __cu = unconstrained; if let Some(result) = record.function_queries[118].get_mut(&__args[..]) { if !__cu && *result.multiplicity == G::ZERO { aiur_fn_118(__args, record, io_buffer, false)? } else { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_118] = unsafe { *(result.output.as_ptr() as *const [G; OUT_118]) }; __ret } } else { aiur_fn_118(__args, record, io_buffer, __cu)? } }; let __v_27: G = __r_arr[0]; - let __r_arr: [G; OUT_245] = { let __args: [G; IN_245] = [__v_27]; let __cu = unconstrained; if let Some(result) = record.function_queries[245].get_mut(&__args[..]) { if !__cu && *result.multiplicity == G::ZERO { aiur_fn_245(__args, record, io_buffer, false)? } else { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_245] = unsafe { *(result.output.as_ptr() as *const [G; OUT_245]) }; __ret } } else { aiur_fn_245(__args, record, io_buffer, __cu)? } }; + let __r_arr: [G; OUT_241] = { let __args: [G; IN_241] = [__v_27]; let __cu = unconstrained; if let Some(result) = record.function_queries[241].get_mut(&__args[..]) { if !__cu && *result.multiplicity == G::ZERO { aiur_fn_241(__args, record, io_buffer, false)? } else { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_241] = unsafe { *(result.output.as_ptr() as *const [G; OUT_241]) }; __ret } } else { aiur_fn_241(__args, record, io_buffer, __cu)? } }; let __v_28: G = __r_arr[0]; - let __ret: [G; OUT_256] = [__v_25, __v_28]; - if let Some(result) = record.function_queries[256].get_mut(&inp[..]) { debug_assert_eq!(result.output, &__ret[..]); if !unconstrained { *result.multiplicity += G::ONE; } } else { record.function_queries[256].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained)); }; + let __ret: [G; OUT_252] = [__v_25, __v_28]; + if let Some(result) = record.function_queries[252].get_mut(&inp[..]) { debug_assert_eq!(result.output, &__ret[..]); if !unconstrained { *result.multiplicity += G::ONE; } } else { record.function_queries[252].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained)); }; return Ok(__ret); }, _ => { @@ -24341,10 +24067,10 @@ fn aiur_fn_256( let __v_28: G = __r_arr[0]; let __r_arr: [G; OUT_118] = { let __args: [G; IN_118] = [__v_28]; let __cu = unconstrained; if let Some(result) = record.function_queries[118].get_mut(&__args[..]) { if !__cu && *result.multiplicity == G::ZERO { aiur_fn_118(__args, record, io_buffer, false)? } else { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_118] = unsafe { *(result.output.as_ptr() as *const [G; OUT_118]) }; __ret } } else { aiur_fn_118(__args, record, io_buffer, __cu)? } }; let __v_29: G = __r_arr[0]; - let __r_arr: [G; OUT_245] = { let __args: [G; IN_245] = [__v_29]; let __cu = unconstrained; if let Some(result) = record.function_queries[245].get_mut(&__args[..]) { if !__cu && *result.multiplicity == G::ZERO { aiur_fn_245(__args, record, io_buffer, false)? } else { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_245] = unsafe { *(result.output.as_ptr() as *const [G; OUT_245]) }; __ret } } else { aiur_fn_245(__args, record, io_buffer, __cu)? } }; + let __r_arr: [G; OUT_241] = { let __args: [G; IN_241] = [__v_29]; let __cu = unconstrained; if let Some(result) = record.function_queries[241].get_mut(&__args[..]) { if !__cu && *result.multiplicity == G::ZERO { aiur_fn_241(__args, record, io_buffer, false)? } else { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_241] = unsafe { *(result.output.as_ptr() as *const [G; OUT_241]) }; __ret } } else { aiur_fn_241(__args, record, io_buffer, __cu)? } }; let __v_30: G = __r_arr[0]; - let __ret: [G; OUT_256] = [__v_27, __v_30]; - if let Some(result) = record.function_queries[256].get_mut(&inp[..]) { debug_assert_eq!(result.output, &__ret[..]); if !unconstrained { *result.multiplicity += G::ONE; } } else { record.function_queries[256].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained)); }; + let __ret: [G; OUT_252] = [__v_27, __v_30]; + if let Some(result) = record.function_queries[252].get_mut(&inp[..]) { debug_assert_eq!(result.output, &__ret[..]); if !unconstrained { *result.multiplicity += G::ONE; } } else { record.function_queries[252].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained)); }; return Ok(__ret); }, _ => { @@ -24355,12 +24081,12 @@ fn aiur_fn_256( match __v_28.as_canonical_u64() { 1u64 => { let __v_29: G = G::from_u64(1); - let __r_arr: [G; OUT_338] = { let __args: [G; IN_338] = [__v_1, __v_2]; let __cu = unconstrained; if let Some(result) = record.function_queries[338].get_mut(&__args[..]) { if !__cu && *result.multiplicity == G::ZERO { aiur_fn_338(__args, record, io_buffer, false)? } else { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_338] = unsafe { *(result.output.as_ptr() as *const [G; OUT_338]) }; __ret } } else { aiur_fn_338(__args, record, io_buffer, __cu)? } }; + let __r_arr: [G; OUT_334] = { let __args: [G; IN_334] = [__v_1, __v_2]; let __cu = unconstrained; if let Some(result) = record.function_queries[334].get_mut(&__args[..]) { if !__cu && *result.multiplicity == G::ZERO { aiur_fn_334(__args, record, io_buffer, false)? } else { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_334] = unsafe { *(result.output.as_ptr() as *const [G; OUT_334]) }; __ret } } else { aiur_fn_334(__args, record, io_buffer, __cu)? } }; let __v_30: G = __r_arr[0]; - let __r_arr: [G; OUT_198] = { let __args: [G; IN_198] = [__v_30]; let __cu = unconstrained; if let Some(result) = record.function_queries[198].get_mut(&__args[..]) { if !__cu && *result.multiplicity == G::ZERO { aiur_fn_198(__args, record, io_buffer, false)? } else { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_198] = unsafe { *(result.output.as_ptr() as *const [G; OUT_198]) }; __ret } } else { aiur_fn_198(__args, record, io_buffer, __cu)? } }; + let __r_arr: [G; OUT_194] = { let __args: [G; IN_194] = [__v_30]; let __cu = unconstrained; if let Some(result) = record.function_queries[194].get_mut(&__args[..]) { if !__cu && *result.multiplicity == G::ZERO { aiur_fn_194(__args, record, io_buffer, false)? } else { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_194] = unsafe { *(result.output.as_ptr() as *const [G; OUT_194]) }; __ret } } else { aiur_fn_194(__args, record, io_buffer, __cu)? } }; let __v_31: G = __r_arr[0]; - let __ret: [G; OUT_256] = [__v_29, __v_31]; - if let Some(result) = record.function_queries[256].get_mut(&inp[..]) { debug_assert_eq!(result.output, &__ret[..]); if !unconstrained { *result.multiplicity += G::ONE; } } else { record.function_queries[256].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained)); }; + let __ret: [G; OUT_252] = [__v_29, __v_31]; + if let Some(result) = record.function_queries[252].get_mut(&inp[..]) { debug_assert_eq!(result.output, &__ret[..]); if !unconstrained { *result.multiplicity += G::ONE; } } else { record.function_queries[252].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained)); }; return Ok(__ret); }, _ => { @@ -24373,10 +24099,10 @@ fn aiur_fn_256( let __v_31: G = G::from_u64(1); let __r_arr: [G; OUT_120] = { let __args: [G; IN_120] = [__v_1, __v_2]; let __cu = unconstrained; if let Some(result) = record.function_queries[120].get_mut(&__args[..]) { if !__cu && *result.multiplicity == G::ZERO { aiur_fn_120(__args, record, io_buffer, false)? } else { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_120] = unsafe { *(result.output.as_ptr() as *const [G; OUT_120]) }; __ret } } else { aiur_fn_120(__args, record, io_buffer, __cu)? } }; let __v_32: G = __r_arr[0]; - let __r_arr: [G; OUT_198] = { let __args: [G; IN_198] = [__v_32]; let __cu = unconstrained; if let Some(result) = record.function_queries[198].get_mut(&__args[..]) { if !__cu && *result.multiplicity == G::ZERO { aiur_fn_198(__args, record, io_buffer, false)? } else { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_198] = unsafe { *(result.output.as_ptr() as *const [G; OUT_198]) }; __ret } } else { aiur_fn_198(__args, record, io_buffer, __cu)? } }; + let __r_arr: [G; OUT_194] = { let __args: [G; IN_194] = [__v_32]; let __cu = unconstrained; if let Some(result) = record.function_queries[194].get_mut(&__args[..]) { if !__cu && *result.multiplicity == G::ZERO { aiur_fn_194(__args, record, io_buffer, false)? } else { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_194] = unsafe { *(result.output.as_ptr() as *const [G; OUT_194]) }; __ret } } else { aiur_fn_194(__args, record, io_buffer, __cu)? } }; let __v_33: G = __r_arr[0]; - let __ret: [G; OUT_256] = [__v_31, __v_33]; - if let Some(result) = record.function_queries[256].get_mut(&inp[..]) { debug_assert_eq!(result.output, &__ret[..]); if !unconstrained { *result.multiplicity += G::ONE; } } else { record.function_queries[256].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained)); }; + let __ret: [G; OUT_252] = [__v_31, __v_33]; + if let Some(result) = record.function_queries[252].get_mut(&inp[..]) { debug_assert_eq!(result.output, &__ret[..]); if !unconstrained { *result.multiplicity += G::ONE; } } else { record.function_queries[252].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained)); }; return Ok(__ret); }, _ => { @@ -24385,8 +24111,8 @@ fn aiur_fn_256( let __v_33: G = G::from_u64(0); let __v_34: G = G::from_u64(0); let __v_35: G = { let __values: [G; 4] = [__v_32, __v_33, __v_34, __v_34]; let __mq = record.memory_queries.get_mut(&4).ok_or(ExecError::InvalidMemorySize(4))?; if let Some(result) = __mq.get_mut(&__values[..]) { if !unconstrained { *result.multiplicity += G::ONE; } result.output[0] } else { let __ptr = G::from_usize(__mq.len()); __mq.insert(&__values[..], &[__ptr], G::from_bool(!unconstrained)); __ptr } }; - let __ret: [G; OUT_256] = [__v_31, __v_35]; - if let Some(result) = record.function_queries[256].get_mut(&inp[..]) { debug_assert_eq!(result.output, &__ret[..]); if !unconstrained { *result.multiplicity += G::ONE; } } else { record.function_queries[256].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained)); }; + let __ret: [G; OUT_252] = [__v_31, __v_35]; + if let Some(result) = record.function_queries[252].get_mut(&inp[..]) { debug_assert_eq!(result.output, &__ret[..]); if !unconstrained { *result.multiplicity += G::ONE; } } else { record.function_queries[252].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained)); }; return Ok(__ret); }, } @@ -24419,15 +24145,15 @@ fn aiur_fn_256( }) } -const INPUT_SIZE_257: usize = 2; -const IN_257: usize = 2; -const OUT_257: usize = 3; -fn aiur_fn_257( - inp: [G; IN_257], +const INPUT_SIZE_253: usize = 2; +const IN_253: usize = 2; +const OUT_253: usize = 3; +fn aiur_fn_253( + inp: [G; IN_253], record: &mut QueryRecord, io_buffer: &mut IOBuffer, unconstrained: bool, -) -> Result<[G; OUT_257], ExecError> { +) -> Result<[G; OUT_253], ExecError> { stacker::maybe_grow(64 * 1024, 4 * 1024 * 1024, || { let __v_0: G = inp[0]; let __v_1: G = inp[1]; @@ -24448,22 +24174,22 @@ fn aiur_fn_257( let __v_9: G = G::from_u64(1); let __v_10: G = G::from_u64(1); let __v_11: G = { let __values: [G; 10] = [__v_9, __v_10, __v_10, __v_10, __v_10, __v_10, __v_10, __v_10, __v_10, __v_10]; let __mq = record.memory_queries.get_mut(&10).ok_or(ExecError::InvalidMemorySize(10))?; if let Some(result) = __mq.get_mut(&__values[..]) { if !unconstrained { *result.multiplicity += G::ONE; } result.output[0] } else { let __ptr = G::from_usize(__mq.len()); __mq.insert(&__values[..], &[__ptr], G::from_bool(!unconstrained)); __ptr } }; - let __ret: [G; OUT_257] = [__v_8, __v_0, __v_11]; - if let Some(result) = record.function_queries[257].get_mut(&inp[..]) { debug_assert_eq!(result.output, &__ret[..]); if !unconstrained { *result.multiplicity += G::ONE; } } else { record.function_queries[257].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained)); }; + let __ret: [G; OUT_253] = [__v_8, __v_0, __v_11]; + if let Some(result) = record.function_queries[253].get_mut(&inp[..]) { debug_assert_eq!(result.output, &__ret[..]); if !unconstrained { *result.multiplicity += G::ONE; } } else { record.function_queries[253].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained)); }; return Ok(__ret); }, _ => { - let __r_arr: [G; OUT_764] = { let __args: [G; IN_764] = [__v_1]; let __cu = unconstrained; if let Some(result) = record.function_queries[764].get_mut(&__args[..]) { if !__cu && *result.multiplicity == G::ZERO { aiur_fn_764(__args, record, io_buffer, false)? } else { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_764] = unsafe { *(result.output.as_ptr() as *const [G; OUT_764]) }; __ret } } else { aiur_fn_764(__args, record, io_buffer, __cu)? } }; + let __r_arr: [G; OUT_760] = { let __args: [G; IN_760] = [__v_1]; let __cu = unconstrained; if let Some(result) = record.function_queries[760].get_mut(&__args[..]) { if !__cu && *result.multiplicity == G::ZERO { aiur_fn_760(__args, record, io_buffer, false)? } else { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_760] = unsafe { *(result.output.as_ptr() as *const [G; OUT_760]) }; __ret } } else { aiur_fn_760(__args, record, io_buffer, __cu)? } }; let __v_8: G = __r_arr[0]; let __v_9: G = G::from_u64(2); let __v_10: G = (__v_8 - __v_9); match __v_10.as_canonical_u64() { 0u64 => { let __v_11: G = G::from_u64(0); - let __r_arr: [G; OUT_766] = { let __args: [G; IN_766] = [__v_1, __v_11]; let __cu = unconstrained; if let Some(result) = record.function_queries[766].get_mut(&__args[..]) { if !__cu && *result.multiplicity == G::ZERO { aiur_fn_766(__args, record, io_buffer, false)? } else { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_766] = unsafe { *(result.output.as_ptr() as *const [G; OUT_766]) }; __ret } } else { aiur_fn_766(__args, record, io_buffer, __cu)? } }; + let __r_arr: [G; OUT_762] = { let __args: [G; IN_762] = [__v_1, __v_11]; let __cu = unconstrained; if let Some(result) = record.function_queries[762].get_mut(&__args[..]) { if !__cu && *result.multiplicity == G::ZERO { aiur_fn_762(__args, record, io_buffer, false)? } else { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_762] = unsafe { *(result.output.as_ptr() as *const [G; OUT_762]) }; __ret } } else { aiur_fn_762(__args, record, io_buffer, __cu)? } }; let __v_12: G = __r_arr[0]; let __v_13: G = G::from_u64(1); - let __r_arr: [G; OUT_766] = { let __args: [G; IN_766] = [__v_1, __v_13]; let __cu = unconstrained; if let Some(result) = record.function_queries[766].get_mut(&__args[..]) { if !__cu && *result.multiplicity == G::ZERO { aiur_fn_766(__args, record, io_buffer, false)? } else { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_766] = unsafe { *(result.output.as_ptr() as *const [G; OUT_766]) }; __ret } } else { aiur_fn_766(__args, record, io_buffer, __cu)? } }; + let __r_arr: [G; OUT_762] = { let __args: [G; IN_762] = [__v_1, __v_13]; let __cu = unconstrained; if let Some(result) = record.function_queries[762].get_mut(&__args[..]) { if !__cu && *result.multiplicity == G::ZERO { aiur_fn_762(__args, record, io_buffer, false)? } else { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_762] = unsafe { *(result.output.as_ptr() as *const [G; OUT_762]) }; __ret } } else { aiur_fn_762(__args, record, io_buffer, __cu)? } }; let __v_14: G = __r_arr[0]; let __loaded: [G; 4] = { let __mq = record.memory_queries.get_mut(&4).ok_or(ExecError::InvalidMemorySize(4))?; let __ptr_u64 = __v_14.as_canonical_u64(); let __ptr_usize = usize::try_from(__ptr_u64).ok().ok_or(ExecError::PointerTooLarge(__ptr_u64))?; let (__args, __mult) = __mq.get_index_mut(__ptr_usize).ok_or(ExecError::UnboundPointer { ptr: __ptr_u64, size: 4 })?; if !unconstrained { *__mult += G::ONE; } let __arr: [G; 4] = __args[..4].try_into().unwrap(); __arr }; let __v_15: G = __loaded[0]; @@ -24475,8 +24201,8 @@ fn aiur_fn_257( match __v_16.as_canonical_u64() { 0u64 => { let __v_19: G = G::from_u64(1); - let __ret: [G; OUT_257] = [__v_19, __v_12, __v_17]; - if let Some(result) = record.function_queries[257].get_mut(&inp[..]) { debug_assert_eq!(result.output, &__ret[..]); if !unconstrained { *result.multiplicity += G::ONE; } } else { record.function_queries[257].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained)); }; + let __ret: [G; OUT_253] = [__v_19, __v_12, __v_17]; + if let Some(result) = record.function_queries[253].get_mut(&inp[..]) { debug_assert_eq!(result.output, &__ret[..]); if !unconstrained { *result.multiplicity += G::ONE; } } else { record.function_queries[253].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained)); }; return Ok(__ret); }, _ => { @@ -24484,8 +24210,8 @@ fn aiur_fn_257( let __v_20: G = G::from_u64(1); let __v_21: G = G::from_u64(1); let __v_22: G = { let __values: [G; 10] = [__v_20, __v_21, __v_21, __v_21, __v_21, __v_21, __v_21, __v_21, __v_21, __v_21]; let __mq = record.memory_queries.get_mut(&10).ok_or(ExecError::InvalidMemorySize(10))?; if let Some(result) = __mq.get_mut(&__values[..]) { if !unconstrained { *result.multiplicity += G::ONE; } result.output[0] } else { let __ptr = G::from_usize(__mq.len()); __mq.insert(&__values[..], &[__ptr], G::from_bool(!unconstrained)); __ptr } }; - let __ret: [G; OUT_257] = [__v_19, __v_0, __v_22]; - if let Some(result) = record.function_queries[257].get_mut(&inp[..]) { debug_assert_eq!(result.output, &__ret[..]); if !unconstrained { *result.multiplicity += G::ONE; } } else { record.function_queries[257].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained)); }; + let __ret: [G; OUT_253] = [__v_19, __v_0, __v_22]; + if let Some(result) = record.function_queries[253].get_mut(&inp[..]) { debug_assert_eq!(result.output, &__ret[..]); if !unconstrained { *result.multiplicity += G::ONE; } } else { record.function_queries[253].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained)); }; return Ok(__ret); }, } @@ -24495,8 +24221,8 @@ fn aiur_fn_257( let __v_20: G = G::from_u64(1); let __v_21: G = G::from_u64(1); let __v_22: G = { let __values: [G; 10] = [__v_20, __v_21, __v_21, __v_21, __v_21, __v_21, __v_21, __v_21, __v_21, __v_21]; let __mq = record.memory_queries.get_mut(&10).ok_or(ExecError::InvalidMemorySize(10))?; if let Some(result) = __mq.get_mut(&__values[..]) { if !unconstrained { *result.multiplicity += G::ONE; } result.output[0] } else { let __ptr = G::from_usize(__mq.len()); __mq.insert(&__values[..], &[__ptr], G::from_bool(!unconstrained)); __ptr } }; - let __ret: [G; OUT_257] = [__v_19, __v_0, __v_22]; - if let Some(result) = record.function_queries[257].get_mut(&inp[..]) { debug_assert_eq!(result.output, &__ret[..]); if !unconstrained { *result.multiplicity += G::ONE; } } else { record.function_queries[257].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained)); }; + let __ret: [G; OUT_253] = [__v_19, __v_0, __v_22]; + if let Some(result) = record.function_queries[253].get_mut(&inp[..]) { debug_assert_eq!(result.output, &__ret[..]); if !unconstrained { *result.multiplicity += G::ONE; } } else { record.function_queries[253].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained)); }; return Ok(__ret); }, } @@ -24506,8 +24232,8 @@ fn aiur_fn_257( let __v_12: G = G::from_u64(1); let __v_13: G = G::from_u64(1); let __v_14: G = { let __values: [G; 10] = [__v_12, __v_13, __v_13, __v_13, __v_13, __v_13, __v_13, __v_13, __v_13, __v_13]; let __mq = record.memory_queries.get_mut(&10).ok_or(ExecError::InvalidMemorySize(10))?; if let Some(result) = __mq.get_mut(&__values[..]) { if !unconstrained { *result.multiplicity += G::ONE; } result.output[0] } else { let __ptr = G::from_usize(__mq.len()); __mq.insert(&__values[..], &[__ptr], G::from_bool(!unconstrained)); __ptr } }; - let __ret: [G; OUT_257] = [__v_11, __v_0, __v_14]; - if let Some(result) = record.function_queries[257].get_mut(&inp[..]) { debug_assert_eq!(result.output, &__ret[..]); if !unconstrained { *result.multiplicity += G::ONE; } } else { record.function_queries[257].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained)); }; + let __ret: [G; OUT_253] = [__v_11, __v_0, __v_14]; + if let Some(result) = record.function_queries[253].get_mut(&inp[..]) { debug_assert_eq!(result.output, &__ret[..]); if !unconstrained { *result.multiplicity += G::ONE; } } else { record.function_queries[253].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained)); }; return Ok(__ret); }, } @@ -24519,23 +24245,23 @@ fn aiur_fn_257( let __v_7: G = G::from_u64(1); let __v_8: G = G::from_u64(1); let __v_9: G = { let __values: [G; 10] = [__v_7, __v_8, __v_8, __v_8, __v_8, __v_8, __v_8, __v_8, __v_8, __v_8]; let __mq = record.memory_queries.get_mut(&10).ok_or(ExecError::InvalidMemorySize(10))?; if let Some(result) = __mq.get_mut(&__values[..]) { if !unconstrained { *result.multiplicity += G::ONE; } result.output[0] } else { let __ptr = G::from_usize(__mq.len()); __mq.insert(&__values[..], &[__ptr], G::from_bool(!unconstrained)); __ptr } }; - let __ret: [G; OUT_257] = [__v_6, __v_0, __v_9]; - if let Some(result) = record.function_queries[257].get_mut(&inp[..]) { debug_assert_eq!(result.output, &__ret[..]); if !unconstrained { *result.multiplicity += G::ONE; } } else { record.function_queries[257].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained)); }; + let __ret: [G; OUT_253] = [__v_6, __v_0, __v_9]; + if let Some(result) = record.function_queries[253].get_mut(&inp[..]) { debug_assert_eq!(result.output, &__ret[..]); if !unconstrained { *result.multiplicity += G::ONE; } } else { record.function_queries[253].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained)); }; return Ok(__ret); }, } }) } -const INPUT_SIZE_258: usize = 2; -const IN_258: usize = 2; -const OUT_258: usize = 1; -fn aiur_fn_258( - inp: [G; IN_258], +const INPUT_SIZE_254: usize = 2; +const IN_254: usize = 2; +const OUT_254: usize = 1; +fn aiur_fn_254( + inp: [G; IN_254], record: &mut QueryRecord, io_buffer: &mut IOBuffer, unconstrained: bool, -) -> Result<[G; OUT_258], ExecError> { +) -> Result<[G; OUT_254], ExecError> { stacker::maybe_grow(64 * 1024, 4 * 1024 * 1024, || { let __v_0: G = inp[0]; let __v_1: G = inp[1]; @@ -24571,8 +24297,8 @@ fn aiur_fn_258( let __v_25: G = G::from_u64(3); let __v_26: G = G::from_u64(0); let __v_27: G = { let __values: [G; 4] = [__v_25, __v_23, __v_0, __v_26]; let __mq = record.memory_queries.get_mut(&4).ok_or(ExecError::InvalidMemorySize(4))?; if let Some(result) = __mq.get_mut(&__values[..]) { if !unconstrained { *result.multiplicity += G::ONE; } result.output[0] } else { let __ptr = G::from_usize(__mq.len()); __mq.insert(&__values[..], &[__ptr], G::from_bool(!unconstrained)); __ptr } }; - let __ret: [G; OUT_258] = [__v_27]; - if let Some(result) = record.function_queries[258].get_mut(&inp[..]) { debug_assert_eq!(result.output, &__ret[..]); if !unconstrained { *result.multiplicity += G::ONE; } } else { record.function_queries[258].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained)); }; + let __ret: [G; OUT_254] = [__v_27]; + if let Some(result) = record.function_queries[254].get_mut(&inp[..]) { debug_assert_eq!(result.output, &__ret[..]); if !unconstrained { *result.multiplicity += G::ONE; } } else { record.function_queries[254].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained)); }; return Ok(__ret); }, _ => { @@ -24597,23 +24323,23 @@ fn aiur_fn_258( let __v_42: G = G::from_u64(3); let __v_43: G = G::from_u64(0); let __v_44: G = { let __values: [G; 4] = [__v_42, __v_23, __v_41, __v_43]; let __mq = record.memory_queries.get_mut(&4).ok_or(ExecError::InvalidMemorySize(4))?; if let Some(result) = __mq.get_mut(&__values[..]) { if !unconstrained { *result.multiplicity += G::ONE; } result.output[0] } else { let __ptr = G::from_usize(__mq.len()); __mq.insert(&__values[..], &[__ptr], G::from_bool(!unconstrained)); __ptr } }; - let __ret: [G; OUT_258] = [__v_44]; - if let Some(result) = record.function_queries[258].get_mut(&inp[..]) { debug_assert_eq!(result.output, &__ret[..]); if !unconstrained { *result.multiplicity += G::ONE; } } else { record.function_queries[258].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained)); }; + let __ret: [G; OUT_254] = [__v_44]; + if let Some(result) = record.function_queries[254].get_mut(&inp[..]) { debug_assert_eq!(result.output, &__ret[..]); if !unconstrained { *result.multiplicity += G::ONE; } } else { record.function_queries[254].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained)); }; return Ok(__ret); }, } }) } -const INPUT_SIZE_259: usize = 1; -const IN_259: usize = 1; -const OUT_259: usize = 1; -fn aiur_fn_259( - inp: [G; IN_259], +const INPUT_SIZE_255: usize = 1; +const IN_255: usize = 1; +const OUT_255: usize = 1; +fn aiur_fn_255( + inp: [G; IN_255], record: &mut QueryRecord, io_buffer: &mut IOBuffer, unconstrained: bool, -) -> Result<[G; OUT_259], ExecError> { +) -> Result<[G; OUT_255], ExecError> { stacker::maybe_grow(64 * 1024, 4 * 1024 * 1024, || { let __v_0: G = inp[0]; let __loaded: [G; 4] = { let __mq = record.memory_queries.get_mut(&4).ok_or(ExecError::InvalidMemorySize(4))?; let __ptr_u64 = __v_0.as_canonical_u64(); let __ptr_usize = usize::try_from(__ptr_u64).ok().ok_or(ExecError::PointerTooLarge(__ptr_u64))?; let (__args, __mult) = __mq.get_index_mut(__ptr_usize).ok_or(ExecError::UnboundPointer { ptr: __ptr_u64, size: 4 })?; if !unconstrained { *__mult += G::ONE; } let __arr: [G; 4] = __args[..4].try_into().unwrap(); __arr }; @@ -24623,8 +24349,8 @@ fn aiur_fn_259( let __v_4: G = __loaded[3]; match __v_1.as_canonical_u64() { 7u64 => { - let __ret: [G; OUT_259] = [__v_0]; - if let Some(result) = record.function_queries[259].get_mut(&inp[..]) { debug_assert_eq!(result.output, &__ret[..]); if !unconstrained { *result.multiplicity += G::ONE; } } else { record.function_queries[259].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained)); }; + let __ret: [G; OUT_255] = [__v_0]; + if let Some(result) = record.function_queries[255].get_mut(&inp[..]) { debug_assert_eq!(result.output, &__ret[..]); if !unconstrained { *result.multiplicity += G::ONE; } } else { record.function_queries[255].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained)); }; return Ok(__ret); }, _ => { @@ -24638,7 +24364,7 @@ fn aiur_fn_259( let __v_10: G = __loaded[3]; match __v_7.as_canonical_u64() { 2u64 => { - let __r_arr: [G; OUT_257] = { let __args: [G; IN_257] = [__v_5, __v_6]; let __cu = unconstrained; if let Some(result) = record.function_queries[257].get_mut(&__args[..]) { if !__cu && *result.multiplicity == G::ZERO { aiur_fn_257(__args, record, io_buffer, false)? } else { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_257] = unsafe { *(result.output.as_ptr() as *const [G; OUT_257]) }; __ret } } else { aiur_fn_257(__args, record, io_buffer, __cu)? } }; + let __r_arr: [G; OUT_253] = { let __args: [G; IN_253] = [__v_5, __v_6]; let __cu = unconstrained; if let Some(result) = record.function_queries[253].get_mut(&__args[..]) { if !__cu && *result.multiplicity == G::ZERO { aiur_fn_253(__args, record, io_buffer, false)? } else { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_253] = unsafe { *(result.output.as_ptr() as *const [G; OUT_253]) }; __ret } } else { aiur_fn_253(__args, record, io_buffer, __cu)? } }; let __v_11: G = __r_arr[0]; let __v_12: G = __r_arr[1]; let __v_13: G = __r_arr[2]; @@ -24650,29 +24376,29 @@ fn aiur_fn_259( let __v_15: G = __r_arr[0]; match __v_15.as_canonical_u64() { 1u64 => { - let __ret: [G; OUT_259] = [__v_0]; - if let Some(result) = record.function_queries[259].get_mut(&inp[..]) { debug_assert_eq!(result.output, &__ret[..]); if !unconstrained { *result.multiplicity += G::ONE; } } else { record.function_queries[259].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained)); }; + let __ret: [G; OUT_255] = [__v_0]; + if let Some(result) = record.function_queries[255].get_mut(&inp[..]) { debug_assert_eq!(result.output, &__ret[..]); if !unconstrained { *result.multiplicity += G::ONE; } } else { record.function_queries[255].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained)); }; return Ok(__ret); }, _ => { - let __r_arr: [G; OUT_258] = { let __args: [G; IN_258] = [__v_12, __v_14]; let __cu = unconstrained; if let Some(result) = record.function_queries[258].get_mut(&__args[..]) { if !__cu && *result.multiplicity == G::ZERO { aiur_fn_258(__args, record, io_buffer, false)? } else { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_258] = unsafe { *(result.output.as_ptr() as *const [G; OUT_258]) }; __ret } } else { aiur_fn_258(__args, record, io_buffer, __cu)? } }; + let __r_arr: [G; OUT_254] = { let __args: [G; IN_254] = [__v_12, __v_14]; let __cu = unconstrained; if let Some(result) = record.function_queries[254].get_mut(&__args[..]) { if !__cu && *result.multiplicity == G::ZERO { aiur_fn_254(__args, record, io_buffer, false)? } else { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_254] = unsafe { *(result.output.as_ptr() as *const [G; OUT_254]) }; __ret } } else { aiur_fn_254(__args, record, io_buffer, __cu)? } }; let __v_16: G = __r_arr[0]; - let __ret: [G; OUT_259] = [__v_16]; - if let Some(result) = record.function_queries[259].get_mut(&inp[..]) { debug_assert_eq!(result.output, &__ret[..]); if !unconstrained { *result.multiplicity += G::ONE; } } else { record.function_queries[259].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained)); }; + let __ret: [G; OUT_255] = [__v_16]; + if let Some(result) = record.function_queries[255].get_mut(&inp[..]) { debug_assert_eq!(result.output, &__ret[..]); if !unconstrained { *result.multiplicity += G::ONE; } } else { record.function_queries[255].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained)); }; return Ok(__ret); }, } }, _ => { - let __ret: [G; OUT_259] = [__v_0]; - if let Some(result) = record.function_queries[259].get_mut(&inp[..]) { debug_assert_eq!(result.output, &__ret[..]); if !unconstrained { *result.multiplicity += G::ONE; } } else { record.function_queries[259].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained)); }; + let __ret: [G; OUT_255] = [__v_0]; + if let Some(result) = record.function_queries[255].get_mut(&inp[..]) { debug_assert_eq!(result.output, &__ret[..]); if !unconstrained { *result.multiplicity += G::ONE; } } else { record.function_queries[255].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained)); }; return Ok(__ret); }, } }, _ => { - let __ret: [G; OUT_259] = [__v_0]; - if let Some(result) = record.function_queries[259].get_mut(&inp[..]) { debug_assert_eq!(result.output, &__ret[..]); if !unconstrained { *result.multiplicity += G::ONE; } } else { record.function_queries[259].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained)); }; + let __ret: [G; OUT_255] = [__v_0]; + if let Some(result) = record.function_queries[255].get_mut(&inp[..]) { debug_assert_eq!(result.output, &__ret[..]); if !unconstrained { *result.multiplicity += G::ONE; } } else { record.function_queries[255].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained)); }; return Ok(__ret); }, } @@ -24681,15 +24407,15 @@ fn aiur_fn_259( }) } -const INPUT_SIZE_260: usize = 3; -const IN_260: usize = 3; -const OUT_260: usize = 2; -fn aiur_fn_260( - inp: [G; IN_260], +const INPUT_SIZE_256: usize = 3; +const IN_256: usize = 3; +const OUT_256: usize = 2; +fn aiur_fn_256( + inp: [G; IN_256], record: &mut QueryRecord, io_buffer: &mut IOBuffer, unconstrained: bool, -) -> Result<[G; OUT_260], ExecError> { +) -> Result<[G; OUT_256], ExecError> { stacker::maybe_grow(64 * 1024, 4 * 1024 * 1024, || { let __v_0: G = inp[0]; let __v_1: G = inp[1]; @@ -24699,10 +24425,10 @@ fn aiur_fn_260( match __v_3.as_canonical_u64() { 1u64 => { let __v_4: G = G::from_u64(1); - let __r_arr: [G; OUT_255] = { let __args: [G; IN_255] = [__v_0, __v_2]; let __cu = unconstrained; if let Some(result) = record.function_queries[255].get_mut(&__args[..]) { if !__cu && *result.multiplicity == G::ZERO { aiur_fn_255(__args, record, io_buffer, false)? } else { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_255] = unsafe { *(result.output.as_ptr() as *const [G; OUT_255]) }; __ret } } else { aiur_fn_255(__args, record, io_buffer, __cu)? } }; + let __r_arr: [G; OUT_251] = { let __args: [G; IN_251] = [__v_0, __v_2]; let __cu = unconstrained; if let Some(result) = record.function_queries[251].get_mut(&__args[..]) { if !__cu && *result.multiplicity == G::ZERO { aiur_fn_251(__args, record, io_buffer, false)? } else { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_251] = unsafe { *(result.output.as_ptr() as *const [G; OUT_251]) }; __ret } } else { aiur_fn_251(__args, record, io_buffer, __cu)? } }; let __v_5: G = __r_arr[0]; - let __ret: [G; OUT_260] = [__v_4, __v_5]; - if let Some(result) = record.function_queries[260].get_mut(&inp[..]) { debug_assert_eq!(result.output, &__ret[..]); if !unconstrained { *result.multiplicity += G::ONE; } } else { record.function_queries[260].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained)); }; + let __ret: [G; OUT_256] = [__v_4, __v_5]; + if let Some(result) = record.function_queries[256].get_mut(&inp[..]) { debug_assert_eq!(result.output, &__ret[..]); if !unconstrained { *result.multiplicity += G::ONE; } } else { record.function_queries[256].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained)); }; return Ok(__ret); }, _ => { @@ -24718,30 +24444,30 @@ fn aiur_fn_260( let __v_12: G = G::from_u64(3); let __v_13: G = G::from_u64(0); let __v_14: G = { let __values: [G; 4] = [__v_12, __v_10, __v_0, __v_13]; let __mq = record.memory_queries.get_mut(&4).ok_or(ExecError::InvalidMemorySize(4))?; if let Some(result) = __mq.get_mut(&__values[..]) { if !unconstrained { *result.multiplicity += G::ONE; } result.output[0] } else { let __ptr = G::from_usize(__mq.len()); __mq.insert(&__values[..], &[__ptr], G::from_bool(!unconstrained)); __ptr } }; - let __r_arr: [G; OUT_245] = { let __args: [G; IN_245] = [__v_1]; let __cu = unconstrained; if let Some(result) = record.function_queries[245].get_mut(&__args[..]) { if !__cu && *result.multiplicity == G::ZERO { aiur_fn_245(__args, record, io_buffer, false)? } else { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_245] = unsafe { *(result.output.as_ptr() as *const [G; OUT_245]) }; __ret } } else { aiur_fn_245(__args, record, io_buffer, __cu)? } }; + let __r_arr: [G; OUT_241] = { let __args: [G; IN_241] = [__v_1]; let __cu = unconstrained; if let Some(result) = record.function_queries[241].get_mut(&__args[..]) { if !__cu && *result.multiplicity == G::ZERO { aiur_fn_241(__args, record, io_buffer, false)? } else { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_241] = unsafe { *(result.output.as_ptr() as *const [G; OUT_241]) }; __ret } } else { aiur_fn_241(__args, record, io_buffer, __cu)? } }; let __v_15: G = __r_arr[0]; let __v_16: G = G::from_u64(0); let __v_17: G = { let __values: [G; 4] = [__v_11, __v_14, __v_15, __v_16]; let __mq = record.memory_queries.get_mut(&4).ok_or(ExecError::InvalidMemorySize(4))?; if let Some(result) = __mq.get_mut(&__values[..]) { if !unconstrained { *result.multiplicity += G::ONE; } result.output[0] } else { let __ptr = G::from_usize(__mq.len()); __mq.insert(&__values[..], &[__ptr], G::from_bool(!unconstrained)); __ptr } }; let __v_18: G = G::from_u64(1); - let __r_arr: [G; OUT_255] = { let __args: [G; IN_255] = [__v_17, __v_2]; let __cu = unconstrained; if let Some(result) = record.function_queries[255].get_mut(&__args[..]) { if !__cu && *result.multiplicity == G::ZERO { aiur_fn_255(__args, record, io_buffer, false)? } else { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_255] = unsafe { *(result.output.as_ptr() as *const [G; OUT_255]) }; __ret } } else { aiur_fn_255(__args, record, io_buffer, __cu)? } }; + let __r_arr: [G; OUT_251] = { let __args: [G; IN_251] = [__v_17, __v_2]; let __cu = unconstrained; if let Some(result) = record.function_queries[251].get_mut(&__args[..]) { if !__cu && *result.multiplicity == G::ZERO { aiur_fn_251(__args, record, io_buffer, false)? } else { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_251] = unsafe { *(result.output.as_ptr() as *const [G; OUT_251]) }; __ret } } else { aiur_fn_251(__args, record, io_buffer, __cu)? } }; let __v_19: G = __r_arr[0]; - let __ret: [G; OUT_260] = [__v_18, __v_19]; - if let Some(result) = record.function_queries[260].get_mut(&inp[..]) { debug_assert_eq!(result.output, &__ret[..]); if !unconstrained { *result.multiplicity += G::ONE; } } else { record.function_queries[260].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained)); }; + let __ret: [G; OUT_256] = [__v_18, __v_19]; + if let Some(result) = record.function_queries[256].get_mut(&inp[..]) { debug_assert_eq!(result.output, &__ret[..]); if !unconstrained { *result.multiplicity += G::ONE; } } else { record.function_queries[256].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained)); }; return Ok(__ret); }, } }) } -const INPUT_SIZE_261: usize = 1; -const IN_261: usize = 1; -const OUT_261: usize = 1; -fn aiur_fn_261( - inp: [G; IN_261], +const INPUT_SIZE_257: usize = 1; +const IN_257: usize = 1; +const OUT_257: usize = 1; +fn aiur_fn_257( + inp: [G; IN_257], record: &mut QueryRecord, io_buffer: &mut IOBuffer, unconstrained: bool, -) -> Result<[G; OUT_261], ExecError> { +) -> Result<[G; OUT_257], ExecError> { stacker::maybe_grow(64 * 1024, 4 * 1024 * 1024, || { let __v_0: G = inp[0]; let __loaded: [G; 4] = { let __mq = record.memory_queries.get_mut(&4).ok_or(ExecError::InvalidMemorySize(4))?; let __ptr_u64 = __v_0.as_canonical_u64(); let __ptr_usize = usize::try_from(__ptr_u64).ok().ok_or(ExecError::PointerTooLarge(__ptr_u64))?; let (__args, __mult) = __mq.get_index_mut(__ptr_usize).ok_or(ExecError::UnboundPointer { ptr: __ptr_u64, size: 4 })?; if !unconstrained { *__mult += G::ONE; } let __arr: [G; 4] = __args[..4].try_into().unwrap(); __arr }; @@ -24775,19 +24501,19 @@ fn aiur_fn_261( match __v_16.as_canonical_u64() { 0u64 => { let __v_17: G = G::from_u64(0); - let __ret: [G; OUT_261] = [__v_17]; - if let Some(result) = record.function_queries[261].get_mut(&inp[..]) { debug_assert_eq!(result.output, &__ret[..]); if !unconstrained { *result.multiplicity += G::ONE; } } else { record.function_queries[261].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained)); }; + let __ret: [G; OUT_257] = [__v_17]; + if let Some(result) = record.function_queries[257].get_mut(&inp[..]) { debug_assert_eq!(result.output, &__ret[..]); if !unconstrained { *result.multiplicity += G::ONE; } } else { record.function_queries[257].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained)); }; return Ok(__ret); }, _ => { - let __r_arr: [G; OUT_764] = { let __args: [G; IN_764] = [__v_10]; let __cu = unconstrained; if let Some(result) = record.function_queries[764].get_mut(&__args[..]) { if !__cu && *result.multiplicity == G::ZERO { aiur_fn_764(__args, record, io_buffer, false)? } else { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_764] = unsafe { *(result.output.as_ptr() as *const [G; OUT_764]) }; __ret } } else { aiur_fn_764(__args, record, io_buffer, __cu)? } }; + let __r_arr: [G; OUT_760] = { let __args: [G; IN_760] = [__v_10]; let __cu = unconstrained; if let Some(result) = record.function_queries[760].get_mut(&__args[..]) { if !__cu && *result.multiplicity == G::ZERO { aiur_fn_760(__args, record, io_buffer, false)? } else { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_760] = unsafe { *(result.output.as_ptr() as *const [G; OUT_760]) }; __ret } } else { aiur_fn_760(__args, record, io_buffer, __cu)? } }; let __v_17: G = __r_arr[0]; let __v_18: G = G::from_u64(1); let __v_19: G = (__v_17 - __v_18); match __v_19.as_canonical_u64() { 0u64 => { let __v_20: G = G::from_u64(0); - let __r_arr: [G; OUT_766] = { let __args: [G; IN_766] = [__v_10, __v_20]; let __cu = unconstrained; if let Some(result) = record.function_queries[766].get_mut(&__args[..]) { if !__cu && *result.multiplicity == G::ZERO { aiur_fn_766(__args, record, io_buffer, false)? } else { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_766] = unsafe { *(result.output.as_ptr() as *const [G; OUT_766]) }; __ret } } else { aiur_fn_766(__args, record, io_buffer, __cu)? } }; + let __r_arr: [G; OUT_762] = { let __args: [G; IN_762] = [__v_10, __v_20]; let __cu = unconstrained; if let Some(result) = record.function_queries[762].get_mut(&__args[..]) { if !__cu && *result.multiplicity == G::ZERO { aiur_fn_762(__args, record, io_buffer, false)? } else { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_762] = unsafe { *(result.output.as_ptr() as *const [G; OUT_762]) }; __ret } } else { aiur_fn_762(__args, record, io_buffer, __cu)? } }; let __v_21: G = __r_arr[0]; let __loaded: [G; 4] = { let __mq = record.memory_queries.get_mut(&4).ok_or(ExecError::InvalidMemorySize(4))?; let __ptr_u64 = __v_21.as_canonical_u64(); let __ptr_usize = usize::try_from(__ptr_u64).ok().ok_or(ExecError::PointerTooLarge(__ptr_u64))?; let (__args, __mult) = __mq.get_index_mut(__ptr_usize).ok_or(ExecError::UnboundPointer { ptr: __ptr_u64, size: 4 })?; if !unconstrained { *__mult += G::ONE; } let __arr: [G; 4] = __args[..4].try_into().unwrap(); __arr }; let __v_22: G = __loaded[0]; @@ -24797,22 +24523,22 @@ fn aiur_fn_261( match __v_22.as_canonical_u64() { 0u64 => { let __v_26: G = G::from_bool((__v_23 == G::ZERO)); - let __ret: [G; OUT_261] = [__v_26]; - if let Some(result) = record.function_queries[261].get_mut(&inp[..]) { debug_assert_eq!(result.output, &__ret[..]); if !unconstrained { *result.multiplicity += G::ONE; } } else { record.function_queries[261].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained)); }; + let __ret: [G; OUT_257] = [__v_26]; + if let Some(result) = record.function_queries[257].get_mut(&inp[..]) { debug_assert_eq!(result.output, &__ret[..]); if !unconstrained { *result.multiplicity += G::ONE; } } else { record.function_queries[257].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained)); }; return Ok(__ret); }, _ => { let __v_26: G = G::from_u64(0); - let __ret: [G; OUT_261] = [__v_26]; - if let Some(result) = record.function_queries[261].get_mut(&inp[..]) { debug_assert_eq!(result.output, &__ret[..]); if !unconstrained { *result.multiplicity += G::ONE; } } else { record.function_queries[261].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained)); }; + let __ret: [G; OUT_257] = [__v_26]; + if let Some(result) = record.function_queries[257].get_mut(&inp[..]) { debug_assert_eq!(result.output, &__ret[..]); if !unconstrained { *result.multiplicity += G::ONE; } } else { record.function_queries[257].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained)); }; return Ok(__ret); }, } }, _ => { let __v_20: G = G::from_u64(0); - let __ret: [G; OUT_261] = [__v_20]; - if let Some(result) = record.function_queries[261].get_mut(&inp[..]) { debug_assert_eq!(result.output, &__ret[..]); if !unconstrained { *result.multiplicity += G::ONE; } } else { record.function_queries[261].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained)); }; + let __ret: [G; OUT_257] = [__v_20]; + if let Some(result) = record.function_queries[257].get_mut(&inp[..]) { debug_assert_eq!(result.output, &__ret[..]); if !unconstrained { *result.multiplicity += G::ONE; } } else { record.function_queries[257].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained)); }; return Ok(__ret); }, } @@ -24821,39 +24547,39 @@ fn aiur_fn_261( }, _ => { let __v_15: G = G::from_u64(0); - let __ret: [G; OUT_261] = [__v_15]; - if let Some(result) = record.function_queries[261].get_mut(&inp[..]) { debug_assert_eq!(result.output, &__ret[..]); if !unconstrained { *result.multiplicity += G::ONE; } } else { record.function_queries[261].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained)); }; + let __ret: [G; OUT_257] = [__v_15]; + if let Some(result) = record.function_queries[257].get_mut(&inp[..]) { debug_assert_eq!(result.output, &__ret[..]); if !unconstrained { *result.multiplicity += G::ONE; } } else { record.function_queries[257].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained)); }; return Ok(__ret); }, } }, _ => { let __v_9: G = G::from_u64(0); - let __ret: [G; OUT_261] = [__v_9]; - if let Some(result) = record.function_queries[261].get_mut(&inp[..]) { debug_assert_eq!(result.output, &__ret[..]); if !unconstrained { *result.multiplicity += G::ONE; } } else { record.function_queries[261].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained)); }; + let __ret: [G; OUT_257] = [__v_9]; + if let Some(result) = record.function_queries[257].get_mut(&inp[..]) { debug_assert_eq!(result.output, &__ret[..]); if !unconstrained { *result.multiplicity += G::ONE; } } else { record.function_queries[257].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained)); }; return Ok(__ret); }, } }, _ => { let __v_5: G = G::from_u64(0); - let __ret: [G; OUT_261] = [__v_5]; - if let Some(result) = record.function_queries[261].get_mut(&inp[..]) { debug_assert_eq!(result.output, &__ret[..]); if !unconstrained { *result.multiplicity += G::ONE; } } else { record.function_queries[261].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained)); }; + let __ret: [G; OUT_257] = [__v_5]; + if let Some(result) = record.function_queries[257].get_mut(&inp[..]) { debug_assert_eq!(result.output, &__ret[..]); if !unconstrained { *result.multiplicity += G::ONE; } } else { record.function_queries[257].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained)); }; return Ok(__ret); }, } }) } -const INPUT_SIZE_262: usize = 5; -const IN_262: usize = 5; -const OUT_262: usize = 2; -fn aiur_fn_262( - inp: [G; IN_262], +const INPUT_SIZE_258: usize = 5; +const IN_258: usize = 5; +const OUT_258: usize = 2; +fn aiur_fn_258( + inp: [G; IN_258], record: &mut QueryRecord, io_buffer: &mut IOBuffer, unconstrained: bool, -) -> Result<[G; OUT_262], ExecError> { +) -> Result<[G; OUT_258], ExecError> { stacker::maybe_grow(64 * 1024, 4 * 1024 * 1024, || { let __v_0: G = inp[0]; let __v_1: G = inp[1]; @@ -24869,14 +24595,14 @@ fn aiur_fn_262( let __v_9: G = G::from_u64(0); let __v_10: G = G::from_u64(0); let __v_11: G = { let __values: [G; 4] = [__v_8, __v_9, __v_10, __v_10]; let __mq = record.memory_queries.get_mut(&4).ok_or(ExecError::InvalidMemorySize(4))?; if let Some(result) = __mq.get_mut(&__values[..]) { if !unconstrained { *result.multiplicity += G::ONE; } result.output[0] } else { let __ptr = G::from_usize(__mq.len()); __mq.insert(&__values[..], &[__ptr], G::from_bool(!unconstrained)); __ptr } }; - let __ret: [G; OUT_262] = [__v_7, __v_11]; - if let Some(result) = record.function_queries[262].get_mut(&inp[..]) { debug_assert_eq!(result.output, &__ret[..]); if !unconstrained { *result.multiplicity += G::ONE; } } else { record.function_queries[262].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained)); }; + let __ret: [G; OUT_258] = [__v_7, __v_11]; + if let Some(result) = record.function_queries[258].get_mut(&inp[..]) { debug_assert_eq!(result.output, &__ret[..]); if !unconstrained { *result.multiplicity += G::ONE; } } else { record.function_queries[258].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained)); }; return Ok(__ret); }, _ => { - let __r_arr: [G; OUT_766] = { let __args: [G; IN_766] = [__v_0, __v_4]; let __cu = unconstrained; if let Some(result) = record.function_queries[766].get_mut(&__args[..]) { if !__cu && *result.multiplicity == G::ZERO { aiur_fn_766(__args, record, io_buffer, false)? } else { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_766] = unsafe { *(result.output.as_ptr() as *const [G; OUT_766]) }; __ret } } else { aiur_fn_766(__args, record, io_buffer, __cu)? } }; + let __r_arr: [G; OUT_762] = { let __args: [G; IN_762] = [__v_0, __v_4]; let __cu = unconstrained; if let Some(result) = record.function_queries[762].get_mut(&__args[..]) { if !__cu && *result.multiplicity == G::ZERO { aiur_fn_762(__args, record, io_buffer, false)? } else { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_762] = unsafe { *(result.output.as_ptr() as *const [G; OUT_762]) }; __ret } } else { aiur_fn_762(__args, record, io_buffer, __cu)? } }; let __v_7: G = __r_arr[0]; - let __r_arr: [G; OUT_243] = { let __args: [G; IN_243] = [__v_7]; let __cu = unconstrained; if let Some(result) = record.function_queries[243].get_mut(&__args[..]) { if !__cu && *result.multiplicity == G::ZERO { aiur_fn_243(__args, record, io_buffer, false)? } else { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_243] = unsafe { *(result.output.as_ptr() as *const [G; OUT_243]) }; __ret } } else { aiur_fn_243(__args, record, io_buffer, __cu)? } }; + let __r_arr: [G; OUT_239] = { let __args: [G; IN_239] = [__v_7]; let __cu = unconstrained; if let Some(result) = record.function_queries[239].get_mut(&__args[..]) { if !__cu && *result.multiplicity == G::ZERO { aiur_fn_239(__args, record, io_buffer, false)? } else { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_239] = unsafe { *(result.output.as_ptr() as *const [G; OUT_239]) }; __ret } } else { aiur_fn_239(__args, record, io_buffer, __cu)? } }; let __v_8: G = __r_arr[0]; let __v_9: G = __r_arr[1]; match __v_8.as_canonical_u64() { @@ -24886,17 +24612,17 @@ fn aiur_fn_262( let __v_12: G = G::from_u64(0); let __v_13: G = G::from_u64(0); let __v_14: G = { let __values: [G; 4] = [__v_11, __v_12, __v_13, __v_13]; let __mq = record.memory_queries.get_mut(&4).ok_or(ExecError::InvalidMemorySize(4))?; if let Some(result) = __mq.get_mut(&__values[..]) { if !unconstrained { *result.multiplicity += G::ONE; } result.output[0] } else { let __ptr = G::from_usize(__mq.len()); __mq.insert(&__values[..], &[__ptr], G::from_bool(!unconstrained)); __ptr } }; - let __ret: [G; OUT_262] = [__v_10, __v_14]; - if let Some(result) = record.function_queries[262].get_mut(&inp[..]) { debug_assert_eq!(result.output, &__ret[..]); if !unconstrained { *result.multiplicity += G::ONE; } } else { record.function_queries[262].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained)); }; + let __ret: [G; OUT_258] = [__v_10, __v_14]; + if let Some(result) = record.function_queries[258].get_mut(&inp[..]) { debug_assert_eq!(result.output, &__ret[..]); if !unconstrained { *result.multiplicity += G::ONE; } } else { record.function_queries[258].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained)); }; return Ok(__ret); }, 1u64 => { let __v_10: G = (__v_1 + __v_2); let __v_11: G = G::from_u64(1); let __v_12: G = (__v_10 + __v_11); - let __r_arr: [G; OUT_766] = { let __args: [G; IN_766] = [__v_0, __v_12]; let __cu = unconstrained; if let Some(result) = record.function_queries[766].get_mut(&__args[..]) { if !__cu && *result.multiplicity == G::ZERO { aiur_fn_766(__args, record, io_buffer, false)? } else { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_766] = unsafe { *(result.output.as_ptr() as *const [G; OUT_766]) }; __ret } } else { aiur_fn_766(__args, record, io_buffer, __cu)? } }; + let __r_arr: [G; OUT_762] = { let __args: [G; IN_762] = [__v_0, __v_12]; let __cu = unconstrained; if let Some(result) = record.function_queries[762].get_mut(&__args[..]) { if !__cu && *result.multiplicity == G::ZERO { aiur_fn_762(__args, record, io_buffer, false)? } else { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_762] = unsafe { *(result.output.as_ptr() as *const [G; OUT_762]) }; __ret } } else { aiur_fn_762(__args, record, io_buffer, __cu)? } }; let __v_13: G = __r_arr[0]; - let __r_arr: [G; OUT_261] = { let __args: [G; IN_261] = [__v_13]; let __cu = unconstrained; if let Some(result) = record.function_queries[261].get_mut(&__args[..]) { if !__cu && *result.multiplicity == G::ZERO { aiur_fn_261(__args, record, io_buffer, false)? } else { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_261] = unsafe { *(result.output.as_ptr() as *const [G; OUT_261]) }; __ret } } else { aiur_fn_261(__args, record, io_buffer, __cu)? } }; + let __r_arr: [G; OUT_257] = { let __args: [G; IN_257] = [__v_13]; let __cu = unconstrained; if let Some(result) = record.function_queries[257].get_mut(&__args[..]) { if !__cu && *result.multiplicity == G::ZERO { aiur_fn_257(__args, record, io_buffer, false)? } else { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_257] = unsafe { *(result.output.as_ptr() as *const [G; OUT_257]) }; __ret } } else { aiur_fn_257(__args, record, io_buffer, __cu)? } }; let __v_14: G = __r_arr[0]; match __v_14.as_canonical_u64() { 0u64 => { @@ -24905,18 +24631,18 @@ fn aiur_fn_262( let __v_17: G = G::from_u64(0); let __v_18: G = G::from_u64(0); let __v_19: G = { let __values: [G; 4] = [__v_16, __v_17, __v_18, __v_18]; let __mq = record.memory_queries.get_mut(&4).ok_or(ExecError::InvalidMemorySize(4))?; if let Some(result) = __mq.get_mut(&__values[..]) { if !unconstrained { *result.multiplicity += G::ONE; } result.output[0] } else { let __ptr = G::from_usize(__mq.len()); __mq.insert(&__values[..], &[__ptr], G::from_bool(!unconstrained)); __ptr } }; - let __ret: [G; OUT_262] = [__v_15, __v_19]; - if let Some(result) = record.function_queries[262].get_mut(&inp[..]) { debug_assert_eq!(result.output, &__ret[..]); if !unconstrained { *result.multiplicity += G::ONE; } } else { record.function_queries[262].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained)); }; + let __ret: [G; OUT_258] = [__v_15, __v_19]; + if let Some(result) = record.function_queries[258].get_mut(&inp[..]) { debug_assert_eq!(result.output, &__ret[..]); if !unconstrained { *result.multiplicity += G::ONE; } } else { record.function_queries[258].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained)); }; return Ok(__ret); }, _ => { - let __r_arr: [G; OUT_766] = { let __args: [G; IN_766] = [__v_0, __v_10]; let __cu = unconstrained; if let Some(result) = record.function_queries[766].get_mut(&__args[..]) { if !__cu && *result.multiplicity == G::ZERO { aiur_fn_766(__args, record, io_buffer, false)? } else { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_766] = unsafe { *(result.output.as_ptr() as *const [G; OUT_766]) }; __ret } } else { aiur_fn_766(__args, record, io_buffer, __cu)? } }; + let __r_arr: [G; OUT_762] = { let __args: [G; IN_762] = [__v_0, __v_10]; let __cu = unconstrained; if let Some(result) = record.function_queries[762].get_mut(&__args[..]) { if !__cu && *result.multiplicity == G::ZERO { aiur_fn_762(__args, record, io_buffer, false)? } else { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_762] = unsafe { *(result.output.as_ptr() as *const [G; OUT_762]) }; __ret } } else { aiur_fn_762(__args, record, io_buffer, __cu)? } }; let __v_15: G = __r_arr[0]; let __v_16: G = G::from_u64(1); let __v_17: G = (__v_4 + __v_16); - let __r_arr: [G; OUT_775] = { let __args: [G; IN_775] = [__v_0, __v_17]; let __cu = unconstrained; if let Some(result) = record.function_queries[775].get_mut(&__args[..]) { if !__cu && *result.multiplicity == G::ZERO { aiur_fn_775(__args, record, io_buffer, false)? } else { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_775] = unsafe { *(result.output.as_ptr() as *const [G; OUT_775]) }; __ret } } else { aiur_fn_775(__args, record, io_buffer, __cu)? } }; + let __r_arr: [G; OUT_771] = { let __args: [G; IN_771] = [__v_0, __v_17]; let __cu = unconstrained; if let Some(result) = record.function_queries[771].get_mut(&__args[..]) { if !__cu && *result.multiplicity == G::ZERO { aiur_fn_771(__args, record, io_buffer, false)? } else { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_771] = unsafe { *(result.output.as_ptr() as *const [G; OUT_771]) }; __ret } } else { aiur_fn_771(__args, record, io_buffer, __cu)? } }; let __v_18: G = __r_arr[0]; - let __r_arr: [G; OUT_243] = { let __args: [G; IN_243] = [__v_15]; let __cu = unconstrained; if let Some(result) = record.function_queries[243].get_mut(&__args[..]) { if !__cu && *result.multiplicity == G::ZERO { aiur_fn_243(__args, record, io_buffer, false)? } else { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_243] = unsafe { *(result.output.as_ptr() as *const [G; OUT_243]) }; __ret } } else { aiur_fn_243(__args, record, io_buffer, __cu)? } }; + let __r_arr: [G; OUT_239] = { let __args: [G; IN_239] = [__v_15]; let __cu = unconstrained; if let Some(result) = record.function_queries[239].get_mut(&__args[..]) { if !__cu && *result.multiplicity == G::ZERO { aiur_fn_239(__args, record, io_buffer, false)? } else { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_239] = unsafe { *(result.output.as_ptr() as *const [G; OUT_239]) }; __ret } } else { aiur_fn_239(__args, record, io_buffer, __cu)? } }; let __v_19: G = __r_arr[0]; let __v_20: G = __r_arr[1]; match __v_19.as_canonical_u64() { @@ -24924,20 +24650,20 @@ fn aiur_fn_262( let __v_21: G = G::from_u64(1); let __r_arr: [G; OUT_114] = { let __args: [G; IN_114] = [__v_20, __v_9]; let __cu = unconstrained; if let Some(result) = record.function_queries[114].get_mut(&__args[..]) { if !__cu && *result.multiplicity == G::ZERO { aiur_fn_114(__args, record, io_buffer, false)? } else { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_114] = unsafe { *(result.output.as_ptr() as *const [G; OUT_114]) }; __ret } } else { aiur_fn_114(__args, record, io_buffer, __cu)? } }; let __v_22: G = __r_arr[0]; - let __r_arr: [G; OUT_245] = { let __args: [G; IN_245] = [__v_22]; let __cu = unconstrained; if let Some(result) = record.function_queries[245].get_mut(&__args[..]) { if !__cu && *result.multiplicity == G::ZERO { aiur_fn_245(__args, record, io_buffer, false)? } else { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_245] = unsafe { *(result.output.as_ptr() as *const [G; OUT_245]) }; __ret } } else { aiur_fn_245(__args, record, io_buffer, __cu)? } }; + let __r_arr: [G; OUT_241] = { let __args: [G; IN_241] = [__v_22]; let __cu = unconstrained; if let Some(result) = record.function_queries[241].get_mut(&__args[..]) { if !__cu && *result.multiplicity == G::ZERO { aiur_fn_241(__args, record, io_buffer, false)? } else { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_241] = unsafe { *(result.output.as_ptr() as *const [G; OUT_241]) }; __ret } } else { aiur_fn_241(__args, record, io_buffer, __cu)? } }; let __v_23: G = __r_arr[0]; - let __r_arr: [G; OUT_255] = { let __args: [G; IN_255] = [__v_23, __v_18]; let __cu = unconstrained; if let Some(result) = record.function_queries[255].get_mut(&__args[..]) { if !__cu && *result.multiplicity == G::ZERO { aiur_fn_255(__args, record, io_buffer, false)? } else { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_255] = unsafe { *(result.output.as_ptr() as *const [G; OUT_255]) }; __ret } } else { aiur_fn_255(__args, record, io_buffer, __cu)? } }; + let __r_arr: [G; OUT_251] = { let __args: [G; IN_251] = [__v_23, __v_18]; let __cu = unconstrained; if let Some(result) = record.function_queries[251].get_mut(&__args[..]) { if !__cu && *result.multiplicity == G::ZERO { aiur_fn_251(__args, record, io_buffer, false)? } else { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_251] = unsafe { *(result.output.as_ptr() as *const [G; OUT_251]) }; __ret } } else { aiur_fn_251(__args, record, io_buffer, __cu)? } }; let __v_24: G = __r_arr[0]; - let __ret: [G; OUT_262] = [__v_21, __v_24]; - if let Some(result) = record.function_queries[262].get_mut(&inp[..]) { debug_assert_eq!(result.output, &__ret[..]); if !unconstrained { *result.multiplicity += G::ONE; } } else { record.function_queries[262].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained)); }; + let __ret: [G; OUT_258] = [__v_21, __v_24]; + if let Some(result) = record.function_queries[258].get_mut(&inp[..]) { debug_assert_eq!(result.output, &__ret[..]); if !unconstrained { *result.multiplicity += G::ONE; } } else { record.function_queries[258].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained)); }; return Ok(__ret); }, _ => { - let __r_arr: [G; OUT_260] = { let __args: [G; IN_260] = [__v_15, __v_9, __v_18]; let __cu = unconstrained; if let Some(result) = record.function_queries[260].get_mut(&__args[..]) { if !__cu && *result.multiplicity == G::ZERO { aiur_fn_260(__args, record, io_buffer, false)? } else { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_260] = unsafe { *(result.output.as_ptr() as *const [G; OUT_260]) }; __ret } } else { aiur_fn_260(__args, record, io_buffer, __cu)? } }; + let __r_arr: [G; OUT_256] = { let __args: [G; IN_256] = [__v_15, __v_9, __v_18]; let __cu = unconstrained; if let Some(result) = record.function_queries[256].get_mut(&__args[..]) { if !__cu && *result.multiplicity == G::ZERO { aiur_fn_256(__args, record, io_buffer, false)? } else { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_256] = unsafe { *(result.output.as_ptr() as *const [G; OUT_256]) }; __ret } } else { aiur_fn_256(__args, record, io_buffer, __cu)? } }; let __v_21: G = __r_arr[0]; let __v_22: G = __r_arr[1]; - let __ret: [G; OUT_262] = [__v_21, __v_22]; - if let Some(result) = record.function_queries[262].get_mut(&inp[..]) { debug_assert_eq!(result.output, &__ret[..]); if !unconstrained { *result.multiplicity += G::ONE; } } else { record.function_queries[262].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained)); }; + let __ret: [G; OUT_258] = [__v_21, __v_22]; + if let Some(result) = record.function_queries[258].get_mut(&inp[..]) { debug_assert_eq!(result.output, &__ret[..]); if !unconstrained { *result.multiplicity += G::ONE; } } else { record.function_queries[258].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained)); }; return Ok(__ret); }, } @@ -24953,20 +24679,20 @@ fn aiur_fn_262( }) } -const INPUT_SIZE_263: usize = 3; -const IN_263: usize = 3; -const OUT_263: usize = 2; -fn aiur_fn_263( - inp: [G; IN_263], +const INPUT_SIZE_259: usize = 3; +const IN_259: usize = 3; +const OUT_259: usize = 2; +fn aiur_fn_259( + inp: [G; IN_259], record: &mut QueryRecord, io_buffer: &mut IOBuffer, unconstrained: bool, -) -> Result<[G; OUT_263], ExecError> { +) -> Result<[G; OUT_259], ExecError> { stacker::maybe_grow(64 * 1024, 4 * 1024 * 1024, || { let __v_0: G = inp[0]; let __v_1: G = inp[1]; let __v_2: G = inp[2]; - let __r_arr: [G; OUT_764] = { let __args: [G; IN_764] = [__v_1]; let __cu = unconstrained; if let Some(result) = record.function_queries[764].get_mut(&__args[..]) { if !__cu && *result.multiplicity == G::ZERO { aiur_fn_764(__args, record, io_buffer, false)? } else { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_764] = unsafe { *(result.output.as_ptr() as *const [G; OUT_764]) }; __ret } } else { aiur_fn_764(__args, record, io_buffer, __cu)? } }; + let __r_arr: [G; OUT_760] = { let __args: [G; IN_760] = [__v_1]; let __cu = unconstrained; if let Some(result) = record.function_queries[760].get_mut(&__args[..]) { if !__cu && *result.multiplicity == G::ZERO { aiur_fn_760(__args, record, io_buffer, false)? } else { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_760] = unsafe { *(result.output.as_ptr() as *const [G; OUT_760]) }; __ret } } else { aiur_fn_760(__args, record, io_buffer, __cu)? } }; let __v_3: G = __r_arr[0]; let __r_arr: [G; OUT_145] = { let __args: [G; IN_145] = []; let __cu = unconstrained; if let Some(result) = record.function_queries[145].get_mut(&__args[..]) { if !__cu && *result.multiplicity == G::ZERO { aiur_fn_145(__args, record, io_buffer, false)? } else { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_145] = unsafe { *(result.output.as_ptr() as *const [G; OUT_145]) }; __ret } } else { aiur_fn_145(__args, record, io_buffer, __cu)? } }; let __v_4: G = __r_arr[0]; @@ -24987,31 +24713,31 @@ fn aiur_fn_263( let __v_12: G = G::from_u64(0); let __v_13: G = G::from_u64(0); let __v_14: G = { let __values: [G; 4] = [__v_11, __v_12, __v_13, __v_13]; let __mq = record.memory_queries.get_mut(&4).ok_or(ExecError::InvalidMemorySize(4))?; if let Some(result) = __mq.get_mut(&__values[..]) { if !unconstrained { *result.multiplicity += G::ONE; } result.output[0] } else { let __ptr = G::from_usize(__mq.len()); __mq.insert(&__values[..], &[__ptr], G::from_bool(!unconstrained)); __ptr } }; - let __ret: [G; OUT_263] = [__v_10, __v_14]; - if let Some(result) = record.function_queries[263].get_mut(&inp[..]) { debug_assert_eq!(result.output, &__ret[..]); if !unconstrained { *result.multiplicity += G::ONE; } } else { record.function_queries[263].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained)); }; + let __ret: [G; OUT_259] = [__v_10, __v_14]; + if let Some(result) = record.function_queries[259].get_mut(&inp[..]) { debug_assert_eq!(result.output, &__ret[..]); if !unconstrained { *result.multiplicity += G::ONE; } } else { record.function_queries[259].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained)); }; return Ok(__ret); }, _ => { let __v_10: G = G::from_u64(0); - let __r_arr: [G; OUT_766] = { let __args: [G; IN_766] = [__v_1, __v_10]; let __cu = unconstrained; if let Some(result) = record.function_queries[766].get_mut(&__args[..]) { if !__cu && *result.multiplicity == G::ZERO { aiur_fn_766(__args, record, io_buffer, false)? } else { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_766] = unsafe { *(result.output.as_ptr() as *const [G; OUT_766]) }; __ret } } else { aiur_fn_766(__args, record, io_buffer, __cu)? } }; + let __r_arr: [G; OUT_762] = { let __args: [G; IN_762] = [__v_1, __v_10]; let __cu = unconstrained; if let Some(result) = record.function_queries[762].get_mut(&__args[..]) { if !__cu && *result.multiplicity == G::ZERO { aiur_fn_762(__args, record, io_buffer, false)? } else { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_762] = unsafe { *(result.output.as_ptr() as *const [G; OUT_762]) }; __ret } } else { aiur_fn_762(__args, record, io_buffer, __cu)? } }; let __v_11: G = __r_arr[0]; - let __r_arr: [G; OUT_243] = { let __args: [G; IN_243] = [__v_11]; let __cu = unconstrained; if let Some(result) = record.function_queries[243].get_mut(&__args[..]) { if !__cu && *result.multiplicity == G::ZERO { aiur_fn_243(__args, record, io_buffer, false)? } else { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_243] = unsafe { *(result.output.as_ptr() as *const [G; OUT_243]) }; __ret } } else { aiur_fn_243(__args, record, io_buffer, __cu)? } }; + let __r_arr: [G; OUT_239] = { let __args: [G; IN_239] = [__v_11]; let __cu = unconstrained; if let Some(result) = record.function_queries[239].get_mut(&__args[..]) { if !__cu && *result.multiplicity == G::ZERO { aiur_fn_239(__args, record, io_buffer, false)? } else { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_239] = unsafe { *(result.output.as_ptr() as *const [G; OUT_239]) }; __ret } } else { aiur_fn_239(__args, record, io_buffer, __cu)? } }; let __v_12: G = __r_arr[0]; let __v_13: G = __r_arr[1]; match __v_12.as_canonical_u64() { 1u64 => { let __v_14: G = G::from_u64(1); - let __r_arr: [G; OUT_775] = { let __args: [G; IN_775] = [__v_1, __v_14]; let __cu = unconstrained; if let Some(result) = record.function_queries[775].get_mut(&__args[..]) { if !__cu && *result.multiplicity == G::ZERO { aiur_fn_775(__args, record, io_buffer, false)? } else { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_775] = unsafe { *(result.output.as_ptr() as *const [G; OUT_775]) }; __ret } } else { aiur_fn_775(__args, record, io_buffer, __cu)? } }; + let __r_arr: [G; OUT_771] = { let __args: [G; IN_771] = [__v_1, __v_14]; let __cu = unconstrained; if let Some(result) = record.function_queries[771].get_mut(&__args[..]) { if !__cu && *result.multiplicity == G::ZERO { aiur_fn_771(__args, record, io_buffer, false)? } else { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_771] = unsafe { *(result.output.as_ptr() as *const [G; OUT_771]) }; __ret } } else { aiur_fn_771(__args, record, io_buffer, __cu)? } }; let __v_15: G = __r_arr[0]; let __v_16: G = G::from_u64(1); let __r_arr: [G; OUT_112] = { let __args: [G; IN_112] = [__v_13]; let __cu = unconstrained; if let Some(result) = record.function_queries[112].get_mut(&__args[..]) { if !__cu && *result.multiplicity == G::ZERO { aiur_fn_112(__args, record, io_buffer, false)? } else { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_112] = unsafe { *(result.output.as_ptr() as *const [G; OUT_112]) }; __ret } } else { aiur_fn_112(__args, record, io_buffer, __cu)? } }; let __v_17: G = __r_arr[0]; - let __r_arr: [G; OUT_245] = { let __args: [G; IN_245] = [__v_17]; let __cu = unconstrained; if let Some(result) = record.function_queries[245].get_mut(&__args[..]) { if !__cu && *result.multiplicity == G::ZERO { aiur_fn_245(__args, record, io_buffer, false)? } else { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_245] = unsafe { *(result.output.as_ptr() as *const [G; OUT_245]) }; __ret } } else { aiur_fn_245(__args, record, io_buffer, __cu)? } }; + let __r_arr: [G; OUT_241] = { let __args: [G; IN_241] = [__v_17]; let __cu = unconstrained; if let Some(result) = record.function_queries[241].get_mut(&__args[..]) { if !__cu && *result.multiplicity == G::ZERO { aiur_fn_241(__args, record, io_buffer, false)? } else { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_241] = unsafe { *(result.output.as_ptr() as *const [G; OUT_241]) }; __ret } } else { aiur_fn_241(__args, record, io_buffer, __cu)? } }; let __v_18: G = __r_arr[0]; - let __r_arr: [G; OUT_255] = { let __args: [G; IN_255] = [__v_18, __v_15]; let __cu = unconstrained; if let Some(result) = record.function_queries[255].get_mut(&__args[..]) { if !__cu && *result.multiplicity == G::ZERO { aiur_fn_255(__args, record, io_buffer, false)? } else { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_255] = unsafe { *(result.output.as_ptr() as *const [G; OUT_255]) }; __ret } } else { aiur_fn_255(__args, record, io_buffer, __cu)? } }; + let __r_arr: [G; OUT_251] = { let __args: [G; IN_251] = [__v_18, __v_15]; let __cu = unconstrained; if let Some(result) = record.function_queries[251].get_mut(&__args[..]) { if !__cu && *result.multiplicity == G::ZERO { aiur_fn_251(__args, record, io_buffer, false)? } else { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_251] = unsafe { *(result.output.as_ptr() as *const [G; OUT_251]) }; __ret } } else { aiur_fn_251(__args, record, io_buffer, __cu)? } }; let __v_19: G = __r_arr[0]; - let __ret: [G; OUT_263] = [__v_16, __v_19]; - if let Some(result) = record.function_queries[263].get_mut(&inp[..]) { debug_assert_eq!(result.output, &__ret[..]); if !unconstrained { *result.multiplicity += G::ONE; } } else { record.function_queries[263].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained)); }; + let __ret: [G; OUT_259] = [__v_16, __v_19]; + if let Some(result) = record.function_queries[259].get_mut(&inp[..]) { debug_assert_eq!(result.output, &__ret[..]); if !unconstrained { *result.multiplicity += G::ONE; } } else { record.function_queries[259].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained)); }; return Ok(__ret); }, _ => { @@ -25020,8 +24746,8 @@ fn aiur_fn_263( let __v_16: G = G::from_u64(0); let __v_17: G = G::from_u64(0); let __v_18: G = { let __values: [G; 4] = [__v_15, __v_16, __v_17, __v_17]; let __mq = record.memory_queries.get_mut(&4).ok_or(ExecError::InvalidMemorySize(4))?; if let Some(result) = __mq.get_mut(&__values[..]) { if !unconstrained { *result.multiplicity += G::ONE; } result.output[0] } else { let __ptr = G::from_usize(__mq.len()); __mq.insert(&__values[..], &[__ptr], G::from_bool(!unconstrained)); __ptr } }; - let __ret: [G; OUT_263] = [__v_14, __v_18]; - if let Some(result) = record.function_queries[263].get_mut(&inp[..]) { debug_assert_eq!(result.output, &__ret[..]); if !unconstrained { *result.multiplicity += G::ONE; } } else { record.function_queries[263].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained)); }; + let __ret: [G; OUT_259] = [__v_14, __v_18]; + if let Some(result) = record.function_queries[259].get_mut(&inp[..]) { debug_assert_eq!(result.output, &__ret[..]); if !unconstrained { *result.multiplicity += G::ONE; } } else { record.function_queries[259].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained)); }; return Ok(__ret); }, } @@ -25040,33 +24766,33 @@ fn aiur_fn_263( let __v_12: G = G::from_u64(0); let __v_13: G = G::from_u64(0); let __v_14: G = { let __values: [G; 4] = [__v_11, __v_12, __v_13, __v_13]; let __mq = record.memory_queries.get_mut(&4).ok_or(ExecError::InvalidMemorySize(4))?; if let Some(result) = __mq.get_mut(&__values[..]) { if !unconstrained { *result.multiplicity += G::ONE; } result.output[0] } else { let __ptr = G::from_usize(__mq.len()); __mq.insert(&__values[..], &[__ptr], G::from_bool(!unconstrained)); __ptr } }; - let __ret: [G; OUT_263] = [__v_10, __v_14]; - if let Some(result) = record.function_queries[263].get_mut(&inp[..]) { debug_assert_eq!(result.output, &__ret[..]); if !unconstrained { *result.multiplicity += G::ONE; } } else { record.function_queries[263].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained)); }; + let __ret: [G; OUT_259] = [__v_10, __v_14]; + if let Some(result) = record.function_queries[259].get_mut(&inp[..]) { debug_assert_eq!(result.output, &__ret[..]); if !unconstrained { *result.multiplicity += G::ONE; } } else { record.function_queries[259].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained)); }; return Ok(__ret); }, _ => { let __v_10: G = G::from_u64(0); - let __r_arr: [G; OUT_766] = { let __args: [G; IN_766] = [__v_1, __v_10]; let __cu = unconstrained; if let Some(result) = record.function_queries[766].get_mut(&__args[..]) { if !__cu && *result.multiplicity == G::ZERO { aiur_fn_766(__args, record, io_buffer, false)? } else { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_766] = unsafe { *(result.output.as_ptr() as *const [G; OUT_766]) }; __ret } } else { aiur_fn_766(__args, record, io_buffer, __cu)? } }; + let __r_arr: [G; OUT_762] = { let __args: [G; IN_762] = [__v_1, __v_10]; let __cu = unconstrained; if let Some(result) = record.function_queries[762].get_mut(&__args[..]) { if !__cu && *result.multiplicity == G::ZERO { aiur_fn_762(__args, record, io_buffer, false)? } else { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_762] = unsafe { *(result.output.as_ptr() as *const [G; OUT_762]) }; __ret } } else { aiur_fn_762(__args, record, io_buffer, __cu)? } }; let __v_11: G = __r_arr[0]; - let __r_arr: [G; OUT_243] = { let __args: [G; IN_243] = [__v_11]; let __cu = unconstrained; if let Some(result) = record.function_queries[243].get_mut(&__args[..]) { if !__cu && *result.multiplicity == G::ZERO { aiur_fn_243(__args, record, io_buffer, false)? } else { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_243] = unsafe { *(result.output.as_ptr() as *const [G; OUT_243]) }; __ret } } else { aiur_fn_243(__args, record, io_buffer, __cu)? } }; + let __r_arr: [G; OUT_239] = { let __args: [G; IN_239] = [__v_11]; let __cu = unconstrained; if let Some(result) = record.function_queries[239].get_mut(&__args[..]) { if !__cu && *result.multiplicity == G::ZERO { aiur_fn_239(__args, record, io_buffer, false)? } else { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_239] = unsafe { *(result.output.as_ptr() as *const [G; OUT_239]) }; __ret } } else { aiur_fn_239(__args, record, io_buffer, __cu)? } }; let __v_12: G = __r_arr[0]; let __v_13: G = __r_arr[1]; match __v_12.as_canonical_u64() { 1u64 => { let __v_14: G = G::from_u64(1); - let __r_arr: [G; OUT_775] = { let __args: [G; IN_775] = [__v_1, __v_14]; let __cu = unconstrained; if let Some(result) = record.function_queries[775].get_mut(&__args[..]) { if !__cu && *result.multiplicity == G::ZERO { aiur_fn_775(__args, record, io_buffer, false)? } else { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_775] = unsafe { *(result.output.as_ptr() as *const [G; OUT_775]) }; __ret } } else { aiur_fn_775(__args, record, io_buffer, __cu)? } }; + let __r_arr: [G; OUT_771] = { let __args: [G; IN_771] = [__v_1, __v_14]; let __cu = unconstrained; if let Some(result) = record.function_queries[771].get_mut(&__args[..]) { if !__cu && *result.multiplicity == G::ZERO { aiur_fn_771(__args, record, io_buffer, false)? } else { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_771] = unsafe { *(result.output.as_ptr() as *const [G; OUT_771]) }; __ret } } else { aiur_fn_771(__args, record, io_buffer, __cu)? } }; let __v_15: G = __r_arr[0]; let __v_16: G = G::from_u64(1); let __r_arr: [G; OUT_121] = { let __args: [G; IN_121] = [__v_13]; let __cu = unconstrained; if let Some(result) = record.function_queries[121].get_mut(&__args[..]) { if !__cu && *result.multiplicity == G::ZERO { aiur_fn_121(__args, record, io_buffer, false)? } else { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_121] = unsafe { *(result.output.as_ptr() as *const [G; OUT_121]) }; __ret } } else { aiur_fn_121(__args, record, io_buffer, __cu)? } }; let __v_17: G = __r_arr[0]; let __r_arr: [G; OUT_118] = { let __args: [G; IN_118] = [__v_17]; let __cu = unconstrained; if let Some(result) = record.function_queries[118].get_mut(&__args[..]) { if !__cu && *result.multiplicity == G::ZERO { aiur_fn_118(__args, record, io_buffer, false)? } else { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_118] = unsafe { *(result.output.as_ptr() as *const [G; OUT_118]) }; __ret } } else { aiur_fn_118(__args, record, io_buffer, __cu)? } }; let __v_18: G = __r_arr[0]; - let __r_arr: [G; OUT_245] = { let __args: [G; IN_245] = [__v_18]; let __cu = unconstrained; if let Some(result) = record.function_queries[245].get_mut(&__args[..]) { if !__cu && *result.multiplicity == G::ZERO { aiur_fn_245(__args, record, io_buffer, false)? } else { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_245] = unsafe { *(result.output.as_ptr() as *const [G; OUT_245]) }; __ret } } else { aiur_fn_245(__args, record, io_buffer, __cu)? } }; + let __r_arr: [G; OUT_241] = { let __args: [G; IN_241] = [__v_18]; let __cu = unconstrained; if let Some(result) = record.function_queries[241].get_mut(&__args[..]) { if !__cu && *result.multiplicity == G::ZERO { aiur_fn_241(__args, record, io_buffer, false)? } else { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_241] = unsafe { *(result.output.as_ptr() as *const [G; OUT_241]) }; __ret } } else { aiur_fn_241(__args, record, io_buffer, __cu)? } }; let __v_19: G = __r_arr[0]; - let __r_arr: [G; OUT_255] = { let __args: [G; IN_255] = [__v_19, __v_15]; let __cu = unconstrained; if let Some(result) = record.function_queries[255].get_mut(&__args[..]) { if !__cu && *result.multiplicity == G::ZERO { aiur_fn_255(__args, record, io_buffer, false)? } else { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_255] = unsafe { *(result.output.as_ptr() as *const [G; OUT_255]) }; __ret } } else { aiur_fn_255(__args, record, io_buffer, __cu)? } }; + let __r_arr: [G; OUT_251] = { let __args: [G; IN_251] = [__v_19, __v_15]; let __cu = unconstrained; if let Some(result) = record.function_queries[251].get_mut(&__args[..]) { if !__cu && *result.multiplicity == G::ZERO { aiur_fn_251(__args, record, io_buffer, false)? } else { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_251] = unsafe { *(result.output.as_ptr() as *const [G; OUT_251]) }; __ret } } else { aiur_fn_251(__args, record, io_buffer, __cu)? } }; let __v_20: G = __r_arr[0]; - let __ret: [G; OUT_263] = [__v_16, __v_20]; - if let Some(result) = record.function_queries[263].get_mut(&inp[..]) { debug_assert_eq!(result.output, &__ret[..]); if !unconstrained { *result.multiplicity += G::ONE; } } else { record.function_queries[263].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained)); }; + let __ret: [G; OUT_259] = [__v_16, __v_20]; + if let Some(result) = record.function_queries[259].get_mut(&inp[..]) { debug_assert_eq!(result.output, &__ret[..]); if !unconstrained { *result.multiplicity += G::ONE; } } else { record.function_queries[259].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained)); }; return Ok(__ret); }, _ => { @@ -25075,8 +24801,8 @@ fn aiur_fn_263( let __v_16: G = G::from_u64(0); let __v_17: G = G::from_u64(0); let __v_18: G = { let __values: [G; 4] = [__v_15, __v_16, __v_17, __v_17]; let __mq = record.memory_queries.get_mut(&4).ok_or(ExecError::InvalidMemorySize(4))?; if let Some(result) = __mq.get_mut(&__values[..]) { if !unconstrained { *result.multiplicity += G::ONE; } result.output[0] } else { let __ptr = G::from_usize(__mq.len()); __mq.insert(&__values[..], &[__ptr], G::from_bool(!unconstrained)); __ptr } }; - let __ret: [G; OUT_263] = [__v_14, __v_18]; - if let Some(result) = record.function_queries[263].get_mut(&inp[..]) { debug_assert_eq!(result.output, &__ret[..]); if !unconstrained { *result.multiplicity += G::ONE; } } else { record.function_queries[263].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained)); }; + let __ret: [G; OUT_259] = [__v_14, __v_18]; + if let Some(result) = record.function_queries[259].get_mut(&inp[..]) { debug_assert_eq!(result.output, &__ret[..]); if !unconstrained { *result.multiplicity += G::ONE; } } else { record.function_queries[259].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained)); }; return Ok(__ret); }, } @@ -25084,11 +24810,11 @@ fn aiur_fn_263( } }, _ => { - let __r_arr: [G; OUT_264] = { let __args: [G; IN_264] = [__v_0, __v_1, __v_3]; let __cu = unconstrained; if let Some(result) = record.function_queries[264].get_mut(&__args[..]) { if !__cu && *result.multiplicity == G::ZERO { aiur_fn_264(__args, record, io_buffer, false)? } else { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_264] = unsafe { *(result.output.as_ptr() as *const [G; OUT_264]) }; __ret } } else { aiur_fn_264(__args, record, io_buffer, __cu)? } }; + let __r_arr: [G; OUT_260] = { let __args: [G; IN_260] = [__v_0, __v_1, __v_3]; let __cu = unconstrained; if let Some(result) = record.function_queries[260].get_mut(&__args[..]) { if !__cu && *result.multiplicity == G::ZERO { aiur_fn_260(__args, record, io_buffer, false)? } else { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_260] = unsafe { *(result.output.as_ptr() as *const [G; OUT_260]) }; __ret } } else { aiur_fn_260(__args, record, io_buffer, __cu)? } }; let __v_8: G = __r_arr[0]; let __v_9: G = __r_arr[1]; - let __ret: [G; OUT_263] = [__v_8, __v_9]; - if let Some(result) = record.function_queries[263].get_mut(&inp[..]) { debug_assert_eq!(result.output, &__ret[..]); if !unconstrained { *result.multiplicity += G::ONE; } } else { record.function_queries[263].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained)); }; + let __ret: [G; OUT_259] = [__v_8, __v_9]; + if let Some(result) = record.function_queries[259].get_mut(&inp[..]) { debug_assert_eq!(result.output, &__ret[..]); if !unconstrained { *result.multiplicity += G::ONE; } } else { record.function_queries[259].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained)); }; return Ok(__ret); }, } @@ -25097,15 +24823,15 @@ fn aiur_fn_263( }) } -const INPUT_SIZE_264: usize = 3; -const IN_264: usize = 3; -const OUT_264: usize = 2; -fn aiur_fn_264( - inp: [G; IN_264], +const INPUT_SIZE_260: usize = 3; +const IN_260: usize = 3; +const OUT_260: usize = 2; +fn aiur_fn_260( + inp: [G; IN_260], record: &mut QueryRecord, io_buffer: &mut IOBuffer, unconstrained: bool, -) -> Result<[G; OUT_264], ExecError> { +) -> Result<[G; OUT_260], ExecError> { stacker::maybe_grow(64 * 1024, 4 * 1024 * 1024, || { let __v_0: G = inp[0]; let __v_1: G = inp[1]; @@ -25119,40 +24845,40 @@ fn aiur_fn_264( let __v_7: G = G::from_u64(0); let __v_8: G = G::from_u64(0); let __v_9: G = { let __values: [G; 4] = [__v_6, __v_7, __v_8, __v_8]; let __mq = record.memory_queries.get_mut(&4).ok_or(ExecError::InvalidMemorySize(4))?; if let Some(result) = __mq.get_mut(&__values[..]) { if !unconstrained { *result.multiplicity += G::ONE; } result.output[0] } else { let __ptr = G::from_usize(__mq.len()); __mq.insert(&__values[..], &[__ptr], G::from_bool(!unconstrained)); __ptr } }; - let __ret: [G; OUT_264] = [__v_5, __v_9]; - if let Some(result) = record.function_queries[264].get_mut(&inp[..]) { debug_assert_eq!(result.output, &__ret[..]); if !unconstrained { *result.multiplicity += G::ONE; } } else { record.function_queries[264].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained)); }; + let __ret: [G; OUT_260] = [__v_5, __v_9]; + if let Some(result) = record.function_queries[260].get_mut(&inp[..]) { debug_assert_eq!(result.output, &__ret[..]); if !unconstrained { *result.multiplicity += G::ONE; } } else { record.function_queries[260].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained)); }; return Ok(__ret); }, _ => { let __v_5: G = G::from_u64(0); - let __r_arr: [G; OUT_766] = { let __args: [G; IN_766] = [__v_1, __v_5]; let __cu = unconstrained; if let Some(result) = record.function_queries[766].get_mut(&__args[..]) { if !__cu && *result.multiplicity == G::ZERO { aiur_fn_766(__args, record, io_buffer, false)? } else { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_766] = unsafe { *(result.output.as_ptr() as *const [G; OUT_766]) }; __ret } } else { aiur_fn_766(__args, record, io_buffer, __cu)? } }; + let __r_arr: [G; OUT_762] = { let __args: [G; IN_762] = [__v_1, __v_5]; let __cu = unconstrained; if let Some(result) = record.function_queries[762].get_mut(&__args[..]) { if !__cu && *result.multiplicity == G::ZERO { aiur_fn_762(__args, record, io_buffer, false)? } else { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_762] = unsafe { *(result.output.as_ptr() as *const [G; OUT_762]) }; __ret } } else { aiur_fn_762(__args, record, io_buffer, __cu)? } }; let __v_6: G = __r_arr[0]; let __v_7: G = G::from_u64(1); - let __r_arr: [G; OUT_766] = { let __args: [G; IN_766] = [__v_1, __v_7]; let __cu = unconstrained; if let Some(result) = record.function_queries[766].get_mut(&__args[..]) { if !__cu && *result.multiplicity == G::ZERO { aiur_fn_766(__args, record, io_buffer, false)? } else { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_766] = unsafe { *(result.output.as_ptr() as *const [G; OUT_766]) }; __ret } } else { aiur_fn_766(__args, record, io_buffer, __cu)? } }; + let __r_arr: [G; OUT_762] = { let __args: [G; IN_762] = [__v_1, __v_7]; let __cu = unconstrained; if let Some(result) = record.function_queries[762].get_mut(&__args[..]) { if !__cu && *result.multiplicity == G::ZERO { aiur_fn_762(__args, record, io_buffer, false)? } else { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_762] = unsafe { *(result.output.as_ptr() as *const [G; OUT_762]) }; __ret } } else { aiur_fn_762(__args, record, io_buffer, __cu)? } }; let __v_8: G = __r_arr[0]; - let __r_arr: [G; OUT_243] = { let __args: [G; IN_243] = [__v_6]; let __cu = unconstrained; if let Some(result) = record.function_queries[243].get_mut(&__args[..]) { if !__cu && *result.multiplicity == G::ZERO { aiur_fn_243(__args, record, io_buffer, false)? } else { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_243] = unsafe { *(result.output.as_ptr() as *const [G; OUT_243]) }; __ret } } else { aiur_fn_243(__args, record, io_buffer, __cu)? } }; + let __r_arr: [G; OUT_239] = { let __args: [G; IN_239] = [__v_6]; let __cu = unconstrained; if let Some(result) = record.function_queries[239].get_mut(&__args[..]) { if !__cu && *result.multiplicity == G::ZERO { aiur_fn_239(__args, record, io_buffer, false)? } else { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_239] = unsafe { *(result.output.as_ptr() as *const [G; OUT_239]) }; __ret } } else { aiur_fn_239(__args, record, io_buffer, __cu)? } }; let __v_9: G = __r_arr[0]; let __v_10: G = __r_arr[1]; match __v_9.as_canonical_u64() { 1u64 => { - let __r_arr: [G; OUT_243] = { let __args: [G; IN_243] = [__v_8]; let __cu = unconstrained; if let Some(result) = record.function_queries[243].get_mut(&__args[..]) { if !__cu && *result.multiplicity == G::ZERO { aiur_fn_243(__args, record, io_buffer, false)? } else { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_243] = unsafe { *(result.output.as_ptr() as *const [G; OUT_243]) }; __ret } } else { aiur_fn_243(__args, record, io_buffer, __cu)? } }; + let __r_arr: [G; OUT_239] = { let __args: [G; IN_239] = [__v_8]; let __cu = unconstrained; if let Some(result) = record.function_queries[239].get_mut(&__args[..]) { if !__cu && *result.multiplicity == G::ZERO { aiur_fn_239(__args, record, io_buffer, false)? } else { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_239] = unsafe { *(result.output.as_ptr() as *const [G; OUT_239]) }; __ret } } else { aiur_fn_239(__args, record, io_buffer, __cu)? } }; let __v_11: G = __r_arr[0]; let __v_12: G = __r_arr[1]; match __v_11.as_canonical_u64() { 1u64 => { - let __r_arr: [G; OUT_256] = { let __args: [G; IN_256] = [__v_0, __v_10, __v_12]; let __cu = unconstrained; if let Some(result) = record.function_queries[256].get_mut(&__args[..]) { if !__cu && *result.multiplicity == G::ZERO { aiur_fn_256(__args, record, io_buffer, false)? } else { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_256] = unsafe { *(result.output.as_ptr() as *const [G; OUT_256]) }; __ret } } else { aiur_fn_256(__args, record, io_buffer, __cu)? } }; + let __r_arr: [G; OUT_252] = { let __args: [G; IN_252] = [__v_0, __v_10, __v_12]; let __cu = unconstrained; if let Some(result) = record.function_queries[252].get_mut(&__args[..]) { if !__cu && *result.multiplicity == G::ZERO { aiur_fn_252(__args, record, io_buffer, false)? } else { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_252] = unsafe { *(result.output.as_ptr() as *const [G; OUT_252]) }; __ret } } else { aiur_fn_252(__args, record, io_buffer, __cu)? } }; let __v_13: G = __r_arr[0]; let __v_14: G = __r_arr[1]; match __v_13.as_canonical_u64() { 1u64 => { let __v_15: G = G::from_u64(2); - let __r_arr: [G; OUT_775] = { let __args: [G; IN_775] = [__v_1, __v_15]; let __cu = unconstrained; if let Some(result) = record.function_queries[775].get_mut(&__args[..]) { if !__cu && *result.multiplicity == G::ZERO { aiur_fn_775(__args, record, io_buffer, false)? } else { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_775] = unsafe { *(result.output.as_ptr() as *const [G; OUT_775]) }; __ret } } else { aiur_fn_775(__args, record, io_buffer, __cu)? } }; + let __r_arr: [G; OUT_771] = { let __args: [G; IN_771] = [__v_1, __v_15]; let __cu = unconstrained; if let Some(result) = record.function_queries[771].get_mut(&__args[..]) { if !__cu && *result.multiplicity == G::ZERO { aiur_fn_771(__args, record, io_buffer, false)? } else { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_771] = unsafe { *(result.output.as_ptr() as *const [G; OUT_771]) }; __ret } } else { aiur_fn_771(__args, record, io_buffer, __cu)? } }; let __v_16: G = __r_arr[0]; let __v_17: G = G::from_u64(1); - let __r_arr: [G; OUT_255] = { let __args: [G; IN_255] = [__v_14, __v_16]; let __cu = unconstrained; if let Some(result) = record.function_queries[255].get_mut(&__args[..]) { if !__cu && *result.multiplicity == G::ZERO { aiur_fn_255(__args, record, io_buffer, false)? } else { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_255] = unsafe { *(result.output.as_ptr() as *const [G; OUT_255]) }; __ret } } else { aiur_fn_255(__args, record, io_buffer, __cu)? } }; + let __r_arr: [G; OUT_251] = { let __args: [G; IN_251] = [__v_14, __v_16]; let __cu = unconstrained; if let Some(result) = record.function_queries[251].get_mut(&__args[..]) { if !__cu && *result.multiplicity == G::ZERO { aiur_fn_251(__args, record, io_buffer, false)? } else { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_251] = unsafe { *(result.output.as_ptr() as *const [G; OUT_251]) }; __ret } } else { aiur_fn_251(__args, record, io_buffer, __cu)? } }; let __v_18: G = __r_arr[0]; - let __ret: [G; OUT_264] = [__v_17, __v_18]; - if let Some(result) = record.function_queries[264].get_mut(&inp[..]) { debug_assert_eq!(result.output, &__ret[..]); if !unconstrained { *result.multiplicity += G::ONE; } } else { record.function_queries[264].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained)); }; + let __ret: [G; OUT_260] = [__v_17, __v_18]; + if let Some(result) = record.function_queries[260].get_mut(&inp[..]) { debug_assert_eq!(result.output, &__ret[..]); if !unconstrained { *result.multiplicity += G::ONE; } } else { record.function_queries[260].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained)); }; return Ok(__ret); }, _ => { @@ -25161,8 +24887,8 @@ fn aiur_fn_264( let __v_17: G = G::from_u64(0); let __v_18: G = G::from_u64(0); let __v_19: G = { let __values: [G; 4] = [__v_16, __v_17, __v_18, __v_18]; let __mq = record.memory_queries.get_mut(&4).ok_or(ExecError::InvalidMemorySize(4))?; if let Some(result) = __mq.get_mut(&__values[..]) { if !unconstrained { *result.multiplicity += G::ONE; } result.output[0] } else { let __ptr = G::from_usize(__mq.len()); __mq.insert(&__values[..], &[__ptr], G::from_bool(!unconstrained)); __ptr } }; - let __ret: [G; OUT_264] = [__v_15, __v_19]; - if let Some(result) = record.function_queries[264].get_mut(&inp[..]) { debug_assert_eq!(result.output, &__ret[..]); if !unconstrained { *result.multiplicity += G::ONE; } } else { record.function_queries[264].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained)); }; + let __ret: [G; OUT_260] = [__v_15, __v_19]; + if let Some(result) = record.function_queries[260].get_mut(&inp[..]) { debug_assert_eq!(result.output, &__ret[..]); if !unconstrained { *result.multiplicity += G::ONE; } } else { record.function_queries[260].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained)); }; return Ok(__ret); }, } @@ -25173,23 +24899,23 @@ fn aiur_fn_264( let __v_15: G = G::from_u64(0); let __v_16: G = G::from_u64(0); let __v_17: G = { let __values: [G; 4] = [__v_14, __v_15, __v_16, __v_16]; let __mq = record.memory_queries.get_mut(&4).ok_or(ExecError::InvalidMemorySize(4))?; if let Some(result) = __mq.get_mut(&__values[..]) { if !unconstrained { *result.multiplicity += G::ONE; } result.output[0] } else { let __ptr = G::from_usize(__mq.len()); __mq.insert(&__values[..], &[__ptr], G::from_bool(!unconstrained)); __ptr } }; - let __ret: [G; OUT_264] = [__v_13, __v_17]; - if let Some(result) = record.function_queries[264].get_mut(&inp[..]) { debug_assert_eq!(result.output, &__ret[..]); if !unconstrained { *result.multiplicity += G::ONE; } } else { record.function_queries[264].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained)); }; + let __ret: [G; OUT_260] = [__v_13, __v_17]; + if let Some(result) = record.function_queries[260].get_mut(&inp[..]) { debug_assert_eq!(result.output, &__ret[..]); if !unconstrained { *result.multiplicity += G::ONE; } } else { record.function_queries[260].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained)); }; return Ok(__ret); }, } }, _ => { - let __r_arr: [G; OUT_243] = { let __args: [G; IN_243] = [__v_8]; let __cu = unconstrained; if let Some(result) = record.function_queries[243].get_mut(&__args[..]) { if !__cu && *result.multiplicity == G::ZERO { aiur_fn_243(__args, record, io_buffer, false)? } else { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_243] = unsafe { *(result.output.as_ptr() as *const [G; OUT_243]) }; __ret } } else { aiur_fn_243(__args, record, io_buffer, __cu)? } }; + let __r_arr: [G; OUT_239] = { let __args: [G; IN_239] = [__v_8]; let __cu = unconstrained; if let Some(result) = record.function_queries[239].get_mut(&__args[..]) { if !__cu && *result.multiplicity == G::ZERO { aiur_fn_239(__args, record, io_buffer, false)? } else { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_239] = unsafe { *(result.output.as_ptr() as *const [G; OUT_239]) }; __ret } } else { aiur_fn_239(__args, record, io_buffer, __cu)? } }; let __v_11: G = __r_arr[0]; let __v_12: G = __r_arr[1]; match __v_11.as_canonical_u64() { 1u64 => { - let __r_arr: [G; OUT_265] = { let __args: [G; IN_265] = [__v_0, __v_6, __v_12, __v_1]; let __cu = unconstrained; if let Some(result) = record.function_queries[265].get_mut(&__args[..]) { if !__cu && *result.multiplicity == G::ZERO { aiur_fn_265(__args, record, io_buffer, false)? } else { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_265] = unsafe { *(result.output.as_ptr() as *const [G; OUT_265]) }; __ret } } else { aiur_fn_265(__args, record, io_buffer, __cu)? } }; + let __r_arr: [G; OUT_261] = { let __args: [G; IN_261] = [__v_0, __v_6, __v_12, __v_1]; let __cu = unconstrained; if let Some(result) = record.function_queries[261].get_mut(&__args[..]) { if !__cu && *result.multiplicity == G::ZERO { aiur_fn_261(__args, record, io_buffer, false)? } else { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_261] = unsafe { *(result.output.as_ptr() as *const [G; OUT_261]) }; __ret } } else { aiur_fn_261(__args, record, io_buffer, __cu)? } }; let __v_13: G = __r_arr[0]; let __v_14: G = __r_arr[1]; - let __ret: [G; OUT_264] = [__v_13, __v_14]; - if let Some(result) = record.function_queries[264].get_mut(&inp[..]) { debug_assert_eq!(result.output, &__ret[..]); if !unconstrained { *result.multiplicity += G::ONE; } } else { record.function_queries[264].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained)); }; + let __ret: [G; OUT_260] = [__v_13, __v_14]; + if let Some(result) = record.function_queries[260].get_mut(&inp[..]) { debug_assert_eq!(result.output, &__ret[..]); if !unconstrained { *result.multiplicity += G::ONE; } } else { record.function_queries[260].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained)); }; return Ok(__ret); }, _ => { @@ -25198,8 +24924,8 @@ fn aiur_fn_264( let __v_15: G = G::from_u64(0); let __v_16: G = G::from_u64(0); let __v_17: G = { let __values: [G; 4] = [__v_14, __v_15, __v_16, __v_16]; let __mq = record.memory_queries.get_mut(&4).ok_or(ExecError::InvalidMemorySize(4))?; if let Some(result) = __mq.get_mut(&__values[..]) { if !unconstrained { *result.multiplicity += G::ONE; } result.output[0] } else { let __ptr = G::from_usize(__mq.len()); __mq.insert(&__values[..], &[__ptr], G::from_bool(!unconstrained)); __ptr } }; - let __ret: [G; OUT_264] = [__v_13, __v_17]; - if let Some(result) = record.function_queries[264].get_mut(&inp[..]) { debug_assert_eq!(result.output, &__ret[..]); if !unconstrained { *result.multiplicity += G::ONE; } } else { record.function_queries[264].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained)); }; + let __ret: [G; OUT_260] = [__v_13, __v_17]; + if let Some(result) = record.function_queries[260].get_mut(&inp[..]) { debug_assert_eq!(result.output, &__ret[..]); if !unconstrained { *result.multiplicity += G::ONE; } } else { record.function_queries[260].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained)); }; return Ok(__ret); }, } @@ -25210,15 +24936,15 @@ fn aiur_fn_264( }) } -const INPUT_SIZE_265: usize = 4; -const IN_265: usize = 4; -const OUT_265: usize = 2; -fn aiur_fn_265( - inp: [G; IN_265], +const INPUT_SIZE_261: usize = 4; +const IN_261: usize = 4; +const OUT_261: usize = 2; +fn aiur_fn_261( + inp: [G; IN_261], record: &mut QueryRecord, io_buffer: &mut IOBuffer, unconstrained: bool, -) -> Result<[G; OUT_265], ExecError> { +) -> Result<[G; OUT_261], ExecError> { stacker::maybe_grow(64 * 1024, 4 * 1024 * 1024, || { let __v_0: G = inp[0]; let __v_1: G = inp[1]; @@ -25259,24 +24985,24 @@ fn aiur_fn_265( let __v_24: G = G::from_u64(0); let __v_25: G = G::from_u64(0); let __v_26: G = { let __values: [G; 4] = [__v_23, __v_24, __v_25, __v_25]; let __mq = record.memory_queries.get_mut(&4).ok_or(ExecError::InvalidMemorySize(4))?; if let Some(result) = __mq.get_mut(&__values[..]) { if !unconstrained { *result.multiplicity += G::ONE; } result.output[0] } else { let __ptr = G::from_usize(__mq.len()); __mq.insert(&__values[..], &[__ptr], G::from_bool(!unconstrained)); __ptr } }; - let __ret: [G; OUT_265] = [__v_22, __v_26]; - if let Some(result) = record.function_queries[265].get_mut(&inp[..]) { debug_assert_eq!(result.output, &__ret[..]); if !unconstrained { *result.multiplicity += G::ONE; } } else { record.function_queries[265].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained)); }; + let __ret: [G; OUT_261] = [__v_22, __v_26]; + if let Some(result) = record.function_queries[261].get_mut(&inp[..]) { debug_assert_eq!(result.output, &__ret[..]); if !unconstrained { *result.multiplicity += G::ONE; } } else { record.function_queries[261].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained)); }; return Ok(__ret); }, _ => { let __v_22: G = G::from_u64(2); - let __r_arr: [G; OUT_775] = { let __args: [G; IN_775] = [__v_3, __v_22]; let __cu = unconstrained; if let Some(result) = record.function_queries[775].get_mut(&__args[..]) { if !__cu && *result.multiplicity == G::ZERO { aiur_fn_775(__args, record, io_buffer, false)? } else { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_775] = unsafe { *(result.output.as_ptr() as *const [G; OUT_775]) }; __ret } } else { aiur_fn_775(__args, record, io_buffer, __cu)? } }; + let __r_arr: [G; OUT_771] = { let __args: [G; IN_771] = [__v_3, __v_22]; let __cu = unconstrained; if let Some(result) = record.function_queries[771].get_mut(&__args[..]) { if !__cu && *result.multiplicity == G::ZERO { aiur_fn_771(__args, record, io_buffer, false)? } else { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_771] = unsafe { *(result.output.as_ptr() as *const [G; OUT_771]) }; __ret } } else { aiur_fn_771(__args, record, io_buffer, __cu)? } }; let __v_23: G = __r_arr[0]; match __v_5.as_canonical_u64() { 1u64 => { - let __r_arr: [G; OUT_260] = { let __args: [G; IN_260] = [__v_1, __v_2, __v_23]; let __cu = unconstrained; if let Some(result) = record.function_queries[260].get_mut(&__args[..]) { if !__cu && *result.multiplicity == G::ZERO { aiur_fn_260(__args, record, io_buffer, false)? } else { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_260] = unsafe { *(result.output.as_ptr() as *const [G; OUT_260]) }; __ret } } else { aiur_fn_260(__args, record, io_buffer, __cu)? } }; + let __r_arr: [G; OUT_256] = { let __args: [G; IN_256] = [__v_1, __v_2, __v_23]; let __cu = unconstrained; if let Some(result) = record.function_queries[256].get_mut(&__args[..]) { if !__cu && *result.multiplicity == G::ZERO { aiur_fn_256(__args, record, io_buffer, false)? } else { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_256] = unsafe { *(result.output.as_ptr() as *const [G; OUT_256]) }; __ret } } else { aiur_fn_256(__args, record, io_buffer, __cu)? } }; let __v_24: G = __r_arr[0]; let __v_25: G = __r_arr[1]; match __v_24.as_canonical_u64() { 1u64 => { let __v_26: G = G::from_u64(2); - let __ret: [G; OUT_265] = [__v_26, __v_25]; - if let Some(result) = record.function_queries[265].get_mut(&inp[..]) { debug_assert_eq!(result.output, &__ret[..]); if !unconstrained { *result.multiplicity += G::ONE; } } else { record.function_queries[265].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained)); }; + let __ret: [G; OUT_261] = [__v_26, __v_25]; + if let Some(result) = record.function_queries[261].get_mut(&inp[..]) { debug_assert_eq!(result.output, &__ret[..]); if !unconstrained { *result.multiplicity += G::ONE; } } else { record.function_queries[261].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained)); }; return Ok(__ret); }, _ => { @@ -25285,18 +25011,18 @@ fn aiur_fn_265( let __v_28: G = G::from_u64(0); let __v_29: G = G::from_u64(0); let __v_30: G = { let __values: [G; 4] = [__v_27, __v_28, __v_29, __v_29]; let __mq = record.memory_queries.get_mut(&4).ok_or(ExecError::InvalidMemorySize(4))?; if let Some(result) = __mq.get_mut(&__values[..]) { if !unconstrained { *result.multiplicity += G::ONE; } result.output[0] } else { let __ptr = G::from_usize(__mq.len()); __mq.insert(&__values[..], &[__ptr], G::from_bool(!unconstrained)); __ptr } }; - let __ret: [G; OUT_265] = [__v_26, __v_30]; - if let Some(result) = record.function_queries[265].get_mut(&inp[..]) { debug_assert_eq!(result.output, &__ret[..]); if !unconstrained { *result.multiplicity += G::ONE; } } else { record.function_queries[265].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained)); }; + let __ret: [G; OUT_261] = [__v_26, __v_30]; + if let Some(result) = record.function_queries[261].get_mut(&inp[..]) { debug_assert_eq!(result.output, &__ret[..]); if !unconstrained { *result.multiplicity += G::ONE; } } else { record.function_queries[261].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained)); }; return Ok(__ret); }, } }, _ => { let __v_24: G = G::from_u64(2); - let __r_arr: [G; OUT_266] = { let __args: [G; IN_266] = [__v_0, __v_1, __v_2, __v_23]; let __cu = unconstrained; if let Some(result) = record.function_queries[266].get_mut(&__args[..]) { if !__cu && *result.multiplicity == G::ZERO { aiur_fn_266(__args, record, io_buffer, false)? } else { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_266] = unsafe { *(result.output.as_ptr() as *const [G; OUT_266]) }; __ret } } else { aiur_fn_266(__args, record, io_buffer, __cu)? } }; + let __r_arr: [G; OUT_262] = { let __args: [G; IN_262] = [__v_0, __v_1, __v_2, __v_23]; let __cu = unconstrained; if let Some(result) = record.function_queries[262].get_mut(&__args[..]) { if !__cu && *result.multiplicity == G::ZERO { aiur_fn_262(__args, record, io_buffer, false)? } else { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_262] = unsafe { *(result.output.as_ptr() as *const [G; OUT_262]) }; __ret } } else { aiur_fn_262(__args, record, io_buffer, __cu)? } }; let __v_25: G = __r_arr[0]; - let __ret: [G; OUT_265] = [__v_24, __v_25]; - if let Some(result) = record.function_queries[265].get_mut(&inp[..]) { debug_assert_eq!(result.output, &__ret[..]); if !unconstrained { *result.multiplicity += G::ONE; } } else { record.function_queries[265].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained)); }; + let __ret: [G; OUT_261] = [__v_24, __v_25]; + if let Some(result) = record.function_queries[261].get_mut(&inp[..]) { debug_assert_eq!(result.output, &__ret[..]); if !unconstrained { *result.multiplicity += G::ONE; } } else { record.function_queries[261].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained)); }; return Ok(__ret); }, } @@ -25305,15 +25031,15 @@ fn aiur_fn_265( }) } -const INPUT_SIZE_266: usize = 4; -const IN_266: usize = 4; -const OUT_266: usize = 1; -fn aiur_fn_266( - inp: [G; IN_266], +const INPUT_SIZE_262: usize = 4; +const IN_262: usize = 4; +const OUT_262: usize = 1; +fn aiur_fn_262( + inp: [G; IN_262], record: &mut QueryRecord, io_buffer: &mut IOBuffer, unconstrained: bool, -) -> Result<[G; OUT_266], ExecError> { +) -> Result<[G; OUT_262], ExecError> { stacker::maybe_grow(64 * 1024, 4 * 1024 * 1024, || { let __v_0: G = inp[0]; let __v_1: G = inp[1]; @@ -25329,27 +25055,27 @@ fn aiur_fn_266( let __v_11: G = G::from_u64(3); let __v_12: G = G::from_u64(0); let __v_13: G = { let __values: [G; 4] = [__v_11, __v_9, __v_1, __v_12]; let __mq = record.memory_queries.get_mut(&4).ok_or(ExecError::InvalidMemorySize(4))?; if let Some(result) = __mq.get_mut(&__values[..]) { if !unconstrained { *result.multiplicity += G::ONE; } result.output[0] } else { let __ptr = G::from_usize(__mq.len()); __mq.insert(&__values[..], &[__ptr], G::from_bool(!unconstrained)); __ptr } }; - let __r_arr: [G; OUT_245] = { let __args: [G; IN_245] = [__v_2]; let __cu = unconstrained; if let Some(result) = record.function_queries[245].get_mut(&__args[..]) { if !__cu && *result.multiplicity == G::ZERO { aiur_fn_245(__args, record, io_buffer, false)? } else { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_245] = unsafe { *(result.output.as_ptr() as *const [G; OUT_245]) }; __ret } } else { aiur_fn_245(__args, record, io_buffer, __cu)? } }; + let __r_arr: [G; OUT_241] = { let __args: [G; IN_241] = [__v_2]; let __cu = unconstrained; if let Some(result) = record.function_queries[241].get_mut(&__args[..]) { if !__cu && *result.multiplicity == G::ZERO { aiur_fn_241(__args, record, io_buffer, false)? } else { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_241] = unsafe { *(result.output.as_ptr() as *const [G; OUT_241]) }; __ret } } else { aiur_fn_241(__args, record, io_buffer, __cu)? } }; let __v_14: G = __r_arr[0]; let __v_15: G = G::from_u64(0); let __v_16: G = { let __values: [G; 4] = [__v_10, __v_13, __v_14, __v_15]; let __mq = record.memory_queries.get_mut(&4).ok_or(ExecError::InvalidMemorySize(4))?; if let Some(result) = __mq.get_mut(&__values[..]) { if !unconstrained { *result.multiplicity += G::ONE; } result.output[0] } else { let __ptr = G::from_usize(__mq.len()); __mq.insert(&__values[..], &[__ptr], G::from_bool(!unconstrained)); __ptr } }; - let __r_arr: [G; OUT_255] = { let __args: [G; IN_255] = [__v_16, __v_3]; let __cu = unconstrained; if let Some(result) = record.function_queries[255].get_mut(&__args[..]) { if !__cu && *result.multiplicity == G::ZERO { aiur_fn_255(__args, record, io_buffer, false)? } else { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_255] = unsafe { *(result.output.as_ptr() as *const [G; OUT_255]) }; __ret } } else { aiur_fn_255(__args, record, io_buffer, __cu)? } }; + let __r_arr: [G; OUT_251] = { let __args: [G; IN_251] = [__v_16, __v_3]; let __cu = unconstrained; if let Some(result) = record.function_queries[251].get_mut(&__args[..]) { if !__cu && *result.multiplicity == G::ZERO { aiur_fn_251(__args, record, io_buffer, false)? } else { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_251] = unsafe { *(result.output.as_ptr() as *const [G; OUT_251]) }; __ret } } else { aiur_fn_251(__args, record, io_buffer, __cu)? } }; let __v_17: G = __r_arr[0]; - let __ret: [G; OUT_266] = [__v_17]; - if let Some(result) = record.function_queries[266].get_mut(&inp[..]) { debug_assert_eq!(result.output, &__ret[..]); if !unconstrained { *result.multiplicity += G::ONE; } } else { record.function_queries[266].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained)); }; + let __ret: [G; OUT_262] = [__v_17]; + if let Some(result) = record.function_queries[262].get_mut(&inp[..]) { debug_assert_eq!(result.output, &__ret[..]); if !unconstrained { *result.multiplicity += G::ONE; } } else { record.function_queries[262].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained)); }; return Ok(__ret); }) } -const INPUT_SIZE_267: usize = 10; -const IN_267: usize = 10; -const OUT_267: usize = 8; -fn aiur_fn_267( - inp: [G; IN_267], +const INPUT_SIZE_263: usize = 10; +const IN_263: usize = 10; +const OUT_263: usize = 8; +fn aiur_fn_263( + inp: [G; IN_263], record: &mut QueryRecord, io_buffer: &mut IOBuffer, unconstrained: bool, -) -> Result<[G; OUT_267], ExecError> { +) -> Result<[G; OUT_263], ExecError> { stacker::maybe_grow(64 * 1024, 4 * 1024 * 1024, || { let __v_0: G = inp[0]; let __v_1: G = inp[1]; @@ -25363,8 +25089,8 @@ fn aiur_fn_267( let __v_9: G = inp[9]; match __v_9.as_canonical_u64() { 8u64 => { - let __ret: [G; OUT_267] = [__v_1, __v_2, __v_3, __v_4, __v_5, __v_6, __v_7, __v_8]; - if let Some(result) = record.function_queries[267].get_mut(&inp[..]) { debug_assert_eq!(result.output, &__ret[..]); if !unconstrained { *result.multiplicity += G::ONE; } } else { record.function_queries[267].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained)); }; + let __ret: [G; OUT_263] = [__v_1, __v_2, __v_3, __v_4, __v_5, __v_6, __v_7, __v_8]; + if let Some(result) = record.function_queries[263].get_mut(&inp[..]) { debug_assert_eq!(result.output, &__ret[..]); if !unconstrained { *result.multiplicity += G::ONE; } } else { record.function_queries[263].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained)); }; return Ok(__ret); }, _ => { @@ -25374,15 +25100,15 @@ fn aiur_fn_267( let __v_12: G = __loaded[2]; match __v_10.as_canonical_u64() { 1u64 => { - let __ret: [G; OUT_267] = [__v_1, __v_2, __v_3, __v_4, __v_5, __v_6, __v_7, __v_8]; - if let Some(result) = record.function_queries[267].get_mut(&inp[..]) { debug_assert_eq!(result.output, &__ret[..]); if !unconstrained { *result.multiplicity += G::ONE; } } else { record.function_queries[267].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained)); }; + let __ret: [G; OUT_263] = [__v_1, __v_2, __v_3, __v_4, __v_5, __v_6, __v_7, __v_8]; + if let Some(result) = record.function_queries[263].get_mut(&inp[..]) { debug_assert_eq!(result.output, &__ret[..]); if !unconstrained { *result.multiplicity += G::ONE; } } else { record.function_queries[263].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained)); }; return Ok(__ret); }, 0u64 => { match __v_9.as_canonical_u64() { 0u64 => { let __v_13: G = G::from_u64(1); - let __r_arr: [G; OUT_267] = { let __args: [G; IN_267] = [__v_12, __v_11, __v_2, __v_3, __v_4, __v_5, __v_6, __v_7, __v_8, __v_13]; let __cu = unconstrained; if let Some(result) = record.function_queries[267].get_mut(&__args[..]) { if !__cu && *result.multiplicity == G::ZERO { aiur_fn_267(__args, record, io_buffer, false)? } else { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_267] = unsafe { *(result.output.as_ptr() as *const [G; OUT_267]) }; __ret } } else { aiur_fn_267(__args, record, io_buffer, __cu)? } }; + let __r_arr: [G; OUT_263] = { let __args: [G; IN_263] = [__v_12, __v_11, __v_2, __v_3, __v_4, __v_5, __v_6, __v_7, __v_8, __v_13]; let __cu = unconstrained; if let Some(result) = record.function_queries[263].get_mut(&__args[..]) { if !__cu && *result.multiplicity == G::ZERO { aiur_fn_263(__args, record, io_buffer, false)? } else { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_263] = unsafe { *(result.output.as_ptr() as *const [G; OUT_263]) }; __ret } } else { aiur_fn_263(__args, record, io_buffer, __cu)? } }; let __v_14: G = __r_arr[0]; let __v_15: G = __r_arr[1]; let __v_16: G = __r_arr[2]; @@ -25391,13 +25117,13 @@ fn aiur_fn_267( let __v_19: G = __r_arr[5]; let __v_20: G = __r_arr[6]; let __v_21: G = __r_arr[7]; - let __ret: [G; OUT_267] = [__v_14, __v_15, __v_16, __v_17, __v_18, __v_19, __v_20, __v_21]; - if let Some(result) = record.function_queries[267].get_mut(&inp[..]) { debug_assert_eq!(result.output, &__ret[..]); if !unconstrained { *result.multiplicity += G::ONE; } } else { record.function_queries[267].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained)); }; + let __ret: [G; OUT_263] = [__v_14, __v_15, __v_16, __v_17, __v_18, __v_19, __v_20, __v_21]; + if let Some(result) = record.function_queries[263].get_mut(&inp[..]) { debug_assert_eq!(result.output, &__ret[..]); if !unconstrained { *result.multiplicity += G::ONE; } } else { record.function_queries[263].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained)); }; return Ok(__ret); }, 1u64 => { let __v_13: G = G::from_u64(2); - let __r_arr: [G; OUT_267] = { let __args: [G; IN_267] = [__v_12, __v_1, __v_11, __v_3, __v_4, __v_5, __v_6, __v_7, __v_8, __v_13]; let __cu = unconstrained; if let Some(result) = record.function_queries[267].get_mut(&__args[..]) { if !__cu && *result.multiplicity == G::ZERO { aiur_fn_267(__args, record, io_buffer, false)? } else { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_267] = unsafe { *(result.output.as_ptr() as *const [G; OUT_267]) }; __ret } } else { aiur_fn_267(__args, record, io_buffer, __cu)? } }; + let __r_arr: [G; OUT_263] = { let __args: [G; IN_263] = [__v_12, __v_1, __v_11, __v_3, __v_4, __v_5, __v_6, __v_7, __v_8, __v_13]; let __cu = unconstrained; if let Some(result) = record.function_queries[263].get_mut(&__args[..]) { if !__cu && *result.multiplicity == G::ZERO { aiur_fn_263(__args, record, io_buffer, false)? } else { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_263] = unsafe { *(result.output.as_ptr() as *const [G; OUT_263]) }; __ret } } else { aiur_fn_263(__args, record, io_buffer, __cu)? } }; let __v_14: G = __r_arr[0]; let __v_15: G = __r_arr[1]; let __v_16: G = __r_arr[2]; @@ -25406,13 +25132,13 @@ fn aiur_fn_267( let __v_19: G = __r_arr[5]; let __v_20: G = __r_arr[6]; let __v_21: G = __r_arr[7]; - let __ret: [G; OUT_267] = [__v_14, __v_15, __v_16, __v_17, __v_18, __v_19, __v_20, __v_21]; - if let Some(result) = record.function_queries[267].get_mut(&inp[..]) { debug_assert_eq!(result.output, &__ret[..]); if !unconstrained { *result.multiplicity += G::ONE; } } else { record.function_queries[267].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained)); }; + let __ret: [G; OUT_263] = [__v_14, __v_15, __v_16, __v_17, __v_18, __v_19, __v_20, __v_21]; + if let Some(result) = record.function_queries[263].get_mut(&inp[..]) { debug_assert_eq!(result.output, &__ret[..]); if !unconstrained { *result.multiplicity += G::ONE; } } else { record.function_queries[263].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained)); }; return Ok(__ret); }, 2u64 => { let __v_13: G = G::from_u64(3); - let __r_arr: [G; OUT_267] = { let __args: [G; IN_267] = [__v_12, __v_1, __v_2, __v_11, __v_4, __v_5, __v_6, __v_7, __v_8, __v_13]; let __cu = unconstrained; if let Some(result) = record.function_queries[267].get_mut(&__args[..]) { if !__cu && *result.multiplicity == G::ZERO { aiur_fn_267(__args, record, io_buffer, false)? } else { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_267] = unsafe { *(result.output.as_ptr() as *const [G; OUT_267]) }; __ret } } else { aiur_fn_267(__args, record, io_buffer, __cu)? } }; + let __r_arr: [G; OUT_263] = { let __args: [G; IN_263] = [__v_12, __v_1, __v_2, __v_11, __v_4, __v_5, __v_6, __v_7, __v_8, __v_13]; let __cu = unconstrained; if let Some(result) = record.function_queries[263].get_mut(&__args[..]) { if !__cu && *result.multiplicity == G::ZERO { aiur_fn_263(__args, record, io_buffer, false)? } else { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_263] = unsafe { *(result.output.as_ptr() as *const [G; OUT_263]) }; __ret } } else { aiur_fn_263(__args, record, io_buffer, __cu)? } }; let __v_14: G = __r_arr[0]; let __v_15: G = __r_arr[1]; let __v_16: G = __r_arr[2]; @@ -25421,13 +25147,13 @@ fn aiur_fn_267( let __v_19: G = __r_arr[5]; let __v_20: G = __r_arr[6]; let __v_21: G = __r_arr[7]; - let __ret: [G; OUT_267] = [__v_14, __v_15, __v_16, __v_17, __v_18, __v_19, __v_20, __v_21]; - if let Some(result) = record.function_queries[267].get_mut(&inp[..]) { debug_assert_eq!(result.output, &__ret[..]); if !unconstrained { *result.multiplicity += G::ONE; } } else { record.function_queries[267].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained)); }; + let __ret: [G; OUT_263] = [__v_14, __v_15, __v_16, __v_17, __v_18, __v_19, __v_20, __v_21]; + if let Some(result) = record.function_queries[263].get_mut(&inp[..]) { debug_assert_eq!(result.output, &__ret[..]); if !unconstrained { *result.multiplicity += G::ONE; } } else { record.function_queries[263].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained)); }; return Ok(__ret); }, 3u64 => { let __v_13: G = G::from_u64(4); - let __r_arr: [G; OUT_267] = { let __args: [G; IN_267] = [__v_12, __v_1, __v_2, __v_3, __v_11, __v_5, __v_6, __v_7, __v_8, __v_13]; let __cu = unconstrained; if let Some(result) = record.function_queries[267].get_mut(&__args[..]) { if !__cu && *result.multiplicity == G::ZERO { aiur_fn_267(__args, record, io_buffer, false)? } else { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_267] = unsafe { *(result.output.as_ptr() as *const [G; OUT_267]) }; __ret } } else { aiur_fn_267(__args, record, io_buffer, __cu)? } }; + let __r_arr: [G; OUT_263] = { let __args: [G; IN_263] = [__v_12, __v_1, __v_2, __v_3, __v_11, __v_5, __v_6, __v_7, __v_8, __v_13]; let __cu = unconstrained; if let Some(result) = record.function_queries[263].get_mut(&__args[..]) { if !__cu && *result.multiplicity == G::ZERO { aiur_fn_263(__args, record, io_buffer, false)? } else { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_263] = unsafe { *(result.output.as_ptr() as *const [G; OUT_263]) }; __ret } } else { aiur_fn_263(__args, record, io_buffer, __cu)? } }; let __v_14: G = __r_arr[0]; let __v_15: G = __r_arr[1]; let __v_16: G = __r_arr[2]; @@ -25436,13 +25162,13 @@ fn aiur_fn_267( let __v_19: G = __r_arr[5]; let __v_20: G = __r_arr[6]; let __v_21: G = __r_arr[7]; - let __ret: [G; OUT_267] = [__v_14, __v_15, __v_16, __v_17, __v_18, __v_19, __v_20, __v_21]; - if let Some(result) = record.function_queries[267].get_mut(&inp[..]) { debug_assert_eq!(result.output, &__ret[..]); if !unconstrained { *result.multiplicity += G::ONE; } } else { record.function_queries[267].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained)); }; + let __ret: [G; OUT_263] = [__v_14, __v_15, __v_16, __v_17, __v_18, __v_19, __v_20, __v_21]; + if let Some(result) = record.function_queries[263].get_mut(&inp[..]) { debug_assert_eq!(result.output, &__ret[..]); if !unconstrained { *result.multiplicity += G::ONE; } } else { record.function_queries[263].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained)); }; return Ok(__ret); }, 4u64 => { let __v_13: G = G::from_u64(5); - let __r_arr: [G; OUT_267] = { let __args: [G; IN_267] = [__v_12, __v_1, __v_2, __v_3, __v_4, __v_11, __v_6, __v_7, __v_8, __v_13]; let __cu = unconstrained; if let Some(result) = record.function_queries[267].get_mut(&__args[..]) { if !__cu && *result.multiplicity == G::ZERO { aiur_fn_267(__args, record, io_buffer, false)? } else { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_267] = unsafe { *(result.output.as_ptr() as *const [G; OUT_267]) }; __ret } } else { aiur_fn_267(__args, record, io_buffer, __cu)? } }; + let __r_arr: [G; OUT_263] = { let __args: [G; IN_263] = [__v_12, __v_1, __v_2, __v_3, __v_4, __v_11, __v_6, __v_7, __v_8, __v_13]; let __cu = unconstrained; if let Some(result) = record.function_queries[263].get_mut(&__args[..]) { if !__cu && *result.multiplicity == G::ZERO { aiur_fn_263(__args, record, io_buffer, false)? } else { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_263] = unsafe { *(result.output.as_ptr() as *const [G; OUT_263]) }; __ret } } else { aiur_fn_263(__args, record, io_buffer, __cu)? } }; let __v_14: G = __r_arr[0]; let __v_15: G = __r_arr[1]; let __v_16: G = __r_arr[2]; @@ -25451,13 +25177,13 @@ fn aiur_fn_267( let __v_19: G = __r_arr[5]; let __v_20: G = __r_arr[6]; let __v_21: G = __r_arr[7]; - let __ret: [G; OUT_267] = [__v_14, __v_15, __v_16, __v_17, __v_18, __v_19, __v_20, __v_21]; - if let Some(result) = record.function_queries[267].get_mut(&inp[..]) { debug_assert_eq!(result.output, &__ret[..]); if !unconstrained { *result.multiplicity += G::ONE; } } else { record.function_queries[267].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained)); }; + let __ret: [G; OUT_263] = [__v_14, __v_15, __v_16, __v_17, __v_18, __v_19, __v_20, __v_21]; + if let Some(result) = record.function_queries[263].get_mut(&inp[..]) { debug_assert_eq!(result.output, &__ret[..]); if !unconstrained { *result.multiplicity += G::ONE; } } else { record.function_queries[263].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained)); }; return Ok(__ret); }, 5u64 => { let __v_13: G = G::from_u64(6); - let __r_arr: [G; OUT_267] = { let __args: [G; IN_267] = [__v_12, __v_1, __v_2, __v_3, __v_4, __v_5, __v_11, __v_7, __v_8, __v_13]; let __cu = unconstrained; if let Some(result) = record.function_queries[267].get_mut(&__args[..]) { if !__cu && *result.multiplicity == G::ZERO { aiur_fn_267(__args, record, io_buffer, false)? } else { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_267] = unsafe { *(result.output.as_ptr() as *const [G; OUT_267]) }; __ret } } else { aiur_fn_267(__args, record, io_buffer, __cu)? } }; + let __r_arr: [G; OUT_263] = { let __args: [G; IN_263] = [__v_12, __v_1, __v_2, __v_3, __v_4, __v_5, __v_11, __v_7, __v_8, __v_13]; let __cu = unconstrained; if let Some(result) = record.function_queries[263].get_mut(&__args[..]) { if !__cu && *result.multiplicity == G::ZERO { aiur_fn_263(__args, record, io_buffer, false)? } else { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_263] = unsafe { *(result.output.as_ptr() as *const [G; OUT_263]) }; __ret } } else { aiur_fn_263(__args, record, io_buffer, __cu)? } }; let __v_14: G = __r_arr[0]; let __v_15: G = __r_arr[1]; let __v_16: G = __r_arr[2]; @@ -25466,13 +25192,13 @@ fn aiur_fn_267( let __v_19: G = __r_arr[5]; let __v_20: G = __r_arr[6]; let __v_21: G = __r_arr[7]; - let __ret: [G; OUT_267] = [__v_14, __v_15, __v_16, __v_17, __v_18, __v_19, __v_20, __v_21]; - if let Some(result) = record.function_queries[267].get_mut(&inp[..]) { debug_assert_eq!(result.output, &__ret[..]); if !unconstrained { *result.multiplicity += G::ONE; } } else { record.function_queries[267].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained)); }; + let __ret: [G; OUT_263] = [__v_14, __v_15, __v_16, __v_17, __v_18, __v_19, __v_20, __v_21]; + if let Some(result) = record.function_queries[263].get_mut(&inp[..]) { debug_assert_eq!(result.output, &__ret[..]); if !unconstrained { *result.multiplicity += G::ONE; } } else { record.function_queries[263].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained)); }; return Ok(__ret); }, 6u64 => { let __v_13: G = G::from_u64(7); - let __r_arr: [G; OUT_267] = { let __args: [G; IN_267] = [__v_12, __v_1, __v_2, __v_3, __v_4, __v_5, __v_6, __v_11, __v_8, __v_13]; let __cu = unconstrained; if let Some(result) = record.function_queries[267].get_mut(&__args[..]) { if !__cu && *result.multiplicity == G::ZERO { aiur_fn_267(__args, record, io_buffer, false)? } else { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_267] = unsafe { *(result.output.as_ptr() as *const [G; OUT_267]) }; __ret } } else { aiur_fn_267(__args, record, io_buffer, __cu)? } }; + let __r_arr: [G; OUT_263] = { let __args: [G; IN_263] = [__v_12, __v_1, __v_2, __v_3, __v_4, __v_5, __v_6, __v_11, __v_8, __v_13]; let __cu = unconstrained; if let Some(result) = record.function_queries[263].get_mut(&__args[..]) { if !__cu && *result.multiplicity == G::ZERO { aiur_fn_263(__args, record, io_buffer, false)? } else { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_263] = unsafe { *(result.output.as_ptr() as *const [G; OUT_263]) }; __ret } } else { aiur_fn_263(__args, record, io_buffer, __cu)? } }; let __v_14: G = __r_arr[0]; let __v_15: G = __r_arr[1]; let __v_16: G = __r_arr[2]; @@ -25481,13 +25207,13 @@ fn aiur_fn_267( let __v_19: G = __r_arr[5]; let __v_20: G = __r_arr[6]; let __v_21: G = __r_arr[7]; - let __ret: [G; OUT_267] = [__v_14, __v_15, __v_16, __v_17, __v_18, __v_19, __v_20, __v_21]; - if let Some(result) = record.function_queries[267].get_mut(&inp[..]) { debug_assert_eq!(result.output, &__ret[..]); if !unconstrained { *result.multiplicity += G::ONE; } } else { record.function_queries[267].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained)); }; + let __ret: [G; OUT_263] = [__v_14, __v_15, __v_16, __v_17, __v_18, __v_19, __v_20, __v_21]; + if let Some(result) = record.function_queries[263].get_mut(&inp[..]) { debug_assert_eq!(result.output, &__ret[..]); if !unconstrained { *result.multiplicity += G::ONE; } } else { record.function_queries[263].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained)); }; return Ok(__ret); }, _ => { let __v_13: G = G::from_u64(8); - let __r_arr: [G; OUT_267] = { let __args: [G; IN_267] = [__v_12, __v_1, __v_2, __v_3, __v_4, __v_5, __v_6, __v_7, __v_11, __v_13]; let __cu = unconstrained; if let Some(result) = record.function_queries[267].get_mut(&__args[..]) { if !__cu && *result.multiplicity == G::ZERO { aiur_fn_267(__args, record, io_buffer, false)? } else { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_267] = unsafe { *(result.output.as_ptr() as *const [G; OUT_267]) }; __ret } } else { aiur_fn_267(__args, record, io_buffer, __cu)? } }; + let __r_arr: [G; OUT_263] = { let __args: [G; IN_263] = [__v_12, __v_1, __v_2, __v_3, __v_4, __v_5, __v_6, __v_7, __v_11, __v_13]; let __cu = unconstrained; if let Some(result) = record.function_queries[263].get_mut(&__args[..]) { if !__cu && *result.multiplicity == G::ZERO { aiur_fn_263(__args, record, io_buffer, false)? } else { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_263] = unsafe { *(result.output.as_ptr() as *const [G; OUT_263]) }; __ret } } else { aiur_fn_263(__args, record, io_buffer, __cu)? } }; let __v_14: G = __r_arr[0]; let __v_15: G = __r_arr[1]; let __v_16: G = __r_arr[2]; @@ -25496,8 +25222,8 @@ fn aiur_fn_267( let __v_19: G = __r_arr[5]; let __v_20: G = __r_arr[6]; let __v_21: G = __r_arr[7]; - let __ret: [G; OUT_267] = [__v_14, __v_15, __v_16, __v_17, __v_18, __v_19, __v_20, __v_21]; - if let Some(result) = record.function_queries[267].get_mut(&inp[..]) { debug_assert_eq!(result.output, &__ret[..]); if !unconstrained { *result.multiplicity += G::ONE; } } else { record.function_queries[267].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained)); }; + let __ret: [G; OUT_263] = [__v_14, __v_15, __v_16, __v_17, __v_18, __v_19, __v_20, __v_21]; + if let Some(result) = record.function_queries[263].get_mut(&inp[..]) { debug_assert_eq!(result.output, &__ret[..]); if !unconstrained { *result.multiplicity += G::ONE; } } else { record.function_queries[263].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained)); }; return Ok(__ret); }, } @@ -25511,22 +25237,22 @@ fn aiur_fn_267( }) } -const INPUT_SIZE_268: usize = 2; -const IN_268: usize = 2; -const OUT_268: usize = 1; -fn aiur_fn_268( - inp: [G; IN_268], +const INPUT_SIZE_264: usize = 2; +const IN_264: usize = 2; +const OUT_264: usize = 1; +fn aiur_fn_264( + inp: [G; IN_264], record: &mut QueryRecord, io_buffer: &mut IOBuffer, unconstrained: bool, -) -> Result<[G; OUT_268], ExecError> { +) -> Result<[G; OUT_264], ExecError> { stacker::maybe_grow(64 * 1024, 4 * 1024 * 1024, || { let __v_0: G = inp[0]; let __v_1: G = inp[1]; match __v_1.as_canonical_u64() { 0u64 => { - let __ret: [G; OUT_268] = [__v_0]; - if let Some(result) = record.function_queries[268].get_mut(&inp[..]) { debug_assert_eq!(result.output, &__ret[..]); if !unconstrained { *result.multiplicity += G::ONE; } } else { record.function_queries[268].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained)); }; + let __ret: [G; OUT_264] = [__v_0]; + if let Some(result) = record.function_queries[264].get_mut(&inp[..]) { debug_assert_eq!(result.output, &__ret[..]); if !unconstrained { *result.multiplicity += G::ONE; } } else { record.function_queries[264].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained)); }; return Ok(__ret); }, _ => { @@ -25539,17 +25265,17 @@ fn aiur_fn_268( let __v_5: G = G::from_u64(1); let __v_6: G = G::from_u64(1); let __v_7: G = { let __values: [G; 3] = [__v_5, __v_6, __v_6]; let __mq = record.memory_queries.get_mut(&3).ok_or(ExecError::InvalidMemorySize(3))?; if let Some(result) = __mq.get_mut(&__values[..]) { if !unconstrained { *result.multiplicity += G::ONE; } result.output[0] } else { let __ptr = G::from_usize(__mq.len()); __mq.insert(&__values[..], &[__ptr], G::from_bool(!unconstrained)); __ptr } }; - let __ret: [G; OUT_268] = [__v_7]; - if let Some(result) = record.function_queries[268].get_mut(&inp[..]) { debug_assert_eq!(result.output, &__ret[..]); if !unconstrained { *result.multiplicity += G::ONE; } } else { record.function_queries[268].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained)); }; + let __ret: [G; OUT_264] = [__v_7]; + if let Some(result) = record.function_queries[264].get_mut(&inp[..]) { debug_assert_eq!(result.output, &__ret[..]); if !unconstrained { *result.multiplicity += G::ONE; } } else { record.function_queries[264].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained)); }; return Ok(__ret); }, 0u64 => { let __v_5: G = G::from_u64(1); let __v_6: G = (__v_1 - __v_5); - let __r_arr: [G; OUT_268] = { let __args: [G; IN_268] = [__v_4, __v_6]; let __cu = unconstrained; if let Some(result) = record.function_queries[268].get_mut(&__args[..]) { if !__cu && *result.multiplicity == G::ZERO { aiur_fn_268(__args, record, io_buffer, false)? } else { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_268] = unsafe { *(result.output.as_ptr() as *const [G; OUT_268]) }; __ret } } else { aiur_fn_268(__args, record, io_buffer, __cu)? } }; + let __r_arr: [G; OUT_264] = { let __args: [G; IN_264] = [__v_4, __v_6]; let __cu = unconstrained; if let Some(result) = record.function_queries[264].get_mut(&__args[..]) { if !__cu && *result.multiplicity == G::ZERO { aiur_fn_264(__args, record, io_buffer, false)? } else { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_264] = unsafe { *(result.output.as_ptr() as *const [G; OUT_264]) }; __ret } } else { aiur_fn_264(__args, record, io_buffer, __cu)? } }; let __v_7: G = __r_arr[0]; - let __ret: [G; OUT_268] = [__v_7]; - if let Some(result) = record.function_queries[268].get_mut(&inp[..]) { debug_assert_eq!(result.output, &__ret[..]); if !unconstrained { *result.multiplicity += G::ONE; } } else { record.function_queries[268].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained)); }; + let __ret: [G; OUT_264] = [__v_7]; + if let Some(result) = record.function_queries[264].get_mut(&inp[..]) { debug_assert_eq!(result.output, &__ret[..]); if !unconstrained { *result.multiplicity += G::ONE; } } else { record.function_queries[264].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained)); }; return Ok(__ret); }, _ => { @@ -25561,15 +25287,15 @@ fn aiur_fn_268( }) } -const INPUT_SIZE_269: usize = 1; -const IN_269: usize = 1; -const OUT_269: usize = 1; -fn aiur_fn_269( - inp: [G; IN_269], +const INPUT_SIZE_265: usize = 1; +const IN_265: usize = 1; +const OUT_265: usize = 1; +fn aiur_fn_265( + inp: [G; IN_265], record: &mut QueryRecord, io_buffer: &mut IOBuffer, unconstrained: bool, -) -> Result<[G; OUT_269], ExecError> { +) -> Result<[G; OUT_265], ExecError> { stacker::maybe_grow(64 * 1024, 4 * 1024 * 1024, || { let __v_0: G = inp[0]; let __v_1: G = G::from_u64(0); @@ -25581,7 +25307,7 @@ fn aiur_fn_269( let __v_7: G = G::from_u64(0); let __v_8: G = G::from_u64(0); let __v_9: G = G::from_u64(0); - let __r_arr: [G; OUT_267] = { let __args: [G; IN_267] = [__v_0, __v_1, __v_2, __v_3, __v_4, __v_5, __v_6, __v_7, __v_8, __v_9]; let __cu = unconstrained; if let Some(result) = record.function_queries[267].get_mut(&__args[..]) { if !__cu && *result.multiplicity == G::ZERO { aiur_fn_267(__args, record, io_buffer, false)? } else { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_267] = unsafe { *(result.output.as_ptr() as *const [G; OUT_267]) }; __ret } } else { aiur_fn_267(__args, record, io_buffer, __cu)? } }; + let __r_arr: [G; OUT_263] = { let __args: [G; IN_263] = [__v_0, __v_1, __v_2, __v_3, __v_4, __v_5, __v_6, __v_7, __v_8, __v_9]; let __cu = unconstrained; if let Some(result) = record.function_queries[263].get_mut(&__args[..]) { if !__cu && *result.multiplicity == G::ZERO { aiur_fn_263(__args, record, io_buffer, false)? } else { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_263] = unsafe { *(result.output.as_ptr() as *const [G; OUT_263]) }; __ret } } else { aiur_fn_263(__args, record, io_buffer, __cu)? } }; let __v_10: G = __r_arr[0]; let __v_11: G = __r_arr[1]; let __v_12: G = __r_arr[2]; @@ -25591,7 +25317,7 @@ fn aiur_fn_269( let __v_16: G = __r_arr[6]; let __v_17: G = __r_arr[7]; let __v_18: G = G::from_u64(8); - let __r_arr: [G; OUT_268] = { let __args: [G; IN_268] = [__v_0, __v_18]; let __cu = unconstrained; if let Some(result) = record.function_queries[268].get_mut(&__args[..]) { if !__cu && *result.multiplicity == G::ZERO { aiur_fn_268(__args, record, io_buffer, false)? } else { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_268] = unsafe { *(result.output.as_ptr() as *const [G; OUT_268]) }; __ret } } else { aiur_fn_268(__args, record, io_buffer, __cu)? } }; + let __r_arr: [G; OUT_264] = { let __args: [G; IN_264] = [__v_0, __v_18]; let __cu = unconstrained; if let Some(result) = record.function_queries[264].get_mut(&__args[..]) { if !__cu && *result.multiplicity == G::ZERO { aiur_fn_264(__args, record, io_buffer, false)? } else { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_264] = unsafe { *(result.output.as_ptr() as *const [G; OUT_264]) }; __ret } } else { aiur_fn_264(__args, record, io_buffer, __cu)? } }; let __v_19: G = __r_arr[0]; let __loaded: [G; 3] = { let __mq = record.memory_queries.get_mut(&3).ok_or(ExecError::InvalidMemorySize(3))?; let __ptr_u64 = __v_19.as_canonical_u64(); let __ptr_usize = usize::try_from(__ptr_u64).ok().ok_or(ExecError::PointerTooLarge(__ptr_u64))?; let (__args, __mult) = __mq.get_index_mut(__ptr_usize).ok_or(ExecError::UnboundPointer { ptr: __ptr_u64, size: 3 })?; if !unconstrained { *__mult += G::ONE; } let __arr: [G; 3] = __args[..3].try_into().unwrap(); __arr }; let __v_20: G = __loaded[0]; @@ -25605,7 +25331,7 @@ fn aiur_fn_269( break '__mc_0 [__v_25]; }, _ => { - let __r_arr: [G; OUT_269] = { let __args: [G; IN_269] = [__v_19]; let __cu = unconstrained; if let Some(result) = record.function_queries[269].get_mut(&__args[..]) { if !__cu && *result.multiplicity == G::ZERO { aiur_fn_269(__args, record, io_buffer, false)? } else { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_269] = unsafe { *(result.output.as_ptr() as *const [G; OUT_269]) }; __ret } } else { aiur_fn_269(__args, record, io_buffer, __cu)? } }; + let __r_arr: [G; OUT_265] = { let __args: [G; IN_265] = [__v_19]; let __cu = unconstrained; if let Some(result) = record.function_queries[265].get_mut(&__args[..]) { if !__cu && *result.multiplicity == G::ZERO { aiur_fn_265(__args, record, io_buffer, false)? } else { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_265] = unsafe { *(result.output.as_ptr() as *const [G; OUT_265]) }; __ret } } else { aiur_fn_265(__args, record, io_buffer, __cu)? } }; let __v_23: G = __r_arr[0]; break '__mc_0 [__v_23]; }, @@ -25632,8 +25358,8 @@ fn aiur_fn_269( let __v_35: G = G::from_u64(1); let __v_36: G = G::from_u64(1); let __v_37: G = { let __values: [G; 10] = [__v_35, __v_36, __v_36, __v_36, __v_36, __v_36, __v_36, __v_36, __v_36, __v_36]; let __mq = record.memory_queries.get_mut(&10).ok_or(ExecError::InvalidMemorySize(10))?; if let Some(result) = __mq.get_mut(&__values[..]) { if !unconstrained { *result.multiplicity += G::ONE; } result.output[0] } else { let __ptr = G::from_usize(__mq.len()); __mq.insert(&__values[..], &[__ptr], G::from_bool(!unconstrained)); __ptr } }; - let __ret: [G; OUT_269] = [__v_37]; - if let Some(result) = record.function_queries[269].get_mut(&inp[..]) { debug_assert_eq!(result.output, &__ret[..]); if !unconstrained { *result.multiplicity += G::ONE; } } else { record.function_queries[269].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained)); }; + let __ret: [G; OUT_265] = [__v_37]; + if let Some(result) = record.function_queries[265].get_mut(&inp[..]) { debug_assert_eq!(result.output, &__ret[..]); if !unconstrained { *result.multiplicity += G::ONE; } } else { record.function_queries[265].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained)); }; return Ok(__ret); }, 0u64 => { @@ -25642,8 +25368,8 @@ fn aiur_fn_269( let __v_37: G = G::from_u64(1); let __v_38: G = { let __values: [G; 10] = [__v_36, __v_37, __v_37, __v_37, __v_37, __v_37, __v_37, __v_37, __v_37, __v_37]; let __mq = record.memory_queries.get_mut(&10).ok_or(ExecError::InvalidMemorySize(10))?; if let Some(result) = __mq.get_mut(&__values[..]) { if !unconstrained { *result.multiplicity += G::ONE; } result.output[0] } else { let __ptr = G::from_usize(__mq.len()); __mq.insert(&__values[..], &[__ptr], G::from_bool(!unconstrained)); __ptr } }; let __v_39: G = { let __values: [G; 10] = [__v_35, __v_10, __v_11, __v_12, __v_13, __v_14, __v_15, __v_16, __v_17, __v_38]; let __mq = record.memory_queries.get_mut(&10).ok_or(ExecError::InvalidMemorySize(10))?; if let Some(result) = __mq.get_mut(&__values[..]) { if !unconstrained { *result.multiplicity += G::ONE; } result.output[0] } else { let __ptr = G::from_usize(__mq.len()); __mq.insert(&__values[..], &[__ptr], G::from_bool(!unconstrained)); __ptr } }; - let __ret: [G; OUT_269] = [__v_39]; - if let Some(result) = record.function_queries[269].get_mut(&inp[..]) { debug_assert_eq!(result.output, &__ret[..]); if !unconstrained { *result.multiplicity += G::ONE; } } else { record.function_queries[269].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained)); }; + let __ret: [G; OUT_265] = [__v_39]; + if let Some(result) = record.function_queries[265].get_mut(&inp[..]) { debug_assert_eq!(result.output, &__ret[..]); if !unconstrained { *result.multiplicity += G::ONE; } } else { record.function_queries[265].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained)); }; return Ok(__ret); }, _ => { @@ -25654,23 +25380,23 @@ fn aiur_fn_269( _ => { let __v_34: G = G::from_u64(0); let __v_35: G = { let __values: [G; 10] = [__v_34, __v_10, __v_11, __v_12, __v_13, __v_14, __v_15, __v_16, __v_17, __v_23]; let __mq = record.memory_queries.get_mut(&10).ok_or(ExecError::InvalidMemorySize(10))?; if let Some(result) = __mq.get_mut(&__values[..]) { if !unconstrained { *result.multiplicity += G::ONE; } result.output[0] } else { let __ptr = G::from_usize(__mq.len()); __mq.insert(&__values[..], &[__ptr], G::from_bool(!unconstrained)); __ptr } }; - let __ret: [G; OUT_269] = [__v_35]; - if let Some(result) = record.function_queries[269].get_mut(&inp[..]) { debug_assert_eq!(result.output, &__ret[..]); if !unconstrained { *result.multiplicity += G::ONE; } } else { record.function_queries[269].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained)); }; + let __ret: [G; OUT_265] = [__v_35]; + if let Some(result) = record.function_queries[265].get_mut(&inp[..]) { debug_assert_eq!(result.output, &__ret[..]); if !unconstrained { *result.multiplicity += G::ONE; } } else { record.function_queries[265].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained)); }; return Ok(__ret); }, } }) } -const INPUT_SIZE_270: usize = 1; -const IN_270: usize = 1; -const OUT_270: usize = 1; -fn aiur_fn_270( - inp: [G; IN_270], +const INPUT_SIZE_266: usize = 1; +const IN_266: usize = 1; +const OUT_266: usize = 1; +fn aiur_fn_266( + inp: [G; IN_266], record: &mut QueryRecord, io_buffer: &mut IOBuffer, unconstrained: bool, -) -> Result<[G; OUT_270], ExecError> { +) -> Result<[G; OUT_266], ExecError> { stacker::maybe_grow(64 * 1024, 4 * 1024 * 1024, || { let __v_0: G = inp[0]; let __loaded: [G; 9] = { let __mq = record.memory_queries.get_mut(&9).ok_or(ExecError::InvalidMemorySize(9))?; let __ptr_u64 = __v_0.as_canonical_u64(); let __ptr_usize = usize::try_from(__ptr_u64).ok().ok_or(ExecError::PointerTooLarge(__ptr_u64))?; let (__args, __mult) = __mq.get_index_mut(__ptr_usize).ok_or(ExecError::UnboundPointer { ptr: __ptr_u64, size: 9 })?; if !unconstrained { *__mult += G::ONE; } let __arr: [G; 9] = __args[..9].try_into().unwrap(); __arr }; @@ -25688,40 +25414,40 @@ fn aiur_fn_270( let __v_10: G = G::from_u64(0); let __v_11: G = G::from_u64(0); let __v_12: G = { let __values: [G; 3] = [__v_10, __v_11, __v_11]; let __mq = record.memory_queries.get_mut(&3).ok_or(ExecError::InvalidMemorySize(3))?; if let Some(result) = __mq.get_mut(&__values[..]) { if !unconstrained { *result.multiplicity += G::ONE; } result.output[0] } else { let __ptr = G::from_usize(__mq.len()); __mq.insert(&__values[..], &[__ptr], G::from_bool(!unconstrained)); __ptr } }; - let __ret: [G; OUT_270] = [__v_12]; - if let Some(result) = record.function_queries[270].get_mut(&inp[..]) { debug_assert_eq!(result.output, &__ret[..]); if !unconstrained { *result.multiplicity += G::ONE; } } else { record.function_queries[270].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained)); }; + let __ret: [G; OUT_266] = [__v_12]; + if let Some(result) = record.function_queries[266].get_mut(&inp[..]) { debug_assert_eq!(result.output, &__ret[..]); if !unconstrained { *result.multiplicity += G::ONE; } } else { record.function_queries[266].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained)); }; return Ok(__ret); }, 1u64 => { let __v_10: G = G::from_u64(1); - let __r_arr: [G; OUT_270] = { let __args: [G; IN_270] = [__v_2]; let __cu = unconstrained; if let Some(result) = record.function_queries[270].get_mut(&__args[..]) { if !__cu && *result.multiplicity == G::ZERO { aiur_fn_270(__args, record, io_buffer, false)? } else { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_270] = unsafe { *(result.output.as_ptr() as *const [G; OUT_270]) }; __ret } } else { aiur_fn_270(__args, record, io_buffer, __cu)? } }; + let __r_arr: [G; OUT_266] = { let __args: [G; IN_266] = [__v_2]; let __cu = unconstrained; if let Some(result) = record.function_queries[266].get_mut(&__args[..]) { if !__cu && *result.multiplicity == G::ZERO { aiur_fn_266(__args, record, io_buffer, false)? } else { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_266] = unsafe { *(result.output.as_ptr() as *const [G; OUT_266]) }; __ret } } else { aiur_fn_266(__args, record, io_buffer, __cu)? } }; let __v_11: G = __r_arr[0]; let __v_12: G = G::from_u64(0); let __v_13: G = { let __values: [G; 3] = [__v_10, __v_11, __v_12]; let __mq = record.memory_queries.get_mut(&3).ok_or(ExecError::InvalidMemorySize(3))?; if let Some(result) = __mq.get_mut(&__values[..]) { if !unconstrained { *result.multiplicity += G::ONE; } result.output[0] } else { let __ptr = G::from_usize(__mq.len()); __mq.insert(&__values[..], &[__ptr], G::from_bool(!unconstrained)); __ptr } }; - let __ret: [G; OUT_270] = [__v_13]; - if let Some(result) = record.function_queries[270].get_mut(&inp[..]) { debug_assert_eq!(result.output, &__ret[..]); if !unconstrained { *result.multiplicity += G::ONE; } } else { record.function_queries[270].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained)); }; + let __ret: [G; OUT_266] = [__v_13]; + if let Some(result) = record.function_queries[266].get_mut(&inp[..]) { debug_assert_eq!(result.output, &__ret[..]); if !unconstrained { *result.multiplicity += G::ONE; } } else { record.function_queries[266].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained)); }; return Ok(__ret); }, 2u64 => { let __v_10: G = G::from_u64(2); - let __r_arr: [G; OUT_270] = { let __args: [G; IN_270] = [__v_2]; let __cu = unconstrained; if let Some(result) = record.function_queries[270].get_mut(&__args[..]) { if !__cu && *result.multiplicity == G::ZERO { aiur_fn_270(__args, record, io_buffer, false)? } else { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_270] = unsafe { *(result.output.as_ptr() as *const [G; OUT_270]) }; __ret } } else { aiur_fn_270(__args, record, io_buffer, __cu)? } }; + let __r_arr: [G; OUT_266] = { let __args: [G; IN_266] = [__v_2]; let __cu = unconstrained; if let Some(result) = record.function_queries[266].get_mut(&__args[..]) { if !__cu && *result.multiplicity == G::ZERO { aiur_fn_266(__args, record, io_buffer, false)? } else { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_266] = unsafe { *(result.output.as_ptr() as *const [G; OUT_266]) }; __ret } } else { aiur_fn_266(__args, record, io_buffer, __cu)? } }; let __v_11: G = __r_arr[0]; - let __r_arr: [G; OUT_270] = { let __args: [G; IN_270] = [__v_3]; let __cu = unconstrained; if let Some(result) = record.function_queries[270].get_mut(&__args[..]) { if !__cu && *result.multiplicity == G::ZERO { aiur_fn_270(__args, record, io_buffer, false)? } else { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_270] = unsafe { *(result.output.as_ptr() as *const [G; OUT_270]) }; __ret } } else { aiur_fn_270(__args, record, io_buffer, __cu)? } }; + let __r_arr: [G; OUT_266] = { let __args: [G; IN_266] = [__v_3]; let __cu = unconstrained; if let Some(result) = record.function_queries[266].get_mut(&__args[..]) { if !__cu && *result.multiplicity == G::ZERO { aiur_fn_266(__args, record, io_buffer, false)? } else { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_266] = unsafe { *(result.output.as_ptr() as *const [G; OUT_266]) }; __ret } } else { aiur_fn_266(__args, record, io_buffer, __cu)? } }; let __v_12: G = __r_arr[0]; let __v_13: G = { let __values: [G; 3] = [__v_10, __v_11, __v_12]; let __mq = record.memory_queries.get_mut(&3).ok_or(ExecError::InvalidMemorySize(3))?; if let Some(result) = __mq.get_mut(&__values[..]) { if !unconstrained { *result.multiplicity += G::ONE; } result.output[0] } else { let __ptr = G::from_usize(__mq.len()); __mq.insert(&__values[..], &[__ptr], G::from_bool(!unconstrained)); __ptr } }; - let __ret: [G; OUT_270] = [__v_13]; - if let Some(result) = record.function_queries[270].get_mut(&inp[..]) { debug_assert_eq!(result.output, &__ret[..]); if !unconstrained { *result.multiplicity += G::ONE; } } else { record.function_queries[270].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained)); }; + let __ret: [G; OUT_266] = [__v_13]; + if let Some(result) = record.function_queries[266].get_mut(&inp[..]) { debug_assert_eq!(result.output, &__ret[..]); if !unconstrained { *result.multiplicity += G::ONE; } } else { record.function_queries[266].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained)); }; return Ok(__ret); }, 3u64 => { let __v_10: G = G::from_u64(3); - let __r_arr: [G; OUT_270] = { let __args: [G; IN_270] = [__v_2]; let __cu = unconstrained; if let Some(result) = record.function_queries[270].get_mut(&__args[..]) { if !__cu && *result.multiplicity == G::ZERO { aiur_fn_270(__args, record, io_buffer, false)? } else { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_270] = unsafe { *(result.output.as_ptr() as *const [G; OUT_270]) }; __ret } } else { aiur_fn_270(__args, record, io_buffer, __cu)? } }; + let __r_arr: [G; OUT_266] = { let __args: [G; IN_266] = [__v_2]; let __cu = unconstrained; if let Some(result) = record.function_queries[266].get_mut(&__args[..]) { if !__cu && *result.multiplicity == G::ZERO { aiur_fn_266(__args, record, io_buffer, false)? } else { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_266] = unsafe { *(result.output.as_ptr() as *const [G; OUT_266]) }; __ret } } else { aiur_fn_266(__args, record, io_buffer, __cu)? } }; let __v_11: G = __r_arr[0]; - let __r_arr: [G; OUT_270] = { let __args: [G; IN_270] = [__v_3]; let __cu = unconstrained; if let Some(result) = record.function_queries[270].get_mut(&__args[..]) { if !__cu && *result.multiplicity == G::ZERO { aiur_fn_270(__args, record, io_buffer, false)? } else { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_270] = unsafe { *(result.output.as_ptr() as *const [G; OUT_270]) }; __ret } } else { aiur_fn_270(__args, record, io_buffer, __cu)? } }; + let __r_arr: [G; OUT_266] = { let __args: [G; IN_266] = [__v_3]; let __cu = unconstrained; if let Some(result) = record.function_queries[266].get_mut(&__args[..]) { if !__cu && *result.multiplicity == G::ZERO { aiur_fn_266(__args, record, io_buffer, false)? } else { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_266] = unsafe { *(result.output.as_ptr() as *const [G; OUT_266]) }; __ret } } else { aiur_fn_266(__args, record, io_buffer, __cu)? } }; let __v_12: G = __r_arr[0]; let __v_13: G = { let __values: [G; 3] = [__v_10, __v_11, __v_12]; let __mq = record.memory_queries.get_mut(&3).ok_or(ExecError::InvalidMemorySize(3))?; if let Some(result) = __mq.get_mut(&__values[..]) { if !unconstrained { *result.multiplicity += G::ONE; } result.output[0] } else { let __ptr = G::from_usize(__mq.len()); __mq.insert(&__values[..], &[__ptr], G::from_bool(!unconstrained)); __ptr } }; - let __ret: [G; OUT_270] = [__v_13]; - if let Some(result) = record.function_queries[270].get_mut(&inp[..]) { debug_assert_eq!(result.output, &__ret[..]); if !unconstrained { *result.multiplicity += G::ONE; } } else { record.function_queries[270].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained)); }; + let __ret: [G; OUT_266] = [__v_13]; + if let Some(result) = record.function_queries[266].get_mut(&inp[..]) { debug_assert_eq!(result.output, &__ret[..]); if !unconstrained { *result.multiplicity += G::ONE; } } else { record.function_queries[266].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained)); }; return Ok(__ret); }, 4u64 => { @@ -25730,8 +25456,8 @@ fn aiur_fn_270( let __v_11: G = __r_arr[0]; let __v_12: G = G::from_u64(0); let __v_13: G = { let __values: [G; 3] = [__v_10, __v_11, __v_12]; let __mq = record.memory_queries.get_mut(&3).ok_or(ExecError::InvalidMemorySize(3))?; if let Some(result) = __mq.get_mut(&__values[..]) { if !unconstrained { *result.multiplicity += G::ONE; } result.output[0] } else { let __ptr = G::from_usize(__mq.len()); __mq.insert(&__values[..], &[__ptr], G::from_bool(!unconstrained)); __ptr } }; - let __ret: [G; OUT_270] = [__v_13]; - if let Some(result) = record.function_queries[270].get_mut(&inp[..]) { debug_assert_eq!(result.output, &__ret[..]); if !unconstrained { *result.multiplicity += G::ONE; } } else { record.function_queries[270].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained)); }; + let __ret: [G; OUT_266] = [__v_13]; + if let Some(result) = record.function_queries[266].get_mut(&inp[..]) { debug_assert_eq!(result.output, &__ret[..]); if !unconstrained { *result.multiplicity += G::ONE; } } else { record.function_queries[266].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained)); }; return Ok(__ret); }, _ => { @@ -25741,15 +25467,15 @@ fn aiur_fn_270( }) } -const INPUT_SIZE_271: usize = 2; -const IN_271: usize = 2; -const OUT_271: usize = 1; -fn aiur_fn_271( - inp: [G; IN_271], +const INPUT_SIZE_267: usize = 2; +const IN_267: usize = 2; +const OUT_267: usize = 1; +fn aiur_fn_267( + inp: [G; IN_267], record: &mut QueryRecord, io_buffer: &mut IOBuffer, unconstrained: bool, -) -> Result<[G; OUT_271], ExecError> { +) -> Result<[G; OUT_267], ExecError> { stacker::maybe_grow(64 * 1024, 4 * 1024 * 1024, || { let __v_0: G = inp[0]; let __v_1: G = inp[1]; @@ -25769,23 +25495,23 @@ fn aiur_fn_271( let __v_12: G = G::from_u64(1); let __v_13: G = G::from_u64(1); let __v_14: G = { let __values: [G; 3] = [__v_12, __v_13, __v_13]; let __mq = record.memory_queries.get_mut(&3).ok_or(ExecError::InvalidMemorySize(3))?; if let Some(result) = __mq.get_mut(&__values[..]) { if !unconstrained { *result.multiplicity += G::ONE; } result.output[0] } else { let __ptr = G::from_usize(__mq.len()); __mq.insert(&__values[..], &[__ptr], G::from_bool(!unconstrained)); __ptr } }; - let __ret: [G; OUT_271] = [__v_14]; - if let Some(result) = record.function_queries[271].get_mut(&inp[..]) { debug_assert_eq!(result.output, &__ret[..]); if !unconstrained { *result.multiplicity += G::ONE; } } else { record.function_queries[271].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained)); }; + let __ret: [G; OUT_267] = [__v_14]; + if let Some(result) = record.function_queries[267].get_mut(&inp[..]) { debug_assert_eq!(result.output, &__ret[..]); if !unconstrained { *result.multiplicity += G::ONE; } } else { record.function_queries[267].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained)); }; return Ok(__ret); }, 0u64 => { let __r_arr: [G; OUT_16] = { let __args: [G; IN_16] = [__v_3, __v_4, __v_5, __v_6, __v_7, __v_8, __v_9, __v_10]; let __cu = unconstrained; if let Some(result) = record.function_queries[16].get_mut(&__args[..]) { if !__cu && *result.multiplicity == G::ZERO { aiur_fn_16(__args, record, io_buffer, false)? } else { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_16] = unsafe { *(result.output.as_ptr() as *const [G; OUT_16]) }; __ret } } else { aiur_fn_16(__args, record, io_buffer, __cu)? } }; let __v_12: G = __r_arr[0]; - let __r_arr: [G; OUT_766] = { let __args: [G; IN_766] = [__v_1, __v_12]; let __cu = unconstrained; if let Some(result) = record.function_queries[766].get_mut(&__args[..]) { if !__cu && *result.multiplicity == G::ZERO { aiur_fn_766(__args, record, io_buffer, false)? } else { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_766] = unsafe { *(result.output.as_ptr() as *const [G; OUT_766]) }; __ret } } else { aiur_fn_766(__args, record, io_buffer, __cu)? } }; + let __r_arr: [G; OUT_762] = { let __args: [G; IN_762] = [__v_1, __v_12]; let __cu = unconstrained; if let Some(result) = record.function_queries[762].get_mut(&__args[..]) { if !__cu && *result.multiplicity == G::ZERO { aiur_fn_762(__args, record, io_buffer, false)? } else { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_762] = unsafe { *(result.output.as_ptr() as *const [G; OUT_762]) }; __ret } } else { aiur_fn_762(__args, record, io_buffer, __cu)? } }; let __v_13: G = __r_arr[0]; let __v_14: G = G::from_u64(0); - let __r_arr: [G; OUT_270] = { let __args: [G; IN_270] = [__v_13]; let __cu = unconstrained; if let Some(result) = record.function_queries[270].get_mut(&__args[..]) { if !__cu && *result.multiplicity == G::ZERO { aiur_fn_270(__args, record, io_buffer, false)? } else { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_270] = unsafe { *(result.output.as_ptr() as *const [G; OUT_270]) }; __ret } } else { aiur_fn_270(__args, record, io_buffer, __cu)? } }; + let __r_arr: [G; OUT_266] = { let __args: [G; IN_266] = [__v_13]; let __cu = unconstrained; if let Some(result) = record.function_queries[266].get_mut(&__args[..]) { if !__cu && *result.multiplicity == G::ZERO { aiur_fn_266(__args, record, io_buffer, false)? } else { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_266] = unsafe { *(result.output.as_ptr() as *const [G; OUT_266]) }; __ret } } else { aiur_fn_266(__args, record, io_buffer, __cu)? } }; let __v_15: G = __r_arr[0]; - let __r_arr: [G; OUT_271] = { let __args: [G; IN_271] = [__v_11, __v_1]; let __cu = unconstrained; if let Some(result) = record.function_queries[271].get_mut(&__args[..]) { if !__cu && *result.multiplicity == G::ZERO { aiur_fn_271(__args, record, io_buffer, false)? } else { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_271] = unsafe { *(result.output.as_ptr() as *const [G; OUT_271]) }; __ret } } else { aiur_fn_271(__args, record, io_buffer, __cu)? } }; + let __r_arr: [G; OUT_267] = { let __args: [G; IN_267] = [__v_11, __v_1]; let __cu = unconstrained; if let Some(result) = record.function_queries[267].get_mut(&__args[..]) { if !__cu && *result.multiplicity == G::ZERO { aiur_fn_267(__args, record, io_buffer, false)? } else { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_267] = unsafe { *(result.output.as_ptr() as *const [G; OUT_267]) }; __ret } } else { aiur_fn_267(__args, record, io_buffer, __cu)? } }; let __v_16: G = __r_arr[0]; let __v_17: G = { let __values: [G; 3] = [__v_14, __v_15, __v_16]; let __mq = record.memory_queries.get_mut(&3).ok_or(ExecError::InvalidMemorySize(3))?; if let Some(result) = __mq.get_mut(&__values[..]) { if !unconstrained { *result.multiplicity += G::ONE; } result.output[0] } else { let __ptr = G::from_usize(__mq.len()); __mq.insert(&__values[..], &[__ptr], G::from_bool(!unconstrained)); __ptr } }; - let __ret: [G; OUT_271] = [__v_17]; - if let Some(result) = record.function_queries[271].get_mut(&inp[..]) { debug_assert_eq!(result.output, &__ret[..]); if !unconstrained { *result.multiplicity += G::ONE; } } else { record.function_queries[271].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained)); }; + let __ret: [G; OUT_267] = [__v_17]; + if let Some(result) = record.function_queries[267].get_mut(&inp[..]) { debug_assert_eq!(result.output, &__ret[..]); if !unconstrained { *result.multiplicity += G::ONE; } } else { record.function_queries[267].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained)); }; return Ok(__ret); }, _ => { @@ -25795,15 +25521,15 @@ fn aiur_fn_271( }) } -const INPUT_SIZE_272: usize = 5; -const IN_272: usize = 5; -const OUT_272: usize = 1; -fn aiur_fn_272( - inp: [G; IN_272], +const INPUT_SIZE_268: usize = 5; +const IN_268: usize = 5; +const OUT_268: usize = 1; +fn aiur_fn_268( + inp: [G; IN_268], record: &mut QueryRecord, io_buffer: &mut IOBuffer, unconstrained: bool, -) -> Result<[G; OUT_272], ExecError> { +) -> Result<[G; OUT_268], ExecError> { stacker::maybe_grow(64 * 1024, 4 * 1024 * 1024, || { let __v_0: G = inp[0]; let __v_1: G = inp[1]; @@ -25833,15 +25559,15 @@ fn aiur_fn_272( 0u64 => { let __r_arr: [G; OUT_16] = { let __args: [G; IN_16] = [__v_6, __v_7, __v_8, __v_9, __v_10, __v_11, __v_12, __v_13]; let __cu = unconstrained; if let Some(result) = record.function_queries[16].get_mut(&__args[..]) { if !__cu && *result.multiplicity == G::ZERO { aiur_fn_16(__args, record, io_buffer, false)? } else { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_16] = unsafe { *(result.output.as_ptr() as *const [G; OUT_16]) }; __ret } } else { aiur_fn_16(__args, record, io_buffer, __cu)? } }; let __v_23: G = __r_arr[0]; - let __r_arr: [G; OUT_766] = { let __args: [G; IN_766] = [__v_4, __v_23]; let __cu = unconstrained; if let Some(result) = record.function_queries[766].get_mut(&__args[..]) { if !__cu && *result.multiplicity == G::ZERO { aiur_fn_766(__args, record, io_buffer, false)? } else { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_766] = unsafe { *(result.output.as_ptr() as *const [G; OUT_766]) }; __ret } } else { aiur_fn_766(__args, record, io_buffer, __cu)? } }; + let __r_arr: [G; OUT_762] = { let __args: [G; IN_762] = [__v_4, __v_23]; let __cu = unconstrained; if let Some(result) = record.function_queries[762].get_mut(&__args[..]) { if !__cu && *result.multiplicity == G::ZERO { aiur_fn_762(__args, record, io_buffer, false)? } else { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_762] = unsafe { *(result.output.as_ptr() as *const [G; OUT_762]) }; __ret } } else { aiur_fn_762(__args, record, io_buffer, __cu)? } }; let __v_24: G = __r_arr[0]; let __v_25: G = G::from_u64(1); - let __r_arr: [G; OUT_270] = { let __args: [G; IN_270] = [__v_24]; let __cu = unconstrained; if let Some(result) = record.function_queries[270].get_mut(&__args[..]) { if !__cu && *result.multiplicity == G::ZERO { aiur_fn_270(__args, record, io_buffer, false)? } else { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_270] = unsafe { *(result.output.as_ptr() as *const [G; OUT_270]) }; __ret } } else { aiur_fn_270(__args, record, io_buffer, __cu)? } }; + let __r_arr: [G; OUT_266] = { let __args: [G; IN_266] = [__v_24]; let __cu = unconstrained; if let Some(result) = record.function_queries[266].get_mut(&__args[..]) { if !__cu && *result.multiplicity == G::ZERO { aiur_fn_266(__args, record, io_buffer, false)? } else { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_266] = unsafe { *(result.output.as_ptr() as *const [G; OUT_266]) }; __ret } } else { aiur_fn_266(__args, record, io_buffer, __cu)? } }; let __v_26: G = __r_arr[0]; let __v_27: G = G::from_u64(0); let __v_28: G = { let __values: [G; 4] = [__v_25, __v_26, __v_27, __v_27]; let __mq = record.memory_queries.get_mut(&4).ok_or(ExecError::InvalidMemorySize(4))?; if let Some(result) = __mq.get_mut(&__values[..]) { if !unconstrained { *result.multiplicity += G::ONE; } result.output[0] } else { let __ptr = G::from_usize(__mq.len()); __mq.insert(&__values[..], &[__ptr], G::from_bool(!unconstrained)); __ptr } }; - let __ret: [G; OUT_272] = [__v_28]; - if let Some(result) = record.function_queries[272].get_mut(&inp[..]) { debug_assert_eq!(result.output, &__ret[..]); if !unconstrained { *result.multiplicity += G::ONE; } } else { record.function_queries[272].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained)); }; + let __ret: [G; OUT_268] = [__v_28]; + if let Some(result) = record.function_queries[268].get_mut(&inp[..]) { debug_assert_eq!(result.output, &__ret[..]); if !unconstrained { *result.multiplicity += G::ONE; } } else { record.function_queries[268].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained)); }; return Ok(__ret); }, 1u64 => { @@ -25850,139 +25576,139 @@ fn aiur_fn_272( let __v_24: G = __r_arr[0]; let __v_25: G = G::from_u64(0); let __v_26: G = { let __values: [G; 4] = [__v_23, __v_24, __v_25, __v_25]; let __mq = record.memory_queries.get_mut(&4).ok_or(ExecError::InvalidMemorySize(4))?; if let Some(result) = __mq.get_mut(&__values[..]) { if !unconstrained { *result.multiplicity += G::ONE; } result.output[0] } else { let __ptr = G::from_usize(__mq.len()); __mq.insert(&__values[..], &[__ptr], G::from_bool(!unconstrained)); __ptr } }; - let __ret: [G; OUT_272] = [__v_26]; - if let Some(result) = record.function_queries[272].get_mut(&inp[..]) { debug_assert_eq!(result.output, &__ret[..]); if !unconstrained { *result.multiplicity += G::ONE; } } else { record.function_queries[272].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained)); }; + let __ret: [G; OUT_268] = [__v_26]; + if let Some(result) = record.function_queries[268].get_mut(&inp[..]) { debug_assert_eq!(result.output, &__ret[..]); if !unconstrained { *result.multiplicity += G::ONE; } } else { record.function_queries[268].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained)); }; return Ok(__ret); }, 2u64 => { let __r_arr: [G; OUT_16] = { let __args: [G; IN_16] = [__v_6, __v_7, __v_8, __v_9, __v_10, __v_11, __v_12, __v_13]; let __cu = unconstrained; if let Some(result) = record.function_queries[16].get_mut(&__args[..]) { if !__cu && *result.multiplicity == G::ZERO { aiur_fn_16(__args, record, io_buffer, false)? } else { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_16] = unsafe { *(result.output.as_ptr() as *const [G; OUT_16]) }; __ret } } else { aiur_fn_16(__args, record, io_buffer, __cu)? } }; let __v_23: G = __r_arr[0]; - let __r_arr: [G; OUT_766] = { let __args: [G; IN_766] = [__v_2, __v_23]; let __cu = unconstrained; if let Some(result) = record.function_queries[766].get_mut(&__args[..]) { if !__cu && *result.multiplicity == G::ZERO { aiur_fn_766(__args, record, io_buffer, false)? } else { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_766] = unsafe { *(result.output.as_ptr() as *const [G; OUT_766]) }; __ret } } else { aiur_fn_766(__args, record, io_buffer, __cu)? } }; + let __r_arr: [G; OUT_762] = { let __args: [G; IN_762] = [__v_2, __v_23]; let __cu = unconstrained; if let Some(result) = record.function_queries[762].get_mut(&__args[..]) { if !__cu && *result.multiplicity == G::ZERO { aiur_fn_762(__args, record, io_buffer, false)? } else { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_762] = unsafe { *(result.output.as_ptr() as *const [G; OUT_762]) }; __ret } } else { aiur_fn_762(__args, record, io_buffer, __cu)? } }; let __v_24: G = __r_arr[0]; - let __r_arr: [G; OUT_271] = { let __args: [G; IN_271] = [__v_14, __v_4]; let __cu = unconstrained; if let Some(result) = record.function_queries[271].get_mut(&__args[..]) { if !__cu && *result.multiplicity == G::ZERO { aiur_fn_271(__args, record, io_buffer, false)? } else { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_271] = unsafe { *(result.output.as_ptr() as *const [G; OUT_271]) }; __ret } } else { aiur_fn_271(__args, record, io_buffer, __cu)? } }; + let __r_arr: [G; OUT_267] = { let __args: [G; IN_267] = [__v_14, __v_4]; let __cu = unconstrained; if let Some(result) = record.function_queries[267].get_mut(&__args[..]) { if !__cu && *result.multiplicity == G::ZERO { aiur_fn_267(__args, record, io_buffer, false)? } else { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_267] = unsafe { *(result.output.as_ptr() as *const [G; OUT_267]) }; __ret } } else { aiur_fn_267(__args, record, io_buffer, __cu)? } }; let __v_25: G = __r_arr[0]; let __v_26: G = G::from_u64(2); let __v_27: G = G::from_u64(0); let __v_28: G = { let __values: [G; 4] = [__v_26, __v_24, __v_25, __v_27]; let __mq = record.memory_queries.get_mut(&4).ok_or(ExecError::InvalidMemorySize(4))?; if let Some(result) = __mq.get_mut(&__values[..]) { if !unconstrained { *result.multiplicity += G::ONE; } result.output[0] } else { let __ptr = G::from_usize(__mq.len()); __mq.insert(&__values[..], &[__ptr], G::from_bool(!unconstrained)); __ptr } }; - let __ret: [G; OUT_272] = [__v_28]; - if let Some(result) = record.function_queries[272].get_mut(&inp[..]) { debug_assert_eq!(result.output, &__ret[..]); if !unconstrained { *result.multiplicity += G::ONE; } } else { record.function_queries[272].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained)); }; + let __ret: [G; OUT_268] = [__v_28]; + if let Some(result) = record.function_queries[268].get_mut(&inp[..]) { debug_assert_eq!(result.output, &__ret[..]); if !unconstrained { *result.multiplicity += G::ONE; } } else { record.function_queries[268].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained)); }; return Ok(__ret); }, 3u64 => { let __r_arr: [G; OUT_16] = { let __args: [G; IN_16] = [__v_6, __v_7, __v_8, __v_9, __v_10, __v_11, __v_12, __v_13]; let __cu = unconstrained; if let Some(result) = record.function_queries[16].get_mut(&__args[..]) { if !__cu && *result.multiplicity == G::ZERO { aiur_fn_16(__args, record, io_buffer, false)? } else { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_16] = unsafe { *(result.output.as_ptr() as *const [G; OUT_16]) }; __ret } } else { aiur_fn_16(__args, record, io_buffer, __cu)? } }; let __v_23: G = __r_arr[0]; - let __r_arr: [G; OUT_766] = { let __args: [G; IN_766] = [__v_3, __v_23]; let __cu = unconstrained; if let Some(result) = record.function_queries[766].get_mut(&__args[..]) { if !__cu && *result.multiplicity == G::ZERO { aiur_fn_766(__args, record, io_buffer, false)? } else { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_766] = unsafe { *(result.output.as_ptr() as *const [G; OUT_766]) }; __ret } } else { aiur_fn_766(__args, record, io_buffer, __cu)? } }; + let __r_arr: [G; OUT_762] = { let __args: [G; IN_762] = [__v_3, __v_23]; let __cu = unconstrained; if let Some(result) = record.function_queries[762].get_mut(&__args[..]) { if !__cu && *result.multiplicity == G::ZERO { aiur_fn_762(__args, record, io_buffer, false)? } else { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_762] = unsafe { *(result.output.as_ptr() as *const [G; OUT_762]) }; __ret } } else { aiur_fn_762(__args, record, io_buffer, __cu)? } }; let __v_24: G = __r_arr[0]; - let __r_arr: [G; OUT_271] = { let __args: [G; IN_271] = [__v_14, __v_4]; let __cu = unconstrained; if let Some(result) = record.function_queries[271].get_mut(&__args[..]) { if !__cu && *result.multiplicity == G::ZERO { aiur_fn_271(__args, record, io_buffer, false)? } else { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_271] = unsafe { *(result.output.as_ptr() as *const [G; OUT_271]) }; __ret } } else { aiur_fn_271(__args, record, io_buffer, __cu)? } }; + let __r_arr: [G; OUT_267] = { let __args: [G; IN_267] = [__v_14, __v_4]; let __cu = unconstrained; if let Some(result) = record.function_queries[267].get_mut(&__args[..]) { if !__cu && *result.multiplicity == G::ZERO { aiur_fn_267(__args, record, io_buffer, false)? } else { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_267] = unsafe { *(result.output.as_ptr() as *const [G; OUT_267]) }; __ret } } else { aiur_fn_267(__args, record, io_buffer, __cu)? } }; let __v_25: G = __r_arr[0]; let __v_26: G = G::from_u64(2); let __v_27: G = G::from_u64(0); let __v_28: G = { let __values: [G; 4] = [__v_26, __v_24, __v_25, __v_27]; let __mq = record.memory_queries.get_mut(&4).ok_or(ExecError::InvalidMemorySize(4))?; if let Some(result) = __mq.get_mut(&__values[..]) { if !unconstrained { *result.multiplicity += G::ONE; } result.output[0] } else { let __ptr = G::from_usize(__mq.len()); __mq.insert(&__values[..], &[__ptr], G::from_bool(!unconstrained)); __ptr } }; - let __ret: [G; OUT_272] = [__v_28]; - if let Some(result) = record.function_queries[272].get_mut(&inp[..]) { debug_assert_eq!(result.output, &__ret[..]); if !unconstrained { *result.multiplicity += G::ONE; } } else { record.function_queries[272].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained)); }; + let __ret: [G; OUT_268] = [__v_28]; + if let Some(result) = record.function_queries[268].get_mut(&inp[..]) { debug_assert_eq!(result.output, &__ret[..]); if !unconstrained { *result.multiplicity += G::ONE; } } else { record.function_queries[268].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained)); }; return Ok(__ret); }, 4u64 => { let __r_arr: [G; OUT_16] = { let __args: [G; IN_16] = [__v_6, __v_7, __v_8, __v_9, __v_10, __v_11, __v_12, __v_13]; let __cu = unconstrained; if let Some(result) = record.function_queries[16].get_mut(&__args[..]) { if !__cu && *result.multiplicity == G::ZERO { aiur_fn_16(__args, record, io_buffer, false)? } else { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_16] = unsafe { *(result.output.as_ptr() as *const [G; OUT_16]) }; __ret } } else { aiur_fn_16(__args, record, io_buffer, __cu)? } }; let __v_23: G = __r_arr[0]; - let __r_arr: [G; OUT_766] = { let __args: [G; IN_766] = [__v_2, __v_23]; let __cu = unconstrained; if let Some(result) = record.function_queries[766].get_mut(&__args[..]) { if !__cu && *result.multiplicity == G::ZERO { aiur_fn_766(__args, record, io_buffer, false)? } else { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_766] = unsafe { *(result.output.as_ptr() as *const [G; OUT_766]) }; __ret } } else { aiur_fn_766(__args, record, io_buffer, __cu)? } }; + let __r_arr: [G; OUT_762] = { let __args: [G; IN_762] = [__v_2, __v_23]; let __cu = unconstrained; if let Some(result) = record.function_queries[762].get_mut(&__args[..]) { if !__cu && *result.multiplicity == G::ZERO { aiur_fn_762(__args, record, io_buffer, false)? } else { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_762] = unsafe { *(result.output.as_ptr() as *const [G; OUT_762]) }; __ret } } else { aiur_fn_762(__args, record, io_buffer, __cu)? } }; let __v_24: G = __r_arr[0]; let __v_25: G = G::from_u64(8); let __r_arr: [G; OUT_16] = { let __args: [G; IN_16] = [__v_14, __v_15, __v_16, __v_17, __v_18, __v_19, __v_20, __v_21]; let __cu = unconstrained; if let Some(result) = record.function_queries[16].get_mut(&__args[..]) { if !__cu && *result.multiplicity == G::ZERO { aiur_fn_16(__args, record, io_buffer, false)? } else { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_16] = unsafe { *(result.output.as_ptr() as *const [G; OUT_16]) }; __ret } } else { aiur_fn_16(__args, record, io_buffer, __cu)? } }; let __v_26: G = __r_arr[0]; - let __r_arr: [G; OUT_272] = { let __args: [G; IN_272] = [__v_22, __v_1, __v_2, __v_3, __v_4]; let __cu = unconstrained; if let Some(result) = record.function_queries[272].get_mut(&__args[..]) { if !__cu && *result.multiplicity == G::ZERO { aiur_fn_272(__args, record, io_buffer, false)? } else { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_272] = unsafe { *(result.output.as_ptr() as *const [G; OUT_272]) }; __ret } } else { aiur_fn_272(__args, record, io_buffer, __cu)? } }; + let __r_arr: [G; OUT_268] = { let __args: [G; IN_268] = [__v_22, __v_1, __v_2, __v_3, __v_4]; let __cu = unconstrained; if let Some(result) = record.function_queries[268].get_mut(&__args[..]) { if !__cu && *result.multiplicity == G::ZERO { aiur_fn_268(__args, record, io_buffer, false)? } else { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_268] = unsafe { *(result.output.as_ptr() as *const [G; OUT_268]) }; __ret } } else { aiur_fn_268(__args, record, io_buffer, __cu)? } }; let __v_27: G = __r_arr[0]; let __v_28: G = { let __values: [G; 4] = [__v_25, __v_24, __v_26, __v_27]; let __mq = record.memory_queries.get_mut(&4).ok_or(ExecError::InvalidMemorySize(4))?; if let Some(result) = __mq.get_mut(&__values[..]) { if !unconstrained { *result.multiplicity += G::ONE; } result.output[0] } else { let __ptr = G::from_usize(__mq.len()); __mq.insert(&__values[..], &[__ptr], G::from_bool(!unconstrained)); __ptr } }; - let __ret: [G; OUT_272] = [__v_28]; - if let Some(result) = record.function_queries[272].get_mut(&inp[..]) { debug_assert_eq!(result.output, &__ret[..]); if !unconstrained { *result.multiplicity += G::ONE; } } else { record.function_queries[272].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained)); }; + let __ret: [G; OUT_268] = [__v_28]; + if let Some(result) = record.function_queries[268].get_mut(&inp[..]) { debug_assert_eq!(result.output, &__ret[..]); if !unconstrained { *result.multiplicity += G::ONE; } } else { record.function_queries[268].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained)); }; return Ok(__ret); }, 5u64 => { let __r_arr: [G; OUT_16] = { let __args: [G; IN_16] = [__v_6, __v_7, __v_8, __v_9, __v_10, __v_11, __v_12, __v_13]; let __cu = unconstrained; if let Some(result) = record.function_queries[16].get_mut(&__args[..]) { if !__cu && *result.multiplicity == G::ZERO { aiur_fn_16(__args, record, io_buffer, false)? } else { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_16] = unsafe { *(result.output.as_ptr() as *const [G; OUT_16]) }; __ret } } else { aiur_fn_16(__args, record, io_buffer, __cu)? } }; let __v_23: G = __r_arr[0]; - let __r_arr: [G; OUT_766] = { let __args: [G; IN_766] = [__v_2, __v_23]; let __cu = unconstrained; if let Some(result) = record.function_queries[766].get_mut(&__args[..]) { if !__cu && *result.multiplicity == G::ZERO { aiur_fn_766(__args, record, io_buffer, false)? } else { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_766] = unsafe { *(result.output.as_ptr() as *const [G; OUT_766]) }; __ret } } else { aiur_fn_766(__args, record, io_buffer, __cu)? } }; + let __r_arr: [G; OUT_762] = { let __args: [G; IN_762] = [__v_2, __v_23]; let __cu = unconstrained; if let Some(result) = record.function_queries[762].get_mut(&__args[..]) { if !__cu && *result.multiplicity == G::ZERO { aiur_fn_762(__args, record, io_buffer, false)? } else { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_762] = unsafe { *(result.output.as_ptr() as *const [G; OUT_762]) }; __ret } } else { aiur_fn_762(__args, record, io_buffer, __cu)? } }; let __v_24: G = __r_arr[0]; - let __r_arr: [G; OUT_284] = { let __args: [G; IN_284] = [__v_24]; let __cu = unconstrained; if let Some(result) = record.function_queries[284].get_mut(&__args[..]) { if !__cu && *result.multiplicity == G::ZERO { aiur_fn_284(__args, record, io_buffer, false)? } else { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_284] = unsafe { *(result.output.as_ptr() as *const [G; OUT_284]) }; __ret } } else { aiur_fn_284(__args, record, io_buffer, __cu)? } }; + let __r_arr: [G; OUT_280] = { let __args: [G; IN_280] = [__v_24]; let __cu = unconstrained; if let Some(result) = record.function_queries[280].get_mut(&__args[..]) { if !__cu && *result.multiplicity == G::ZERO { aiur_fn_280(__args, record, io_buffer, false)? } else { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_280] = unsafe { *(result.output.as_ptr() as *const [G; OUT_280]) }; __ret } } else { aiur_fn_280(__args, record, io_buffer, __cu)? } }; let __v_25: G = __r_arr[0]; - let __r_arr: [G; OUT_223] = { let __args: [G; IN_223] = [__v_25]; let __cu = unconstrained; if let Some(result) = record.function_queries[223].get_mut(&__args[..]) { if !__cu && *result.multiplicity == G::ZERO { aiur_fn_223(__args, record, io_buffer, false)? } else { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_223] = unsafe { *(result.output.as_ptr() as *const [G; OUT_223]) }; __ret } } else { aiur_fn_223(__args, record, io_buffer, __cu)? } }; + let __r_arr: [G; OUT_219] = { let __args: [G; IN_219] = [__v_25]; let __cu = unconstrained; if let Some(result) = record.function_queries[219].get_mut(&__args[..]) { if !__cu && *result.multiplicity == G::ZERO { aiur_fn_219(__args, record, io_buffer, false)? } else { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_219] = unsafe { *(result.output.as_ptr() as *const [G; OUT_219]) }; __ret } } else { aiur_fn_219(__args, record, io_buffer, __cu)? } }; let __v_26: G = G::from_u64(7); let __v_27: G = G::from_u64(1); let __v_28: G = G::from_u64(0); let __v_29: G = { let __values: [G; 4] = [__v_26, __v_27, __v_25, __v_28]; let __mq = record.memory_queries.get_mut(&4).ok_or(ExecError::InvalidMemorySize(4))?; if let Some(result) = __mq.get_mut(&__values[..]) { if !unconstrained { *result.multiplicity += G::ONE; } result.output[0] } else { let __ptr = G::from_usize(__mq.len()); __mq.insert(&__values[..], &[__ptr], G::from_bool(!unconstrained)); __ptr } }; - let __ret: [G; OUT_272] = [__v_29]; - if let Some(result) = record.function_queries[272].get_mut(&inp[..]) { debug_assert_eq!(result.output, &__ret[..]); if !unconstrained { *result.multiplicity += G::ONE; } } else { record.function_queries[272].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained)); }; + let __ret: [G; OUT_268] = [__v_29]; + if let Some(result) = record.function_queries[268].get_mut(&inp[..]) { debug_assert_eq!(result.output, &__ret[..]); if !unconstrained { *result.multiplicity += G::ONE; } } else { record.function_queries[268].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained)); }; return Ok(__ret); }, 6u64 => { let __r_arr: [G; OUT_16] = { let __args: [G; IN_16] = [__v_6, __v_7, __v_8, __v_9, __v_10, __v_11, __v_12, __v_13]; let __cu = unconstrained; if let Some(result) = record.function_queries[16].get_mut(&__args[..]) { if !__cu && *result.multiplicity == G::ZERO { aiur_fn_16(__args, record, io_buffer, false)? } else { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_16] = unsafe { *(result.output.as_ptr() as *const [G; OUT_16]) }; __ret } } else { aiur_fn_16(__args, record, io_buffer, __cu)? } }; let __v_23: G = __r_arr[0]; - let __r_arr: [G; OUT_766] = { let __args: [G; IN_766] = [__v_2, __v_23]; let __cu = unconstrained; if let Some(result) = record.function_queries[766].get_mut(&__args[..]) { if !__cu && *result.multiplicity == G::ZERO { aiur_fn_766(__args, record, io_buffer, false)? } else { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_766] = unsafe { *(result.output.as_ptr() as *const [G; OUT_766]) }; __ret } } else { aiur_fn_766(__args, record, io_buffer, __cu)? } }; + let __r_arr: [G; OUT_762] = { let __args: [G; IN_762] = [__v_2, __v_23]; let __cu = unconstrained; if let Some(result) = record.function_queries[762].get_mut(&__args[..]) { if !__cu && *result.multiplicity == G::ZERO { aiur_fn_762(__args, record, io_buffer, false)? } else { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_762] = unsafe { *(result.output.as_ptr() as *const [G; OUT_762]) }; __ret } } else { aiur_fn_762(__args, record, io_buffer, __cu)? } }; let __v_24: G = __r_arr[0]; - let __r_arr: [G; OUT_284] = { let __args: [G; IN_284] = [__v_24]; let __cu = unconstrained; if let Some(result) = record.function_queries[284].get_mut(&__args[..]) { if !__cu && *result.multiplicity == G::ZERO { aiur_fn_284(__args, record, io_buffer, false)? } else { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_284] = unsafe { *(result.output.as_ptr() as *const [G; OUT_284]) }; __ret } } else { aiur_fn_284(__args, record, io_buffer, __cu)? } }; + let __r_arr: [G; OUT_280] = { let __args: [G; IN_280] = [__v_24]; let __cu = unconstrained; if let Some(result) = record.function_queries[280].get_mut(&__args[..]) { if !__cu && *result.multiplicity == G::ZERO { aiur_fn_280(__args, record, io_buffer, false)? } else { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_280] = unsafe { *(result.output.as_ptr() as *const [G; OUT_280]) }; __ret } } else { aiur_fn_280(__args, record, io_buffer, __cu)? } }; let __v_25: G = __r_arr[0]; - let __r_arr: [G; OUT_269] = { let __args: [G; IN_269] = [__v_25]; let __cu = unconstrained; if let Some(result) = record.function_queries[269].get_mut(&__args[..]) { if !__cu && *result.multiplicity == G::ZERO { aiur_fn_269(__args, record, io_buffer, false)? } else { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_269] = unsafe { *(result.output.as_ptr() as *const [G; OUT_269]) }; __ret } } else { aiur_fn_269(__args, record, io_buffer, __cu)? } }; + let __r_arr: [G; OUT_265] = { let __args: [G; IN_265] = [__v_25]; let __cu = unconstrained; if let Some(result) = record.function_queries[265].get_mut(&__args[..]) { if !__cu && *result.multiplicity == G::ZERO { aiur_fn_265(__args, record, io_buffer, false)? } else { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_265] = unsafe { *(result.output.as_ptr() as *const [G; OUT_265]) }; __ret } } else { aiur_fn_265(__args, record, io_buffer, __cu)? } }; let __v_26: G = __r_arr[0]; let __v_27: G = G::from_u64(7); let __v_28: G = G::from_u64(0); let __v_29: G = G::from_u64(0); let __v_30: G = { let __values: [G; 4] = [__v_27, __v_28, __v_26, __v_29]; let __mq = record.memory_queries.get_mut(&4).ok_or(ExecError::InvalidMemorySize(4))?; if let Some(result) = __mq.get_mut(&__values[..]) { if !unconstrained { *result.multiplicity += G::ONE; } result.output[0] } else { let __ptr = G::from_usize(__mq.len()); __mq.insert(&__values[..], &[__ptr], G::from_bool(!unconstrained)); __ptr } }; - let __ret: [G; OUT_272] = [__v_30]; - if let Some(result) = record.function_queries[272].get_mut(&inp[..]) { debug_assert_eq!(result.output, &__ret[..]); if !unconstrained { *result.multiplicity += G::ONE; } } else { record.function_queries[272].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained)); }; + let __ret: [G; OUT_268] = [__v_30]; + if let Some(result) = record.function_queries[268].get_mut(&inp[..]) { debug_assert_eq!(result.output, &__ret[..]); if !unconstrained { *result.multiplicity += G::ONE; } } else { record.function_queries[268].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained)); }; return Ok(__ret); }, 7u64 => { let __v_23: G = G::from_u64(3); - let __r_arr: [G; OUT_272] = { let __args: [G; IN_272] = [__v_6, __v_1, __v_2, __v_3, __v_4]; let __cu = unconstrained; if let Some(result) = record.function_queries[272].get_mut(&__args[..]) { if !__cu && *result.multiplicity == G::ZERO { aiur_fn_272(__args, record, io_buffer, false)? } else { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_272] = unsafe { *(result.output.as_ptr() as *const [G; OUT_272]) }; __ret } } else { aiur_fn_272(__args, record, io_buffer, __cu)? } }; + let __r_arr: [G; OUT_268] = { let __args: [G; IN_268] = [__v_6, __v_1, __v_2, __v_3, __v_4]; let __cu = unconstrained; if let Some(result) = record.function_queries[268].get_mut(&__args[..]) { if !__cu && *result.multiplicity == G::ZERO { aiur_fn_268(__args, record, io_buffer, false)? } else { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_268] = unsafe { *(result.output.as_ptr() as *const [G; OUT_268]) }; __ret } } else { aiur_fn_268(__args, record, io_buffer, __cu)? } }; let __v_24: G = __r_arr[0]; - let __r_arr: [G; OUT_272] = { let __args: [G; IN_272] = [__v_7, __v_1, __v_2, __v_3, __v_4]; let __cu = unconstrained; if let Some(result) = record.function_queries[272].get_mut(&__args[..]) { if !__cu && *result.multiplicity == G::ZERO { aiur_fn_272(__args, record, io_buffer, false)? } else { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_272] = unsafe { *(result.output.as_ptr() as *const [G; OUT_272]) }; __ret } } else { aiur_fn_272(__args, record, io_buffer, __cu)? } }; + let __r_arr: [G; OUT_268] = { let __args: [G; IN_268] = [__v_7, __v_1, __v_2, __v_3, __v_4]; let __cu = unconstrained; if let Some(result) = record.function_queries[268].get_mut(&__args[..]) { if !__cu && *result.multiplicity == G::ZERO { aiur_fn_268(__args, record, io_buffer, false)? } else { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_268] = unsafe { *(result.output.as_ptr() as *const [G; OUT_268]) }; __ret } } else { aiur_fn_268(__args, record, io_buffer, __cu)? } }; let __v_25: G = __r_arr[0]; let __v_26: G = G::from_u64(0); let __v_27: G = { let __values: [G; 4] = [__v_23, __v_24, __v_25, __v_26]; let __mq = record.memory_queries.get_mut(&4).ok_or(ExecError::InvalidMemorySize(4))?; if let Some(result) = __mq.get_mut(&__values[..]) { if !unconstrained { *result.multiplicity += G::ONE; } result.output[0] } else { let __ptr = G::from_usize(__mq.len()); __mq.insert(&__values[..], &[__ptr], G::from_bool(!unconstrained)); __ptr } }; - let __ret: [G; OUT_272] = [__v_27]; - if let Some(result) = record.function_queries[272].get_mut(&inp[..]) { debug_assert_eq!(result.output, &__ret[..]); if !unconstrained { *result.multiplicity += G::ONE; } } else { record.function_queries[272].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained)); }; + let __ret: [G; OUT_268] = [__v_27]; + if let Some(result) = record.function_queries[268].get_mut(&inp[..]) { debug_assert_eq!(result.output, &__ret[..]); if !unconstrained { *result.multiplicity += G::ONE; } } else { record.function_queries[268].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained)); }; return Ok(__ret); }, 8u64 => { let __v_23: G = G::from_u64(4); - let __r_arr: [G; OUT_272] = { let __args: [G; IN_272] = [__v_6, __v_1, __v_2, __v_3, __v_4]; let __cu = unconstrained; if let Some(result) = record.function_queries[272].get_mut(&__args[..]) { if !__cu && *result.multiplicity == G::ZERO { aiur_fn_272(__args, record, io_buffer, false)? } else { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_272] = unsafe { *(result.output.as_ptr() as *const [G; OUT_272]) }; __ret } } else { aiur_fn_272(__args, record, io_buffer, __cu)? } }; + let __r_arr: [G; OUT_268] = { let __args: [G; IN_268] = [__v_6, __v_1, __v_2, __v_3, __v_4]; let __cu = unconstrained; if let Some(result) = record.function_queries[268].get_mut(&__args[..]) { if !__cu && *result.multiplicity == G::ZERO { aiur_fn_268(__args, record, io_buffer, false)? } else { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_268] = unsafe { *(result.output.as_ptr() as *const [G; OUT_268]) }; __ret } } else { aiur_fn_268(__args, record, io_buffer, __cu)? } }; let __v_24: G = __r_arr[0]; - let __r_arr: [G; OUT_272] = { let __args: [G; IN_272] = [__v_7, __v_1, __v_2, __v_3, __v_4]; let __cu = unconstrained; if let Some(result) = record.function_queries[272].get_mut(&__args[..]) { if !__cu && *result.multiplicity == G::ZERO { aiur_fn_272(__args, record, io_buffer, false)? } else { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_272] = unsafe { *(result.output.as_ptr() as *const [G; OUT_272]) }; __ret } } else { aiur_fn_272(__args, record, io_buffer, __cu)? } }; + let __r_arr: [G; OUT_268] = { let __args: [G; IN_268] = [__v_7, __v_1, __v_2, __v_3, __v_4]; let __cu = unconstrained; if let Some(result) = record.function_queries[268].get_mut(&__args[..]) { if !__cu && *result.multiplicity == G::ZERO { aiur_fn_268(__args, record, io_buffer, false)? } else { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_268] = unsafe { *(result.output.as_ptr() as *const [G; OUT_268]) }; __ret } } else { aiur_fn_268(__args, record, io_buffer, __cu)? } }; let __v_25: G = __r_arr[0]; let __v_26: G = G::from_u64(0); let __v_27: G = { let __values: [G; 4] = [__v_23, __v_24, __v_25, __v_26]; let __mq = record.memory_queries.get_mut(&4).ok_or(ExecError::InvalidMemorySize(4))?; if let Some(result) = __mq.get_mut(&__values[..]) { if !unconstrained { *result.multiplicity += G::ONE; } result.output[0] } else { let __ptr = G::from_usize(__mq.len()); __mq.insert(&__values[..], &[__ptr], G::from_bool(!unconstrained)); __ptr } }; - let __ret: [G; OUT_272] = [__v_27]; - if let Some(result) = record.function_queries[272].get_mut(&inp[..]) { debug_assert_eq!(result.output, &__ret[..]); if !unconstrained { *result.multiplicity += G::ONE; } } else { record.function_queries[272].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained)); }; + let __ret: [G; OUT_268] = [__v_27]; + if let Some(result) = record.function_queries[268].get_mut(&inp[..]) { debug_assert_eq!(result.output, &__ret[..]); if !unconstrained { *result.multiplicity += G::ONE; } } else { record.function_queries[268].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained)); }; return Ok(__ret); }, 9u64 => { let __v_23: G = G::from_u64(5); - let __r_arr: [G; OUT_272] = { let __args: [G; IN_272] = [__v_6, __v_1, __v_2, __v_3, __v_4]; let __cu = unconstrained; if let Some(result) = record.function_queries[272].get_mut(&__args[..]) { if !__cu && *result.multiplicity == G::ZERO { aiur_fn_272(__args, record, io_buffer, false)? } else { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_272] = unsafe { *(result.output.as_ptr() as *const [G; OUT_272]) }; __ret } } else { aiur_fn_272(__args, record, io_buffer, __cu)? } }; + let __r_arr: [G; OUT_268] = { let __args: [G; IN_268] = [__v_6, __v_1, __v_2, __v_3, __v_4]; let __cu = unconstrained; if let Some(result) = record.function_queries[268].get_mut(&__args[..]) { if !__cu && *result.multiplicity == G::ZERO { aiur_fn_268(__args, record, io_buffer, false)? } else { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_268] = unsafe { *(result.output.as_ptr() as *const [G; OUT_268]) }; __ret } } else { aiur_fn_268(__args, record, io_buffer, __cu)? } }; let __v_24: G = __r_arr[0]; - let __r_arr: [G; OUT_272] = { let __args: [G; IN_272] = [__v_7, __v_1, __v_2, __v_3, __v_4]; let __cu = unconstrained; if let Some(result) = record.function_queries[272].get_mut(&__args[..]) { if !__cu && *result.multiplicity == G::ZERO { aiur_fn_272(__args, record, io_buffer, false)? } else { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_272] = unsafe { *(result.output.as_ptr() as *const [G; OUT_272]) }; __ret } } else { aiur_fn_272(__args, record, io_buffer, __cu)? } }; + let __r_arr: [G; OUT_268] = { let __args: [G; IN_268] = [__v_7, __v_1, __v_2, __v_3, __v_4]; let __cu = unconstrained; if let Some(result) = record.function_queries[268].get_mut(&__args[..]) { if !__cu && *result.multiplicity == G::ZERO { aiur_fn_268(__args, record, io_buffer, false)? } else { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_268] = unsafe { *(result.output.as_ptr() as *const [G; OUT_268]) }; __ret } } else { aiur_fn_268(__args, record, io_buffer, __cu)? } }; let __v_25: G = __r_arr[0]; let __v_26: G = G::from_u64(0); let __v_27: G = { let __values: [G; 4] = [__v_23, __v_24, __v_25, __v_26]; let __mq = record.memory_queries.get_mut(&4).ok_or(ExecError::InvalidMemorySize(4))?; if let Some(result) = __mq.get_mut(&__values[..]) { if !unconstrained { *result.multiplicity += G::ONE; } result.output[0] } else { let __ptr = G::from_usize(__mq.len()); __mq.insert(&__values[..], &[__ptr], G::from_bool(!unconstrained)); __ptr } }; - let __ret: [G; OUT_272] = [__v_27]; - if let Some(result) = record.function_queries[272].get_mut(&inp[..]) { debug_assert_eq!(result.output, &__ret[..]); if !unconstrained { *result.multiplicity += G::ONE; } } else { record.function_queries[272].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained)); }; + let __ret: [G; OUT_268] = [__v_27]; + if let Some(result) = record.function_queries[268].get_mut(&inp[..]) { debug_assert_eq!(result.output, &__ret[..]); if !unconstrained { *result.multiplicity += G::ONE; } } else { record.function_queries[268].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained)); }; return Ok(__ret); }, 10u64 => { let __v_23: G = G::from_u64(6); - let __r_arr: [G; OUT_272] = { let __args: [G; IN_272] = [__v_14, __v_1, __v_2, __v_3, __v_4]; let __cu = unconstrained; if let Some(result) = record.function_queries[272].get_mut(&__args[..]) { if !__cu && *result.multiplicity == G::ZERO { aiur_fn_272(__args, record, io_buffer, false)? } else { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_272] = unsafe { *(result.output.as_ptr() as *const [G; OUT_272]) }; __ret } } else { aiur_fn_272(__args, record, io_buffer, __cu)? } }; + let __r_arr: [G; OUT_268] = { let __args: [G; IN_268] = [__v_14, __v_1, __v_2, __v_3, __v_4]; let __cu = unconstrained; if let Some(result) = record.function_queries[268].get_mut(&__args[..]) { if !__cu && *result.multiplicity == G::ZERO { aiur_fn_268(__args, record, io_buffer, false)? } else { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_268] = unsafe { *(result.output.as_ptr() as *const [G; OUT_268]) }; __ret } } else { aiur_fn_268(__args, record, io_buffer, __cu)? } }; let __v_24: G = __r_arr[0]; - let __r_arr: [G; OUT_272] = { let __args: [G; IN_272] = [__v_15, __v_1, __v_2, __v_3, __v_4]; let __cu = unconstrained; if let Some(result) = record.function_queries[272].get_mut(&__args[..]) { if !__cu && *result.multiplicity == G::ZERO { aiur_fn_272(__args, record, io_buffer, false)? } else { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_272] = unsafe { *(result.output.as_ptr() as *const [G; OUT_272]) }; __ret } } else { aiur_fn_272(__args, record, io_buffer, __cu)? } }; + let __r_arr: [G; OUT_268] = { let __args: [G; IN_268] = [__v_15, __v_1, __v_2, __v_3, __v_4]; let __cu = unconstrained; if let Some(result) = record.function_queries[268].get_mut(&__args[..]) { if !__cu && *result.multiplicity == G::ZERO { aiur_fn_268(__args, record, io_buffer, false)? } else { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_268] = unsafe { *(result.output.as_ptr() as *const [G; OUT_268]) }; __ret } } else { aiur_fn_268(__args, record, io_buffer, __cu)? } }; let __v_25: G = __r_arr[0]; - let __r_arr: [G; OUT_272] = { let __args: [G; IN_272] = [__v_16, __v_1, __v_2, __v_3, __v_4]; let __cu = unconstrained; if let Some(result) = record.function_queries[272].get_mut(&__args[..]) { if !__cu && *result.multiplicity == G::ZERO { aiur_fn_272(__args, record, io_buffer, false)? } else { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_272] = unsafe { *(result.output.as_ptr() as *const [G; OUT_272]) }; __ret } } else { aiur_fn_272(__args, record, io_buffer, __cu)? } }; + let __r_arr: [G; OUT_268] = { let __args: [G; IN_268] = [__v_16, __v_1, __v_2, __v_3, __v_4]; let __cu = unconstrained; if let Some(result) = record.function_queries[268].get_mut(&__args[..]) { if !__cu && *result.multiplicity == G::ZERO { aiur_fn_268(__args, record, io_buffer, false)? } else { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_268] = unsafe { *(result.output.as_ptr() as *const [G; OUT_268]) }; __ret } } else { aiur_fn_268(__args, record, io_buffer, __cu)? } }; let __v_26: G = __r_arr[0]; let __v_27: G = { let __values: [G; 4] = [__v_23, __v_24, __v_25, __v_26]; let __mq = record.memory_queries.get_mut(&4).ok_or(ExecError::InvalidMemorySize(4))?; if let Some(result) = __mq.get_mut(&__values[..]) { if !unconstrained { *result.multiplicity += G::ONE; } result.output[0] } else { let __ptr = G::from_usize(__mq.len()); __mq.insert(&__values[..], &[__ptr], G::from_bool(!unconstrained)); __ptr } }; - let __ret: [G; OUT_272] = [__v_27]; - if let Some(result) = record.function_queries[272].get_mut(&inp[..]) { debug_assert_eq!(result.output, &__ret[..]); if !unconstrained { *result.multiplicity += G::ONE; } } else { record.function_queries[272].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained)); }; + let __ret: [G; OUT_268] = [__v_27]; + if let Some(result) = record.function_queries[268].get_mut(&inp[..]) { debug_assert_eq!(result.output, &__ret[..]); if !unconstrained { *result.multiplicity += G::ONE; } } else { record.function_queries[268].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained)); }; return Ok(__ret); }, 11u64 => { let __r_arr: [G; OUT_16] = { let __args: [G; IN_16] = [__v_6, __v_7, __v_8, __v_9, __v_10, __v_11, __v_12, __v_13]; let __cu = unconstrained; if let Some(result) = record.function_queries[16].get_mut(&__args[..]) { if !__cu && *result.multiplicity == G::ZERO { aiur_fn_16(__args, record, io_buffer, false)? } else { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_16] = unsafe { *(result.output.as_ptr() as *const [G; OUT_16]) }; __ret } } else { aiur_fn_16(__args, record, io_buffer, __cu)? } }; let __v_23: G = __r_arr[0]; - let __r_arr: [G; OUT_775] = { let __args: [G; IN_775] = [__v_1, __v_23]; let __cu = unconstrained; if let Some(result) = record.function_queries[775].get_mut(&__args[..]) { if !__cu && *result.multiplicity == G::ZERO { aiur_fn_775(__args, record, io_buffer, false)? } else { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_775] = unsafe { *(result.output.as_ptr() as *const [G; OUT_775]) }; __ret } } else { aiur_fn_775(__args, record, io_buffer, __cu)? } }; + let __r_arr: [G; OUT_771] = { let __args: [G; IN_771] = [__v_1, __v_23]; let __cu = unconstrained; if let Some(result) = record.function_queries[771].get_mut(&__args[..]) { if !__cu && *result.multiplicity == G::ZERO { aiur_fn_771(__args, record, io_buffer, false)? } else { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_771] = unsafe { *(result.output.as_ptr() as *const [G; OUT_771]) }; __ret } } else { aiur_fn_771(__args, record, io_buffer, __cu)? } }; let __v_24: G = __r_arr[0]; let __loaded: [G; 3] = { let __mq = record.memory_queries.get_mut(&3).ok_or(ExecError::InvalidMemorySize(3))?; let __ptr_u64 = __v_24.as_canonical_u64(); let __ptr_usize = usize::try_from(__ptr_u64).ok().ok_or(ExecError::PointerTooLarge(__ptr_u64))?; let (__args, __mult) = __mq.get_index_mut(__ptr_usize).ok_or(ExecError::UnboundPointer { ptr: __ptr_u64, size: 3 })?; if !unconstrained { *__mult += G::ONE; } let __arr: [G; 3] = __args[..3].try_into().unwrap(); __arr }; let __v_25: G = __loaded[0]; @@ -25990,10 +25716,10 @@ fn aiur_fn_272( let __v_27: G = __loaded[2]; match __v_25.as_canonical_u64() { 0u64 => { - let __r_arr: [G; OUT_272] = { let __args: [G; IN_272] = [__v_26, __v_1, __v_2, __v_3, __v_4]; let __cu = unconstrained; if let Some(result) = record.function_queries[272].get_mut(&__args[..]) { if !__cu && *result.multiplicity == G::ZERO { aiur_fn_272(__args, record, io_buffer, false)? } else { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_272] = unsafe { *(result.output.as_ptr() as *const [G; OUT_272]) }; __ret } } else { aiur_fn_272(__args, record, io_buffer, __cu)? } }; + let __r_arr: [G; OUT_268] = { let __args: [G; IN_268] = [__v_26, __v_1, __v_2, __v_3, __v_4]; let __cu = unconstrained; if let Some(result) = record.function_queries[268].get_mut(&__args[..]) { if !__cu && *result.multiplicity == G::ZERO { aiur_fn_268(__args, record, io_buffer, false)? } else { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_268] = unsafe { *(result.output.as_ptr() as *const [G; OUT_268]) }; __ret } } else { aiur_fn_268(__args, record, io_buffer, __cu)? } }; let __v_28: G = __r_arr[0]; - let __ret: [G; OUT_272] = [__v_28]; - if let Some(result) = record.function_queries[272].get_mut(&inp[..]) { debug_assert_eq!(result.output, &__ret[..]); if !unconstrained { *result.multiplicity += G::ONE; } } else { record.function_queries[272].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained)); }; + let __ret: [G; OUT_268] = [__v_28]; + if let Some(result) = record.function_queries[268].get_mut(&inp[..]) { debug_assert_eq!(result.output, &__ret[..]); if !unconstrained { *result.multiplicity += G::ONE; } } else { record.function_queries[268].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained)); }; return Ok(__ret); }, _ => { @@ -26008,15 +25734,15 @@ fn aiur_fn_272( }) } -const INPUT_SIZE_273: usize = 17; -const IN_273: usize = 17; -const OUT_273: usize = 12; -fn aiur_fn_273( - inp: [G; IN_273], +const INPUT_SIZE_269: usize = 17; +const IN_269: usize = 17; +const OUT_269: usize = 12; +fn aiur_fn_269( + inp: [G; IN_269], record: &mut QueryRecord, io_buffer: &mut IOBuffer, unconstrained: bool, -) -> Result<[G; OUT_273], ExecError> { +) -> Result<[G; OUT_269], ExecError> { stacker::maybe_grow(64 * 1024, 4 * 1024 * 1024, || { let __v_0: G = inp[0]; let __v_1: G = inp[1]; @@ -26037,9 +25763,9 @@ fn aiur_fn_273( let __v_16: G = inp[16]; match __v_0.as_canonical_u64() { _ => { - let __r_arr: [G; OUT_272] = { let __args: [G; IN_272] = [__v_10, __v_12, __v_13, __v_14, __v_15]; let __cu = unconstrained; if let Some(result) = record.function_queries[272].get_mut(&__args[..]) { if !__cu && *result.multiplicity == G::ZERO { aiur_fn_272(__args, record, io_buffer, false)? } else { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_272] = unsafe { *(result.output.as_ptr() as *const [G; OUT_272]) }; __ret } } else { aiur_fn_272(__args, record, io_buffer, __cu)? } }; + let __r_arr: [G; OUT_268] = { let __args: [G; IN_268] = [__v_10, __v_12, __v_13, __v_14, __v_15]; let __cu = unconstrained; if let Some(result) = record.function_queries[268].get_mut(&__args[..]) { if !__cu && *result.multiplicity == G::ZERO { aiur_fn_268(__args, record, io_buffer, false)? } else { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_268] = unsafe { *(result.output.as_ptr() as *const [G; OUT_268]) }; __ret } } else { aiur_fn_268(__args, record, io_buffer, __cu)? } }; let __v_17: G = __r_arr[0]; - let __r_arr: [G; OUT_272] = { let __args: [G; IN_272] = [__v_11, __v_12, __v_13, __v_14, __v_15]; let __cu = unconstrained; if let Some(result) = record.function_queries[272].get_mut(&__args[..]) { if !__cu && *result.multiplicity == G::ZERO { aiur_fn_272(__args, record, io_buffer, false)? } else { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_272] = unsafe { *(result.output.as_ptr() as *const [G; OUT_272]) }; __ret } } else { aiur_fn_272(__args, record, io_buffer, __cu)? } }; + let __r_arr: [G; OUT_268] = { let __args: [G; IN_268] = [__v_11, __v_12, __v_13, __v_14, __v_15]; let __cu = unconstrained; if let Some(result) = record.function_queries[268].get_mut(&__args[..]) { if !__cu && *result.multiplicity == G::ZERO { aiur_fn_268(__args, record, io_buffer, false)? } else { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_268] = unsafe { *(result.output.as_ptr() as *const [G; OUT_268]) }; __ret } } else { aiur_fn_268(__args, record, io_buffer, __cu)? } }; let __v_18: G = __r_arr[0]; let __r_arr: [G; OUT_16] = { let __args: [G; IN_16] = [__v_2, __v_3, __v_4, __v_5, __v_6, __v_7, __v_8, __v_9]; let __cu = unconstrained; if let Some(result) = record.function_queries[16].get_mut(&__args[..]) { if !__cu && *result.multiplicity == G::ZERO { aiur_fn_16(__args, record, io_buffer, false)? } else { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_16] = unsafe { *(result.output.as_ptr() as *const [G; OUT_16]) }; __ret } } else { aiur_fn_16(__args, record, io_buffer, __cu)? } }; let __v_19: G = __r_arr[0]; @@ -26047,8 +25773,8 @@ fn aiur_fn_273( 0u64 => { let __v_20: G = G::from_u64(1); let __v_21: G = G::from_u64(0); - let __ret: [G; OUT_273] = [__v_20, __v_19, __v_17, __v_18, __v_1, __v_16, __v_21, __v_21, __v_21, __v_21, __v_21, __v_21]; - if let Some(result) = record.function_queries[273].get_mut(&inp[..]) { debug_assert_eq!(result.output, &__ret[..]); if !unconstrained { *result.multiplicity += G::ONE; } } else { record.function_queries[273].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained)); }; + let __ret: [G; OUT_269] = [__v_20, __v_19, __v_17, __v_18, __v_1, __v_16, __v_21, __v_21, __v_21, __v_21, __v_21, __v_21]; + if let Some(result) = record.function_queries[269].get_mut(&inp[..]) { debug_assert_eq!(result.output, &__ret[..]); if !unconstrained { *result.multiplicity += G::ONE; } } else { record.function_queries[269].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained)); }; return Ok(__ret); }, 1u64 => { @@ -26066,15 +25792,15 @@ fn aiur_fn_273( let __v_20: G = __mc_out___mc_0[0]; let __v_21: G = G::from_u64(3); let __v_22: G = G::from_u64(0); - let __ret: [G; OUT_273] = [__v_21, __v_19, __v_17, __v_18, __v_20, __v_22, __v_22, __v_22, __v_22, __v_22, __v_22, __v_22]; - if let Some(result) = record.function_queries[273].get_mut(&inp[..]) { debug_assert_eq!(result.output, &__ret[..]); if !unconstrained { *result.multiplicity += G::ONE; } } else { record.function_queries[273].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained)); }; + let __ret: [G; OUT_269] = [__v_21, __v_19, __v_17, __v_18, __v_20, __v_22, __v_22, __v_22, __v_22, __v_22, __v_22, __v_22]; + if let Some(result) = record.function_queries[269].get_mut(&inp[..]) { debug_assert_eq!(result.output, &__ret[..]); if !unconstrained { *result.multiplicity += G::ONE; } } else { record.function_queries[269].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained)); }; return Ok(__ret); }, 2u64 => { let __v_20: G = G::from_u64(2); let __v_21: G = G::from_u64(0); - let __ret: [G; OUT_273] = [__v_20, __v_19, __v_17, __v_18, __v_21, __v_21, __v_21, __v_21, __v_21, __v_21, __v_21, __v_21]; - if let Some(result) = record.function_queries[273].get_mut(&inp[..]) { debug_assert_eq!(result.output, &__ret[..]); if !unconstrained { *result.multiplicity += G::ONE; } } else { record.function_queries[273].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained)); }; + let __ret: [G; OUT_269] = [__v_20, __v_19, __v_17, __v_18, __v_21, __v_21, __v_21, __v_21, __v_21, __v_21, __v_21, __v_21]; + if let Some(result) = record.function_queries[269].get_mut(&inp[..]) { debug_assert_eq!(result.output, &__ret[..]); if !unconstrained { *result.multiplicity += G::ONE; } } else { record.function_queries[269].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained)); }; return Ok(__ret); }, _ => { @@ -26086,15 +25812,15 @@ fn aiur_fn_273( }) } -const INPUT_SIZE_274: usize = 14; -const IN_274: usize = 14; -const OUT_274: usize = 12; -fn aiur_fn_274( - inp: [G; IN_274], +const INPUT_SIZE_270: usize = 14; +const IN_270: usize = 14; +const OUT_270: usize = 12; +fn aiur_fn_270( + inp: [G; IN_270], record: &mut QueryRecord, io_buffer: &mut IOBuffer, unconstrained: bool, -) -> Result<[G; OUT_274], ExecError> { +) -> Result<[G; OUT_270], ExecError> { stacker::maybe_grow(64 * 1024, 4 * 1024 * 1024, || { let __v_0: G = inp[0]; let __v_1: G = inp[1]; @@ -26112,29 +25838,29 @@ fn aiur_fn_274( let __v_13: G = inp[13]; match __v_0.as_canonical_u64() { _ => { - let __r_arr: [G; OUT_272] = { let __args: [G; IN_272] = [__v_9, __v_10, __v_11, __v_12, __v_13]; let __cu = unconstrained; if let Some(result) = record.function_queries[272].get_mut(&__args[..]) { if !__cu && *result.multiplicity == G::ZERO { aiur_fn_272(__args, record, io_buffer, false)? } else { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_272] = unsafe { *(result.output.as_ptr() as *const [G; OUT_272]) }; __ret } } else { aiur_fn_272(__args, record, io_buffer, __cu)? } }; + let __r_arr: [G; OUT_268] = { let __args: [G; IN_268] = [__v_9, __v_10, __v_11, __v_12, __v_13]; let __cu = unconstrained; if let Some(result) = record.function_queries[268].get_mut(&__args[..]) { if !__cu && *result.multiplicity == G::ZERO { aiur_fn_268(__args, record, io_buffer, false)? } else { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_268] = unsafe { *(result.output.as_ptr() as *const [G; OUT_268]) }; __ret } } else { aiur_fn_268(__args, record, io_buffer, __cu)? } }; let __v_14: G = __r_arr[0]; let __v_15: G = G::from_u64(0); let __r_arr: [G; OUT_16] = { let __args: [G; IN_16] = [__v_1, __v_2, __v_3, __v_4, __v_5, __v_6, __v_7, __v_8]; let __cu = unconstrained; if let Some(result) = record.function_queries[16].get_mut(&__args[..]) { if !__cu && *result.multiplicity == G::ZERO { aiur_fn_16(__args, record, io_buffer, false)? } else { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_16] = unsafe { *(result.output.as_ptr() as *const [G; OUT_16]) }; __ret } } else { aiur_fn_16(__args, record, io_buffer, __cu)? } }; let __v_16: G = __r_arr[0]; let __v_17: G = G::from_u64(0); - let __ret: [G; OUT_274] = [__v_15, __v_16, __v_14, __v_0, __v_17, __v_17, __v_17, __v_17, __v_17, __v_17, __v_17, __v_17]; - if let Some(result) = record.function_queries[274].get_mut(&inp[..]) { debug_assert_eq!(result.output, &__ret[..]); if !unconstrained { *result.multiplicity += G::ONE; } } else { record.function_queries[274].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained)); }; + let __ret: [G; OUT_270] = [__v_15, __v_16, __v_14, __v_0, __v_17, __v_17, __v_17, __v_17, __v_17, __v_17, __v_17, __v_17]; + if let Some(result) = record.function_queries[270].get_mut(&inp[..]) { debug_assert_eq!(result.output, &__ret[..]); if !unconstrained { *result.multiplicity += G::ONE; } } else { record.function_queries[270].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained)); }; return Ok(__ret); }, } }) } -const INPUT_SIZE_275: usize = 14; -const IN_275: usize = 14; -const OUT_275: usize = 12; -fn aiur_fn_275( - inp: [G; IN_275], +const INPUT_SIZE_271: usize = 14; +const IN_271: usize = 14; +const OUT_271: usize = 12; +fn aiur_fn_271( + inp: [G; IN_271], record: &mut QueryRecord, io_buffer: &mut IOBuffer, unconstrained: bool, -) -> Result<[G; OUT_275], ExecError> { +) -> Result<[G; OUT_271], ExecError> { stacker::maybe_grow(64 * 1024, 4 * 1024 * 1024, || { let __v_0: G = inp[0]; let __v_1: G = inp[1]; @@ -26152,29 +25878,29 @@ fn aiur_fn_275( let __v_13: G = inp[13]; match __v_0.as_canonical_u64() { _ => { - let __r_arr: [G; OUT_272] = { let __args: [G; IN_272] = [__v_9, __v_10, __v_11, __v_12, __v_13]; let __cu = unconstrained; if let Some(result) = record.function_queries[272].get_mut(&__args[..]) { if !__cu && *result.multiplicity == G::ZERO { aiur_fn_272(__args, record, io_buffer, false)? } else { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_272] = unsafe { *(result.output.as_ptr() as *const [G; OUT_272]) }; __ret } } else { aiur_fn_272(__args, record, io_buffer, __cu)? } }; + let __r_arr: [G; OUT_268] = { let __args: [G; IN_268] = [__v_9, __v_10, __v_11, __v_12, __v_13]; let __cu = unconstrained; if let Some(result) = record.function_queries[268].get_mut(&__args[..]) { if !__cu && *result.multiplicity == G::ZERO { aiur_fn_268(__args, record, io_buffer, false)? } else { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_268] = unsafe { *(result.output.as_ptr() as *const [G; OUT_268]) }; __ret } } else { aiur_fn_268(__args, record, io_buffer, __cu)? } }; let __v_14: G = __r_arr[0]; let __v_15: G = G::from_u64(4); let __r_arr: [G; OUT_16] = { let __args: [G; IN_16] = [__v_1, __v_2, __v_3, __v_4, __v_5, __v_6, __v_7, __v_8]; let __cu = unconstrained; if let Some(result) = record.function_queries[16].get_mut(&__args[..]) { if !__cu && *result.multiplicity == G::ZERO { aiur_fn_16(__args, record, io_buffer, false)? } else { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_16] = unsafe { *(result.output.as_ptr() as *const [G; OUT_16]) }; __ret } } else { aiur_fn_16(__args, record, io_buffer, __cu)? } }; let __v_16: G = __r_arr[0]; let __v_17: G = G::from_u64(0); - let __ret: [G; OUT_275] = [__v_15, __v_16, __v_14, __v_0, __v_17, __v_17, __v_17, __v_17, __v_17, __v_17, __v_17, __v_17]; - if let Some(result) = record.function_queries[275].get_mut(&inp[..]) { debug_assert_eq!(result.output, &__ret[..]); if !unconstrained { *result.multiplicity += G::ONE; } } else { record.function_queries[275].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained)); }; + let __ret: [G; OUT_271] = [__v_15, __v_16, __v_14, __v_0, __v_17, __v_17, __v_17, __v_17, __v_17, __v_17, __v_17, __v_17]; + if let Some(result) = record.function_queries[271].get_mut(&inp[..]) { debug_assert_eq!(result.output, &__ret[..]); if !unconstrained { *result.multiplicity += G::ONE; } } else { record.function_queries[271].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained)); }; return Ok(__ret); }, } }) } -const INPUT_SIZE_276: usize = 1; -const IN_276: usize = 1; -const OUT_276: usize = 1; -fn aiur_fn_276( - inp: [G; IN_276], +const INPUT_SIZE_272: usize = 1; +const IN_272: usize = 1; +const OUT_272: usize = 1; +fn aiur_fn_272( + inp: [G; IN_272], record: &mut QueryRecord, io_buffer: &mut IOBuffer, unconstrained: bool, -) -> Result<[G; OUT_276], ExecError> { +) -> Result<[G; OUT_272], ExecError> { stacker::maybe_grow(64 * 1024, 4 * 1024 * 1024, || { let __v_0: G = inp[0]; let __loaded: [G; 36] = { let __mq = record.memory_queries.get_mut(&36).ok_or(ExecError::InvalidMemorySize(36))?; let __ptr_u64 = __v_0.as_canonical_u64(); let __ptr_usize = usize::try_from(__ptr_u64).ok().ok_or(ExecError::PointerTooLarge(__ptr_u64))?; let (__args, __mult) = __mq.get_index_mut(__ptr_usize).ok_or(ExecError::UnboundPointer { ptr: __ptr_u64, size: 36 })?; if !unconstrained { *__mult += G::ONE; } let __arr: [G; 36] = __args[..36].try_into().unwrap(); __arr }; @@ -26217,17 +25943,17 @@ fn aiur_fn_276( match __v_1.as_canonical_u64() { 1u64 => { let __v_37: G = G::from_u64(0); - let __ret: [G; OUT_276] = [__v_37]; - if let Some(result) = record.function_queries[276].get_mut(&inp[..]) { debug_assert_eq!(result.output, &__ret[..]); if !unconstrained { *result.multiplicity += G::ONE; } } else { record.function_queries[276].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained)); }; + let __ret: [G; OUT_272] = [__v_37]; + if let Some(result) = record.function_queries[272].get_mut(&inp[..]) { debug_assert_eq!(result.output, &__ret[..]); if !unconstrained { *result.multiplicity += G::ONE; } } else { record.function_queries[272].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained)); }; return Ok(__ret); }, 0u64 => { - let __r_arr: [G; OUT_276] = { let __args: [G; IN_276] = [__v_36]; let __cu = unconstrained; if let Some(result) = record.function_queries[276].get_mut(&__args[..]) { if !__cu && *result.multiplicity == G::ZERO { aiur_fn_276(__args, record, io_buffer, false)? } else { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_276] = unsafe { *(result.output.as_ptr() as *const [G; OUT_276]) }; __ret } } else { aiur_fn_276(__args, record, io_buffer, __cu)? } }; + let __r_arr: [G; OUT_272] = { let __args: [G; IN_272] = [__v_36]; let __cu = unconstrained; if let Some(result) = record.function_queries[272].get_mut(&__args[..]) { if !__cu && *result.multiplicity == G::ZERO { aiur_fn_272(__args, record, io_buffer, false)? } else { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_272] = unsafe { *(result.output.as_ptr() as *const [G; OUT_272]) }; __ret } } else { aiur_fn_272(__args, record, io_buffer, __cu)? } }; let __v_37: G = __r_arr[0]; let __v_38: G = G::from_u64(1); let __v_39: G = (__v_37 + __v_38); - let __ret: [G; OUT_276] = [__v_39]; - if let Some(result) = record.function_queries[276].get_mut(&inp[..]) { debug_assert_eq!(result.output, &__ret[..]); if !unconstrained { *result.multiplicity += G::ONE; } } else { record.function_queries[276].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained)); }; + let __ret: [G; OUT_272] = [__v_39]; + if let Some(result) = record.function_queries[272].get_mut(&inp[..]) { debug_assert_eq!(result.output, &__ret[..]); if !unconstrained { *result.multiplicity += G::ONE; } } else { record.function_queries[272].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained)); }; return Ok(__ret); }, _ => { @@ -26237,15 +25963,15 @@ fn aiur_fn_276( }) } -const INPUT_SIZE_277: usize = 2; -const IN_277: usize = 2; -const OUT_277: usize = 34; -fn aiur_fn_277( - inp: [G; IN_277], +const INPUT_SIZE_273: usize = 2; +const IN_273: usize = 2; +const OUT_273: usize = 34; +fn aiur_fn_273( + inp: [G; IN_273], record: &mut QueryRecord, io_buffer: &mut IOBuffer, unconstrained: bool, -) -> Result<[G; OUT_277], ExecError> { +) -> Result<[G; OUT_273], ExecError> { stacker::maybe_grow(64 * 1024, 4 * 1024 * 1024, || { let __v_0: G = inp[0]; let __v_1: G = inp[1]; @@ -26290,14 +26016,14 @@ fn aiur_fn_277( 0u64 => { match __v_1.as_canonical_u64() { 0u64 => { - let __ret: [G; OUT_277] = [__v_3, __v_4, __v_5, __v_6, __v_7, __v_8, __v_9, __v_10, __v_11, __v_12, __v_13, __v_14, __v_15, __v_16, __v_17, __v_18, __v_19, __v_20, __v_21, __v_22, __v_23, __v_24, __v_25, __v_26, __v_27, __v_28, __v_29, __v_30, __v_31, __v_32, __v_33, __v_34, __v_35, __v_36]; - if let Some(result) = record.function_queries[277].get_mut(&inp[..]) { debug_assert_eq!(result.output, &__ret[..]); if !unconstrained { *result.multiplicity += G::ONE; } } else { record.function_queries[277].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained)); }; + let __ret: [G; OUT_273] = [__v_3, __v_4, __v_5, __v_6, __v_7, __v_8, __v_9, __v_10, __v_11, __v_12, __v_13, __v_14, __v_15, __v_16, __v_17, __v_18, __v_19, __v_20, __v_21, __v_22, __v_23, __v_24, __v_25, __v_26, __v_27, __v_28, __v_29, __v_30, __v_31, __v_32, __v_33, __v_34, __v_35, __v_36]; + if let Some(result) = record.function_queries[273].get_mut(&inp[..]) { debug_assert_eq!(result.output, &__ret[..]); if !unconstrained { *result.multiplicity += G::ONE; } } else { record.function_queries[273].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained)); }; return Ok(__ret); }, _ => { let __v_38: G = G::from_u64(1); let __v_39: G = (__v_1 - __v_38); - let __r_arr: [G; OUT_277] = { let __args: [G; IN_277] = [__v_37, __v_39]; let __cu = unconstrained; if let Some(result) = record.function_queries[277].get_mut(&__args[..]) { if !__cu && *result.multiplicity == G::ZERO { aiur_fn_277(__args, record, io_buffer, false)? } else { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_277] = unsafe { *(result.output.as_ptr() as *const [G; OUT_277]) }; __ret } } else { aiur_fn_277(__args, record, io_buffer, __cu)? } }; + let __r_arr: [G; OUT_273] = { let __args: [G; IN_273] = [__v_37, __v_39]; let __cu = unconstrained; if let Some(result) = record.function_queries[273].get_mut(&__args[..]) { if !__cu && *result.multiplicity == G::ZERO { aiur_fn_273(__args, record, io_buffer, false)? } else { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_273] = unsafe { *(result.output.as_ptr() as *const [G; OUT_273]) }; __ret } } else { aiur_fn_273(__args, record, io_buffer, __cu)? } }; let __v_40: G = __r_arr[0]; let __v_41: G = __r_arr[1]; let __v_42: G = __r_arr[2]; @@ -26332,8 +26058,8 @@ fn aiur_fn_277( let __v_71: G = __r_arr[31]; let __v_72: G = __r_arr[32]; let __v_73: G = __r_arr[33]; - let __ret: [G; OUT_277] = [__v_40, __v_41, __v_42, __v_43, __v_44, __v_45, __v_46, __v_47, __v_48, __v_49, __v_50, __v_51, __v_52, __v_53, __v_54, __v_55, __v_56, __v_57, __v_58, __v_59, __v_60, __v_61, __v_62, __v_63, __v_64, __v_65, __v_66, __v_67, __v_68, __v_69, __v_70, __v_71, __v_72, __v_73]; - if let Some(result) = record.function_queries[277].get_mut(&inp[..]) { debug_assert_eq!(result.output, &__ret[..]); if !unconstrained { *result.multiplicity += G::ONE; } } else { record.function_queries[277].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained)); }; + let __ret: [G; OUT_273] = [__v_40, __v_41, __v_42, __v_43, __v_44, __v_45, __v_46, __v_47, __v_48, __v_49, __v_50, __v_51, __v_52, __v_53, __v_54, __v_55, __v_56, __v_57, __v_58, __v_59, __v_60, __v_61, __v_62, __v_63, __v_64, __v_65, __v_66, __v_67, __v_68, __v_69, __v_70, __v_71, __v_72, __v_73]; + if let Some(result) = record.function_queries[273].get_mut(&inp[..]) { debug_assert_eq!(result.output, &__ret[..]); if !unconstrained { *result.multiplicity += G::ONE; } } else { record.function_queries[273].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained)); }; return Ok(__ret); }, } @@ -26345,15 +26071,15 @@ fn aiur_fn_277( }) } -const INPUT_SIZE_278: usize = 33; -const IN_278: usize = 33; -const OUT_278: usize = 12; -fn aiur_fn_278( - inp: [G; IN_278], +const INPUT_SIZE_274: usize = 33; +const IN_274: usize = 33; +const OUT_274: usize = 12; +fn aiur_fn_274( + inp: [G; IN_274], record: &mut QueryRecord, io_buffer: &mut IOBuffer, unconstrained: bool, -) -> Result<[G; OUT_278], ExecError> { +) -> Result<[G; OUT_274], ExecError> { stacker::maybe_grow(64 * 1024, 4 * 1024 * 1024, || { let __v_0: G = inp[0]; let __v_1: G = inp[1]; @@ -26390,7 +26116,7 @@ fn aiur_fn_278( let __v_32: G = inp[32]; match __v_0.as_canonical_u64() { _ => { - let __r_arr: [G; OUT_272] = { let __args: [G; IN_272] = [__v_25, __v_29, __v_30, __v_31, __v_32]; let __cu = unconstrained; if let Some(result) = record.function_queries[272].get_mut(&__args[..]) { if !__cu && *result.multiplicity == G::ZERO { aiur_fn_272(__args, record, io_buffer, false)? } else { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_272] = unsafe { *(result.output.as_ptr() as *const [G; OUT_272]) }; __ret } } else { aiur_fn_272(__args, record, io_buffer, __cu)? } }; + let __r_arr: [G; OUT_268] = { let __args: [G; IN_268] = [__v_25, __v_29, __v_30, __v_31, __v_32]; let __cu = unconstrained; if let Some(result) = record.function_queries[268].get_mut(&__args[..]) { if !__cu && *result.multiplicity == G::ZERO { aiur_fn_268(__args, record, io_buffer, false)? } else { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_268] = unsafe { *(result.output.as_ptr() as *const [G; OUT_268]) }; __ret } } else { aiur_fn_268(__args, record, io_buffer, __cu)? } }; let __v_33: G = __r_arr[0]; let __v_34: G = G::from_u64(5); let __r_arr: [G; OUT_16] = { let __args: [G; IN_16] = [__v_1, __v_2, __v_3, __v_4, __v_5, __v_6, __v_7, __v_8]; let __cu = unconstrained; if let Some(result) = record.function_queries[16].get_mut(&__args[..]) { if !__cu && *result.multiplicity == G::ZERO { aiur_fn_16(__args, record, io_buffer, false)? } else { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_16] = unsafe { *(result.output.as_ptr() as *const [G; OUT_16]) }; __ret } } else { aiur_fn_16(__args, record, io_buffer, __cu)? } }; @@ -26399,26 +26125,26 @@ fn aiur_fn_278( let __v_36: G = __r_arr[0]; let __r_arr: [G; OUT_16] = { let __args: [G; IN_16] = [__v_17, __v_18, __v_19, __v_20, __v_21, __v_22, __v_23, __v_24]; let __cu = unconstrained; if let Some(result) = record.function_queries[16].get_mut(&__args[..]) { if !__cu && *result.multiplicity == G::ZERO { aiur_fn_16(__args, record, io_buffer, false)? } else { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_16] = unsafe { *(result.output.as_ptr() as *const [G; OUT_16]) }; __ret } } else { aiur_fn_16(__args, record, io_buffer, __cu)? } }; let __v_37: G = __r_arr[0]; - let __r_arr: [G; OUT_276] = { let __args: [G; IN_276] = [__v_26]; let __cu = unconstrained; if let Some(result) = record.function_queries[276].get_mut(&__args[..]) { if !__cu && *result.multiplicity == G::ZERO { aiur_fn_276(__args, record, io_buffer, false)? } else { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_276] = unsafe { *(result.output.as_ptr() as *const [G; OUT_276]) }; __ret } } else { aiur_fn_276(__args, record, io_buffer, __cu)? } }; + let __r_arr: [G; OUT_272] = { let __args: [G; IN_272] = [__v_26]; let __cu = unconstrained; if let Some(result) = record.function_queries[272].get_mut(&__args[..]) { if !__cu && *result.multiplicity == G::ZERO { aiur_fn_272(__args, record, io_buffer, false)? } else { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_272] = unsafe { *(result.output.as_ptr() as *const [G; OUT_272]) }; __ret } } else { aiur_fn_272(__args, record, io_buffer, __cu)? } }; let __v_38: G = __r_arr[0]; let __v_39: G = G::from_u64(0); - let __ret: [G; OUT_278] = [__v_34, __v_35, __v_33, __v_36, __v_37, __v_38, __v_0, __v_27, __v_28, __v_39, __v_39, __v_39]; - if let Some(result) = record.function_queries[278].get_mut(&inp[..]) { debug_assert_eq!(result.output, &__ret[..]); if !unconstrained { *result.multiplicity += G::ONE; } } else { record.function_queries[278].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained)); }; + let __ret: [G; OUT_274] = [__v_34, __v_35, __v_33, __v_36, __v_37, __v_38, __v_0, __v_27, __v_28, __v_39, __v_39, __v_39]; + if let Some(result) = record.function_queries[274].get_mut(&inp[..]) { debug_assert_eq!(result.output, &__ret[..]); if !unconstrained { *result.multiplicity += G::ONE; } } else { record.function_queries[274].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained)); }; return Ok(__ret); }, } }) } -const INPUT_SIZE_279: usize = 40; -const IN_279: usize = 40; -const OUT_279: usize = 12; -fn aiur_fn_279( - inp: [G; IN_279], +const INPUT_SIZE_275: usize = 40; +const IN_275: usize = 40; +const OUT_275: usize = 12; +fn aiur_fn_275( + inp: [G; IN_275], record: &mut QueryRecord, io_buffer: &mut IOBuffer, unconstrained: bool, -) -> Result<[G; OUT_279], ExecError> { +) -> Result<[G; OUT_275], ExecError> { stacker::maybe_grow(64 * 1024, 4 * 1024 * 1024, || { let __v_0: G = inp[0]; let __v_1: G = inp[1]; @@ -26462,7 +26188,7 @@ fn aiur_fn_279( let __v_39: G = inp[39]; match __v_0.as_canonical_u64() { _ => { - let __r_arr: [G; OUT_272] = { let __args: [G; IN_272] = [__v_33, __v_36, __v_37, __v_38, __v_39]; let __cu = unconstrained; if let Some(result) = record.function_queries[272].get_mut(&__args[..]) { if !__cu && *result.multiplicity == G::ZERO { aiur_fn_272(__args, record, io_buffer, false)? } else { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_272] = unsafe { *(result.output.as_ptr() as *const [G; OUT_272]) }; __ret } } else { aiur_fn_272(__args, record, io_buffer, __cu)? } }; + let __r_arr: [G; OUT_268] = { let __args: [G; IN_268] = [__v_33, __v_36, __v_37, __v_38, __v_39]; let __cu = unconstrained; if let Some(result) = record.function_queries[268].get_mut(&__args[..]) { if !__cu && *result.multiplicity == G::ZERO { aiur_fn_268(__args, record, io_buffer, false)? } else { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_268] = unsafe { *(result.output.as_ptr() as *const [G; OUT_268]) }; __ret } } else { aiur_fn_268(__args, record, io_buffer, __cu)? } }; let __v_40: G = __r_arr[0]; let __v_41: G = G::from_u64(6); let __r_arr: [G; OUT_16] = { let __args: [G; IN_16] = [__v_1, __v_2, __v_3, __v_4, __v_5, __v_6, __v_7, __v_8]; let __cu = unconstrained; if let Some(result) = record.function_queries[16].get_mut(&__args[..]) { if !__cu && *result.multiplicity == G::ZERO { aiur_fn_16(__args, record, io_buffer, false)? } else { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_16] = unsafe { *(result.output.as_ptr() as *const [G; OUT_16]) }; __ret } } else { aiur_fn_16(__args, record, io_buffer, __cu)? } }; @@ -26474,23 +26200,23 @@ fn aiur_fn_279( let __r_arr: [G; OUT_16] = { let __args: [G; IN_16] = [__v_25, __v_26, __v_27, __v_28, __v_29, __v_30, __v_31, __v_32]; let __cu = unconstrained; if let Some(result) = record.function_queries[16].get_mut(&__args[..]) { if !__cu && *result.multiplicity == G::ZERO { aiur_fn_16(__args, record, io_buffer, false)? } else { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_16] = unsafe { *(result.output.as_ptr() as *const [G; OUT_16]) }; __ret } } else { aiur_fn_16(__args, record, io_buffer, __cu)? } }; let __v_45: G = __r_arr[0]; let __v_46: G = G::from_u64(0); - let __ret: [G; OUT_279] = [__v_41, __v_42, __v_40, __v_34, __v_35, __v_43, __v_44, __v_45, __v_0, __v_46, __v_46, __v_46]; - if let Some(result) = record.function_queries[279].get_mut(&inp[..]) { debug_assert_eq!(result.output, &__ret[..]); if !unconstrained { *result.multiplicity += G::ONE; } } else { record.function_queries[279].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained)); }; + let __ret: [G; OUT_275] = [__v_41, __v_42, __v_40, __v_34, __v_35, __v_43, __v_44, __v_45, __v_0, __v_46, __v_46, __v_46]; + if let Some(result) = record.function_queries[275].get_mut(&inp[..]) { debug_assert_eq!(result.output, &__ret[..]); if !unconstrained { *result.multiplicity += G::ONE; } } else { record.function_queries[275].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained)); }; return Ok(__ret); }, } }) } -const INPUT_SIZE_280: usize = 6; -const IN_280: usize = 6; -const OUT_280: usize = 1; -fn aiur_fn_280( - inp: [G; IN_280], +const INPUT_SIZE_276: usize = 6; +const IN_276: usize = 6; +const OUT_276: usize = 1; +fn aiur_fn_276( + inp: [G; IN_276], record: &mut QueryRecord, io_buffer: &mut IOBuffer, unconstrained: bool, -) -> Result<[G; OUT_280], ExecError> { +) -> Result<[G; OUT_276], ExecError> { stacker::maybe_grow(64 * 1024, 4 * 1024 * 1024, || { let __v_0: G = inp[0]; let __v_1: G = inp[1]; @@ -26515,25 +26241,25 @@ fn aiur_fn_280( let __v_17: G = G::from_u64(1); let __v_18: G = G::from_u64(1); let __v_19: G = { let __values: [G; 5] = [__v_17, __v_18, __v_18, __v_18, __v_18]; let __mq = record.memory_queries.get_mut(&5).ok_or(ExecError::InvalidMemorySize(5))?; if let Some(result) = __mq.get_mut(&__values[..]) { if !unconstrained { *result.multiplicity += G::ONE; } result.output[0] } else { let __ptr = G::from_usize(__mq.len()); __mq.insert(&__values[..], &[__ptr], G::from_bool(!unconstrained)); __ptr } }; - let __ret: [G; OUT_280] = [__v_19]; - if let Some(result) = record.function_queries[280].get_mut(&inp[..]) { debug_assert_eq!(result.output, &__ret[..]); if !unconstrained { *result.multiplicity += G::ONE; } } else { record.function_queries[280].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained)); }; + let __ret: [G; OUT_276] = [__v_19]; + if let Some(result) = record.function_queries[276].get_mut(&inp[..]) { debug_assert_eq!(result.output, &__ret[..]); if !unconstrained { *result.multiplicity += G::ONE; } } else { record.function_queries[276].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained)); }; return Ok(__ret); }, 0u64 => { match __v_7.as_canonical_u64() { _ => { - let __r_arr: [G; OUT_272] = { let __args: [G; IN_272] = [__v_15, __v_1, __v_2, __v_3, __v_4]; let __cu = unconstrained; if let Some(result) = record.function_queries[272].get_mut(&__args[..]) { if !__cu && *result.multiplicity == G::ZERO { aiur_fn_272(__args, record, io_buffer, false)? } else { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_272] = unsafe { *(result.output.as_ptr() as *const [G; OUT_272]) }; __ret } } else { aiur_fn_272(__args, record, io_buffer, __cu)? } }; + let __r_arr: [G; OUT_268] = { let __args: [G; IN_268] = [__v_15, __v_1, __v_2, __v_3, __v_4]; let __cu = unconstrained; if let Some(result) = record.function_queries[268].get_mut(&__args[..]) { if !__cu && *result.multiplicity == G::ZERO { aiur_fn_268(__args, record, io_buffer, false)? } else { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_268] = unsafe { *(result.output.as_ptr() as *const [G; OUT_268]) }; __ret } } else { aiur_fn_268(__args, record, io_buffer, __cu)? } }; let __v_17: G = __r_arr[0]; let __v_18: G = G::from_u64(0); let __r_arr: [G; OUT_16] = { let __args: [G; IN_16] = [__v_7, __v_8, __v_9, __v_10, __v_11, __v_12, __v_13, __v_14]; let __cu = unconstrained; if let Some(result) = record.function_queries[16].get_mut(&__args[..]) { if !__cu && *result.multiplicity == G::ZERO { aiur_fn_16(__args, record, io_buffer, false)? } else { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_16] = unsafe { *(result.output.as_ptr() as *const [G; OUT_16]) }; __ret } } else { aiur_fn_16(__args, record, io_buffer, __cu)? } }; let __v_19: G = __r_arr[0]; let __v_20: G = G::from_u64(1); let __v_21: G = (__v_5 + __v_20); - let __r_arr: [G; OUT_280] = { let __args: [G; IN_280] = [__v_16, __v_1, __v_2, __v_3, __v_4, __v_21]; let __cu = unconstrained; if let Some(result) = record.function_queries[280].get_mut(&__args[..]) { if !__cu && *result.multiplicity == G::ZERO { aiur_fn_280(__args, record, io_buffer, false)? } else { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_280] = unsafe { *(result.output.as_ptr() as *const [G; OUT_280]) }; __ret } } else { aiur_fn_280(__args, record, io_buffer, __cu)? } }; + let __r_arr: [G; OUT_276] = { let __args: [G; IN_276] = [__v_16, __v_1, __v_2, __v_3, __v_4, __v_21]; let __cu = unconstrained; if let Some(result) = record.function_queries[276].get_mut(&__args[..]) { if !__cu && *result.multiplicity == G::ZERO { aiur_fn_276(__args, record, io_buffer, false)? } else { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_276] = unsafe { *(result.output.as_ptr() as *const [G; OUT_276]) }; __ret } } else { aiur_fn_276(__args, record, io_buffer, __cu)? } }; let __v_22: G = __r_arr[0]; let __v_23: G = { let __values: [G; 5] = [__v_18, __v_5, __v_19, __v_17, __v_22]; let __mq = record.memory_queries.get_mut(&5).ok_or(ExecError::InvalidMemorySize(5))?; if let Some(result) = __mq.get_mut(&__values[..]) { if !unconstrained { *result.multiplicity += G::ONE; } result.output[0] } else { let __ptr = G::from_usize(__mq.len()); __mq.insert(&__values[..], &[__ptr], G::from_bool(!unconstrained)); __ptr } }; - let __ret: [G; OUT_280] = [__v_23]; - if let Some(result) = record.function_queries[280].get_mut(&inp[..]) { debug_assert_eq!(result.output, &__ret[..]); if !unconstrained { *result.multiplicity += G::ONE; } } else { record.function_queries[280].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained)); }; + let __ret: [G; OUT_276] = [__v_23]; + if let Some(result) = record.function_queries[276].get_mut(&inp[..]) { debug_assert_eq!(result.output, &__ret[..]); if !unconstrained { *result.multiplicity += G::ONE; } } else { record.function_queries[276].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained)); }; return Ok(__ret); }, } @@ -26545,15 +26271,15 @@ fn aiur_fn_280( }) } -const INPUT_SIZE_281: usize = 50; -const IN_281: usize = 50; -const OUT_281: usize = 12; -fn aiur_fn_281( - inp: [G; IN_281], +const INPUT_SIZE_277: usize = 50; +const IN_277: usize = 50; +const OUT_277: usize = 12; +fn aiur_fn_277( + inp: [G; IN_277], record: &mut QueryRecord, io_buffer: &mut IOBuffer, unconstrained: bool, -) -> Result<[G; OUT_281], ExecError> { +) -> Result<[G; OUT_277], ExecError> { stacker::maybe_grow(64 * 1024, 4 * 1024 * 1024, || { let __v_0: G = inp[0]; let __v_1: G = inp[1]; @@ -26607,10 +26333,10 @@ fn aiur_fn_281( let __v_49: G = inp[49]; match __v_0.as_canonical_u64() { _ => { - let __r_arr: [G; OUT_272] = { let __args: [G; IN_272] = [__v_42, __v_46, __v_47, __v_48, __v_49]; let __cu = unconstrained; if let Some(result) = record.function_queries[272].get_mut(&__args[..]) { if !__cu && *result.multiplicity == G::ZERO { aiur_fn_272(__args, record, io_buffer, false)? } else { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_272] = unsafe { *(result.output.as_ptr() as *const [G; OUT_272]) }; __ret } } else { aiur_fn_272(__args, record, io_buffer, __cu)? } }; + let __r_arr: [G; OUT_268] = { let __args: [G; IN_268] = [__v_42, __v_46, __v_47, __v_48, __v_49]; let __cu = unconstrained; if let Some(result) = record.function_queries[268].get_mut(&__args[..]) { if !__cu && *result.multiplicity == G::ZERO { aiur_fn_268(__args, record, io_buffer, false)? } else { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_268] = unsafe { *(result.output.as_ptr() as *const [G; OUT_268]) }; __ret } } else { aiur_fn_268(__args, record, io_buffer, __cu)? } }; let __v_50: G = __r_arr[0]; let __v_51: G = G::from_u64(0); - let __r_arr: [G; OUT_280] = { let __args: [G; IN_280] = [__v_43, __v_46, __v_47, __v_48, __v_49, __v_51]; let __cu = unconstrained; if let Some(result) = record.function_queries[280].get_mut(&__args[..]) { if !__cu && *result.multiplicity == G::ZERO { aiur_fn_280(__args, record, io_buffer, false)? } else { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_280] = unsafe { *(result.output.as_ptr() as *const [G; OUT_280]) }; __ret } } else { aiur_fn_280(__args, record, io_buffer, __cu)? } }; + let __r_arr: [G; OUT_276] = { let __args: [G; IN_276] = [__v_43, __v_46, __v_47, __v_48, __v_49, __v_51]; let __cu = unconstrained; if let Some(result) = record.function_queries[276].get_mut(&__args[..]) { if !__cu && *result.multiplicity == G::ZERO { aiur_fn_276(__args, record, io_buffer, false)? } else { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_276] = unsafe { *(result.output.as_ptr() as *const [G; OUT_276]) }; __ret } } else { aiur_fn_276(__args, record, io_buffer, __cu)? } }; let __v_52: G = __r_arr[0]; let __v_53: G = G::from_u64(7); let __r_arr: [G; OUT_16] = { let __args: [G; IN_16] = [__v_2, __v_3, __v_4, __v_5, __v_6, __v_7, __v_8, __v_9]; let __cu = unconstrained; if let Some(result) = record.function_queries[16].get_mut(&__args[..]) { if !__cu && *result.multiplicity == G::ZERO { aiur_fn_16(__args, record, io_buffer, false)? } else { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_16] = unsafe { *(result.output.as_ptr() as *const [G; OUT_16]) }; __ret } } else { aiur_fn_16(__args, record, io_buffer, __cu)? } }; @@ -26623,23 +26349,23 @@ fn aiur_fn_281( let __v_57: G = __r_arr[0]; let __r_arr: [G; OUT_16] = { let __args: [G; IN_16] = [__v_34, __v_35, __v_36, __v_37, __v_38, __v_39, __v_40, __v_41]; let __cu = unconstrained; if let Some(result) = record.function_queries[16].get_mut(&__args[..]) { if !__cu && *result.multiplicity == G::ZERO { aiur_fn_16(__args, record, io_buffer, false)? } else { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_16] = unsafe { *(result.output.as_ptr() as *const [G; OUT_16]) }; __ret } } else { aiur_fn_16(__args, record, io_buffer, __cu)? } }; let __v_58: G = __r_arr[0]; - let __ret: [G; OUT_281] = [__v_53, __v_54, __v_50, __v_55, __v_56, __v_57, __v_58, __v_52, __v_0, __v_1, __v_44, __v_45]; - if let Some(result) = record.function_queries[281].get_mut(&inp[..]) { debug_assert_eq!(result.output, &__ret[..]); if !unconstrained { *result.multiplicity += G::ONE; } } else { record.function_queries[281].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained)); }; + let __ret: [G; OUT_277] = [__v_53, __v_54, __v_50, __v_55, __v_56, __v_57, __v_58, __v_52, __v_0, __v_1, __v_44, __v_45]; + if let Some(result) = record.function_queries[277].get_mut(&inp[..]) { debug_assert_eq!(result.output, &__ret[..]); if !unconstrained { *result.multiplicity += G::ONE; } } else { record.function_queries[277].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained)); }; return Ok(__ret); }, } }) } -const INPUT_SIZE_282: usize = 1; -const IN_282: usize = 1; -const OUT_282: usize = 48; -fn aiur_fn_282( - inp: [G; IN_282], +const INPUT_SIZE_278: usize = 1; +const IN_278: usize = 1; +const OUT_278: usize = 48; +fn aiur_fn_278( + inp: [G; IN_278], record: &mut QueryRecord, io_buffer: &mut IOBuffer, unconstrained: bool, -) -> Result<[G; OUT_282], ExecError> { +) -> Result<[G; OUT_278], ExecError> { stacker::maybe_grow(64 * 1024, 4 * 1024 * 1024, || { let __v_0: G = inp[0]; let __loaded: [G; 32] = { let __mq = record.memory_queries.get_mut(&32).ok_or(ExecError::InvalidMemorySize(32))?; let __ptr_u64 = __v_0.as_canonical_u64(); let __ptr_usize = usize::try_from(__ptr_u64).ok().ok_or(ExecError::PointerTooLarge(__ptr_u64))?; let (__args, __mult) = __mq.get_index_mut(__ptr_usize).ok_or(ExecError::UnboundPointer { ptr: __ptr_u64, size: 32 })?; if !unconstrained { *__mult += G::ONE; } let __arr: [G; 32] = __args[..32].try_into().unwrap(); __arr }; @@ -26748,21 +26474,21 @@ fn aiur_fn_282( if (__v_89 != __v_91) { return Err(ExecError::AssertEqMismatch { lhs: __v_89.as_canonical_u64(), rhs: __v_91.as_canonical_u64(), msg: Some("trailing bytes after constant on ch 2".to_string()) }); } - let __ret: [G; OUT_282] = [__v_38, __v_39, __v_40, __v_41, __v_42, __v_43, __v_44, __v_45, __v_46, __v_47, __v_48, __v_49, __v_50, __v_51, __v_52, __v_53, __v_54, __v_55, __v_56, __v_57, __v_58, __v_59, __v_60, __v_61, __v_62, __v_63, __v_64, __v_65, __v_66, __v_67, __v_68, __v_69, __v_70, __v_71, __v_72, __v_73, __v_74, __v_75, __v_76, __v_77, __v_78, __v_79, __v_80, __v_81, __v_82, __v_83, __v_84, __v_85]; - if let Some(result) = record.function_queries[282].get_mut(&inp[..]) { debug_assert_eq!(result.output, &__ret[..]); if !unconstrained { *result.multiplicity += G::ONE; } } else { record.function_queries[282].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained)); }; + let __ret: [G; OUT_278] = [__v_38, __v_39, __v_40, __v_41, __v_42, __v_43, __v_44, __v_45, __v_46, __v_47, __v_48, __v_49, __v_50, __v_51, __v_52, __v_53, __v_54, __v_55, __v_56, __v_57, __v_58, __v_59, __v_60, __v_61, __v_62, __v_63, __v_64, __v_65, __v_66, __v_67, __v_68, __v_69, __v_70, __v_71, __v_72, __v_73, __v_74, __v_75, __v_76, __v_77, __v_78, __v_79, __v_80, __v_81, __v_82, __v_83, __v_84, __v_85]; + if let Some(result) = record.function_queries[278].get_mut(&inp[..]) { debug_assert_eq!(result.output, &__ret[..]); if !unconstrained { *result.multiplicity += G::ONE; } } else { record.function_queries[278].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained)); }; return Ok(__ret); }) } -const INPUT_SIZE_283: usize = 1; -const IN_283: usize = 1; -const OUT_283: usize = 1; -fn aiur_fn_283( - inp: [G; IN_283], +const INPUT_SIZE_279: usize = 1; +const IN_279: usize = 1; +const OUT_279: usize = 1; +fn aiur_fn_279( + inp: [G; IN_279], record: &mut QueryRecord, io_buffer: &mut IOBuffer, unconstrained: bool, -) -> Result<[G; OUT_283], ExecError> { +) -> Result<[G; OUT_279], ExecError> { stacker::maybe_grow(64 * 1024, 4 * 1024 * 1024, || { let __v_0: G = inp[0]; let __loaded: [G; 32] = { let __mq = record.memory_queries.get_mut(&32).ok_or(ExecError::InvalidMemorySize(32))?; let __ptr_u64 = __v_0.as_canonical_u64(); let __ptr_usize = usize::try_from(__ptr_u64).ok().ok_or(ExecError::PointerTooLarge(__ptr_u64))?; let (__args, __mult) = __mq.get_index_mut(__ptr_usize).ok_or(ExecError::UnboundPointer { ptr: __ptr_u64, size: 32 })?; if !unconstrained { *__mult += G::ONE; } let __arr: [G; 32] = __args[..32].try_into().unwrap(); __arr }; @@ -26811,8 +26537,8 @@ fn aiur_fn_283( let __v_40: G = __loaded[2]; match __v_38.as_canonical_u64() { 0u64 => { - let __ret: [G; OUT_283] = [__v_39]; - if let Some(result) = record.function_queries[283].get_mut(&inp[..]) { debug_assert_eq!(result.output, &__ret[..]); if !unconstrained { *result.multiplicity += G::ONE; } } else { record.function_queries[283].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained)); }; + let __ret: [G; OUT_279] = [__v_39]; + if let Some(result) = record.function_queries[279].get_mut(&inp[..]) { debug_assert_eq!(result.output, &__ret[..]); if !unconstrained { *result.multiplicity += G::ONE; } } else { record.function_queries[279].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained)); }; return Ok(__ret); }, _ => { @@ -26822,15 +26548,15 @@ fn aiur_fn_283( }) } -const INPUT_SIZE_284: usize = 1; -const IN_284: usize = 1; -const OUT_284: usize = 1; -fn aiur_fn_284( - inp: [G; IN_284], +const INPUT_SIZE_280: usize = 1; +const IN_280: usize = 1; +const OUT_280: usize = 1; +fn aiur_fn_280( + inp: [G; IN_280], record: &mut QueryRecord, io_buffer: &mut IOBuffer, unconstrained: bool, -) -> Result<[G; OUT_284], ExecError> { +) -> Result<[G; OUT_280], ExecError> { stacker::maybe_grow(64 * 1024, 4 * 1024 * 1024, || { let __v_0: G = inp[0]; let __loaded: [G; 32] = { let __mq = record.memory_queries.get_mut(&32).ok_or(ExecError::InvalidMemorySize(32))?; let __ptr_u64 = __v_0.as_canonical_u64(); let __ptr_usize = usize::try_from(__ptr_u64).ok().ok_or(ExecError::PointerTooLarge(__ptr_u64))?; let (__args, __mult) = __mq.get_index_mut(__ptr_usize).ok_or(ExecError::UnboundPointer { ptr: __ptr_u64, size: 32 })?; if !unconstrained { *__mult += G::ONE; } let __arr: [G; 32] = __args[..32].try_into().unwrap(); __arr }; @@ -26874,43 +26600,43 @@ fn aiur_fn_284( let __r_arr: [G; OUT_2] = { let __args: [G; IN_2] = [__v_36, __v_34, __v_35]; let __cu = true; if let Some(result) = record.function_queries[2].get_mut(&__args[..]) { if !__cu && *result.multiplicity == G::ZERO { aiur_fn_2(__args, record, io_buffer, false)? } else { let __ret: [G; OUT_2] = unsafe { *(result.output.as_ptr() as *const [G; OUT_2]) }; __ret } } else { aiur_fn_2(__args, record, io_buffer, __cu)? } }; let __v_37: G = __r_arr[0]; let __r_arr: [G; OUT_20] = { let __args: [G; IN_20] = [__v_37, __v_1, __v_2, __v_3, __v_4, __v_5, __v_6, __v_7, __v_8, __v_9, __v_10, __v_11, __v_12, __v_13, __v_14, __v_15, __v_16, __v_17, __v_18, __v_19, __v_20, __v_21, __v_22, __v_23, __v_24, __v_25, __v_26, __v_27, __v_28, __v_29, __v_30, __v_31, __v_32]; let __cu = unconstrained; if let Some(result) = record.function_queries[20].get_mut(&__args[..]) { if !__cu && *result.multiplicity == G::ZERO { aiur_fn_20(__args, record, io_buffer, false)? } else { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_20] = unsafe { *(result.output.as_ptr() as *const [G; OUT_20]) }; __ret } } else { aiur_fn_20(__args, record, io_buffer, __cu)? } }; - let __ret: [G; OUT_284] = [__v_37]; - if let Some(result) = record.function_queries[284].get_mut(&inp[..]) { debug_assert_eq!(result.output, &__ret[..]); if !unconstrained { *result.multiplicity += G::ONE; } } else { record.function_queries[284].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained)); }; + let __ret: [G; OUT_280] = [__v_37]; + if let Some(result) = record.function_queries[280].get_mut(&inp[..]) { debug_assert_eq!(result.output, &__ret[..]); if !unconstrained { *result.multiplicity += G::ONE; } } else { record.function_queries[280].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained)); }; return Ok(__ret); }) } -const INPUT_SIZE_285: usize = 2; -const IN_285: usize = 2; -const OUT_285: usize = 1; -fn aiur_fn_285( - inp: [G; IN_285], +const INPUT_SIZE_281: usize = 2; +const IN_281: usize = 2; +const OUT_281: usize = 1; +fn aiur_fn_281( + inp: [G; IN_281], record: &mut QueryRecord, io_buffer: &mut IOBuffer, unconstrained: bool, -) -> Result<[G; OUT_285], ExecError> { +) -> Result<[G; OUT_281], ExecError> { stacker::maybe_grow(64 * 1024, 4 * 1024 * 1024, || { let __v_0: G = inp[0]; let __v_1: G = inp[1]; match __v_0.as_canonical_u64() { 2u64 => { let __v_2: G = G::from_u64(0); - let __ret: [G; OUT_285] = [__v_2]; - if let Some(result) = record.function_queries[285].get_mut(&inp[..]) { debug_assert_eq!(result.output, &__ret[..]); if !unconstrained { *result.multiplicity += G::ONE; } } else { record.function_queries[285].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained)); }; + let __ret: [G; OUT_281] = [__v_2]; + if let Some(result) = record.function_queries[281].get_mut(&inp[..]) { debug_assert_eq!(result.output, &__ret[..]); if !unconstrained { *result.multiplicity += G::ONE; } } else { record.function_queries[281].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained)); }; return Ok(__ret); }, 1u64 => { match __v_1.as_canonical_u64() { 0u64 => { let __v_2: G = G::from_u64(1); - let __ret: [G; OUT_285] = [__v_2]; - if let Some(result) = record.function_queries[285].get_mut(&inp[..]) { debug_assert_eq!(result.output, &__ret[..]); if !unconstrained { *result.multiplicity += G::ONE; } } else { record.function_queries[285].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained)); }; + let __ret: [G; OUT_281] = [__v_2]; + if let Some(result) = record.function_queries[281].get_mut(&inp[..]) { debug_assert_eq!(result.output, &__ret[..]); if !unconstrained { *result.multiplicity += G::ONE; } } else { record.function_queries[281].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained)); }; return Ok(__ret); }, _ => { let __v_2: G = G::from_u64(0); - let __ret: [G; OUT_285] = [__v_2]; - if let Some(result) = record.function_queries[285].get_mut(&inp[..]) { debug_assert_eq!(result.output, &__ret[..]); if !unconstrained { *result.multiplicity += G::ONE; } } else { record.function_queries[285].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained)); }; + let __ret: [G; OUT_281] = [__v_2]; + if let Some(result) = record.function_queries[281].get_mut(&inp[..]) { debug_assert_eq!(result.output, &__ret[..]); if !unconstrained { *result.multiplicity += G::ONE; } } else { record.function_queries[281].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained)); }; return Ok(__ret); }, } @@ -26919,14 +26645,14 @@ fn aiur_fn_285( match __v_1.as_canonical_u64() { 1u64 => { let __v_2: G = G::from_u64(0); - let __ret: [G; OUT_285] = [__v_2]; - if let Some(result) = record.function_queries[285].get_mut(&inp[..]) { debug_assert_eq!(result.output, &__ret[..]); if !unconstrained { *result.multiplicity += G::ONE; } } else { record.function_queries[285].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained)); }; + let __ret: [G; OUT_281] = [__v_2]; + if let Some(result) = record.function_queries[281].get_mut(&inp[..]) { debug_assert_eq!(result.output, &__ret[..]); if !unconstrained { *result.multiplicity += G::ONE; } } else { record.function_queries[281].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained)); }; return Ok(__ret); }, _ => { let __v_2: G = G::from_u64(1); - let __ret: [G; OUT_285] = [__v_2]; - if let Some(result) = record.function_queries[285].get_mut(&inp[..]) { debug_assert_eq!(result.output, &__ret[..]); if !unconstrained { *result.multiplicity += G::ONE; } } else { record.function_queries[285].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained)); }; + let __ret: [G; OUT_281] = [__v_2]; + if let Some(result) = record.function_queries[281].get_mut(&inp[..]) { debug_assert_eq!(result.output, &__ret[..]); if !unconstrained { *result.multiplicity += G::ONE; } } else { record.function_queries[281].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained)); }; return Ok(__ret); }, } @@ -26938,15 +26664,15 @@ fn aiur_fn_285( }) } -const INPUT_SIZE_286: usize = 14; -const IN_286: usize = 14; -const OUT_286: usize = 1; -fn aiur_fn_286( - inp: [G; IN_286], +const INPUT_SIZE_282: usize = 14; +const IN_282: usize = 14; +const OUT_282: usize = 1; +fn aiur_fn_282( + inp: [G; IN_282], record: &mut QueryRecord, io_buffer: &mut IOBuffer, unconstrained: bool, -) -> Result<[G; OUT_286], ExecError> { +) -> Result<[G; OUT_282], ExecError> { stacker::maybe_grow(64 * 1024, 4 * 1024 * 1024, || { let __v_0: G = inp[0]; let __v_1: G = inp[1]; @@ -26964,22 +26690,22 @@ fn aiur_fn_286( let __v_13: G = inp[13]; match __v_0.as_canonical_u64() { _ => { - let __r_arr: [G; OUT_285] = { let __args: [G; IN_285] = [__v_0, __v_1]; let __cu = unconstrained; if let Some(result) = record.function_queries[285].get_mut(&__args[..]) { if !__cu && *result.multiplicity == G::ZERO { aiur_fn_285(__args, record, io_buffer, false)? } else { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_285] = unsafe { *(result.output.as_ptr() as *const [G; OUT_285]) }; __ret } } else { aiur_fn_285(__args, record, io_buffer, __cu)? } }; + let __r_arr: [G; OUT_281] = { let __args: [G; IN_281] = [__v_0, __v_1]; let __cu = unconstrained; if let Some(result) = record.function_queries[281].get_mut(&__args[..]) { if !__cu && *result.multiplicity == G::ZERO { aiur_fn_281(__args, record, io_buffer, false)? } else { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_281] = unsafe { *(result.output.as_ptr() as *const [G; OUT_281]) }; __ret } } else { aiur_fn_281(__args, record, io_buffer, __cu)? } }; let __v_14: G = __r_arr[0]; match __v_14.as_canonical_u64() { 0u64 => { let __v_15: G = G::from_u64(1); let __v_16: G = G::from_u64(1); let __v_17: G = { let __values: [G; 3] = [__v_15, __v_16, __v_16]; let __mq = record.memory_queries.get_mut(&3).ok_or(ExecError::InvalidMemorySize(3))?; if let Some(result) = __mq.get_mut(&__values[..]) { if !unconstrained { *result.multiplicity += G::ONE; } result.output[0] } else { let __ptr = G::from_usize(__mq.len()); __mq.insert(&__values[..], &[__ptr], G::from_bool(!unconstrained)); __ptr } }; - let __ret: [G; OUT_286] = [__v_17]; - if let Some(result) = record.function_queries[286].get_mut(&inp[..]) { debug_assert_eq!(result.output, &__ret[..]); if !unconstrained { *result.multiplicity += G::ONE; } } else { record.function_queries[286].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained)); }; + let __ret: [G; OUT_282] = [__v_17]; + if let Some(result) = record.function_queries[282].get_mut(&inp[..]) { debug_assert_eq!(result.output, &__ret[..]); if !unconstrained { *result.multiplicity += G::ONE; } } else { record.function_queries[282].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained)); }; return Ok(__ret); }, _ => { - let __r_arr: [G; OUT_295] = { let __args: [G; IN_295] = [__v_12, __v_13]; let __cu = unconstrained; if let Some(result) = record.function_queries[295].get_mut(&__args[..]) { if !__cu && *result.multiplicity == G::ZERO { aiur_fn_295(__args, record, io_buffer, false)? } else { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_295] = unsafe { *(result.output.as_ptr() as *const [G; OUT_295]) }; __ret } } else { aiur_fn_295(__args, record, io_buffer, __cu)? } }; + let __r_arr: [G; OUT_291] = { let __args: [G; IN_291] = [__v_12, __v_13]; let __cu = unconstrained; if let Some(result) = record.function_queries[291].get_mut(&__args[..]) { if !__cu && *result.multiplicity == G::ZERO { aiur_fn_291(__args, record, io_buffer, false)? } else { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_291] = unsafe { *(result.output.as_ptr() as *const [G; OUT_291]) }; __ret } } else { aiur_fn_291(__args, record, io_buffer, __cu)? } }; let __v_15: G = __r_arr[0]; - let __ret: [G; OUT_286] = [__v_15]; - if let Some(result) = record.function_queries[286].get_mut(&inp[..]) { debug_assert_eq!(result.output, &__ret[..]); if !unconstrained { *result.multiplicity += G::ONE; } } else { record.function_queries[286].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained)); }; + let __ret: [G; OUT_282] = [__v_15]; + if let Some(result) = record.function_queries[282].get_mut(&inp[..]) { debug_assert_eq!(result.output, &__ret[..]); if !unconstrained { *result.multiplicity += G::ONE; } } else { record.function_queries[282].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained)); }; return Ok(__ret); }, } @@ -26988,18 +26714,18 @@ fn aiur_fn_286( }) } -const INPUT_SIZE_287: usize = 1; -const IN_287: usize = 1; -const OUT_287: usize = 1; -fn aiur_fn_287( - inp: [G; IN_287], +const INPUT_SIZE_283: usize = 1; +const IN_283: usize = 1; +const OUT_283: usize = 1; +fn aiur_fn_283( + inp: [G; IN_283], record: &mut QueryRecord, io_buffer: &mut IOBuffer, unconstrained: bool, -) -> Result<[G; OUT_287], ExecError> { +) -> Result<[G; OUT_283], ExecError> { stacker::maybe_grow(64 * 1024, 4 * 1024 * 1024, || { let __v_0: G = inp[0]; - let __r_arr: [G; OUT_282] = { let __args: [G; IN_282] = [__v_0]; let __cu = unconstrained; if let Some(result) = record.function_queries[282].get_mut(&__args[..]) { if !__cu && *result.multiplicity == G::ZERO { aiur_fn_282(__args, record, io_buffer, false)? } else { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_282] = unsafe { *(result.output.as_ptr() as *const [G; OUT_282]) }; __ret } } else { aiur_fn_282(__args, record, io_buffer, __cu)? } }; + let __r_arr: [G; OUT_278] = { let __args: [G; IN_278] = [__v_0]; let __cu = unconstrained; if let Some(result) = record.function_queries[278].get_mut(&__args[..]) { if !__cu && *result.multiplicity == G::ZERO { aiur_fn_278(__args, record, io_buffer, false)? } else { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_278] = unsafe { *(result.output.as_ptr() as *const [G; OUT_278]) }; __ret } } else { aiur_fn_278(__args, record, io_buffer, __cu)? } }; let __v_1: G = __r_arr[0]; let __v_2: G = __r_arr[1]; let __v_3: G = __r_arr[2]; @@ -27052,11 +26778,11 @@ fn aiur_fn_287( _ => { match __v_1.as_canonical_u64() { 0u64 => { - let __r_arr: [G; OUT_283] = { let __args: [G; IN_283] = [__v_0]; let __cu = true; if let Some(result) = record.function_queries[283].get_mut(&__args[..]) { if !__cu && *result.multiplicity == G::ZERO { aiur_fn_283(__args, record, io_buffer, false)? } else { let __ret: [G; OUT_283] = unsafe { *(result.output.as_ptr() as *const [G; OUT_283]) }; __ret } } else { aiur_fn_283(__args, record, io_buffer, __cu)? } }; + let __r_arr: [G; OUT_279] = { let __args: [G; IN_279] = [__v_0]; let __cu = true; if let Some(result) = record.function_queries[279].get_mut(&__args[..]) { if !__cu && *result.multiplicity == G::ZERO { aiur_fn_279(__args, record, io_buffer, false)? } else { let __ret: [G; OUT_279] = unsafe { *(result.output.as_ptr() as *const [G; OUT_279]) }; __ret } } else { aiur_fn_279(__args, record, io_buffer, __cu)? } }; let __v_49: G = __r_arr[0]; let __mc_out___mc_0: [G; 1] = '__mc_0: { match __v_2.as_canonical_u64() { _ => { - let __r_arr: [G; OUT_285] = { let __args: [G; IN_285] = [__v_2, __v_3]; let __cu = unconstrained; if let Some(result) = record.function_queries[285].get_mut(&__args[..]) { if !__cu && *result.multiplicity == G::ZERO { aiur_fn_285(__args, record, io_buffer, false)? } else { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_285] = unsafe { *(result.output.as_ptr() as *const [G; OUT_285]) }; __ret } } else { aiur_fn_285(__args, record, io_buffer, __cu)? } }; + let __r_arr: [G; OUT_281] = { let __args: [G; IN_281] = [__v_2, __v_3]; let __cu = unconstrained; if let Some(result) = record.function_queries[281].get_mut(&__args[..]) { if !__cu && *result.multiplicity == G::ZERO { aiur_fn_281(__args, record, io_buffer, false)? } else { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_281] = unsafe { *(result.output.as_ptr() as *const [G; OUT_281]) }; __ret } } else { aiur_fn_281(__args, record, io_buffer, __cu)? } }; let __v_50: G = __r_arr[0]; match __v_50.as_canonical_u64() { 0u64 => { @@ -27078,7 +26804,7 @@ fn aiur_fn_287( } }; let __v_50: G = __mc_out___mc_0[0]; - let __r_arr: [G; OUT_273] = { let __args: [G; IN_273] = [__v_2, __v_3, __v_4, __v_5, __v_6, __v_7, __v_8, __v_9, __v_10, __v_11, __v_12, __v_13, __v_46, __v_47, __v_50, __v_48, __v_49]; let __cu = unconstrained; if let Some(result) = record.function_queries[273].get_mut(&__args[..]) { if !__cu && *result.multiplicity == G::ZERO { aiur_fn_273(__args, record, io_buffer, false)? } else { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_273] = unsafe { *(result.output.as_ptr() as *const [G; OUT_273]) }; __ret } } else { aiur_fn_273(__args, record, io_buffer, __cu)? } }; + let __r_arr: [G; OUT_269] = { let __args: [G; IN_269] = [__v_2, __v_3, __v_4, __v_5, __v_6, __v_7, __v_8, __v_9, __v_10, __v_11, __v_12, __v_13, __v_46, __v_47, __v_50, __v_48, __v_49]; let __cu = unconstrained; if let Some(result) = record.function_queries[269].get_mut(&__args[..]) { if !__cu && *result.multiplicity == G::ZERO { aiur_fn_269(__args, record, io_buffer, false)? } else { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_269] = unsafe { *(result.output.as_ptr() as *const [G; OUT_269]) }; __ret } } else { aiur_fn_269(__args, record, io_buffer, __cu)? } }; let __v_51: G = __r_arr[0]; let __v_52: G = __r_arr[1]; let __v_53: G = __r_arr[2]; @@ -27092,15 +26818,15 @@ fn aiur_fn_287( let __v_61: G = __r_arr[10]; let __v_62: G = __r_arr[11]; let __v_63: G = { let __values: [G; 12] = [__v_51, __v_52, __v_53, __v_54, __v_55, __v_56, __v_57, __v_58, __v_59, __v_60, __v_61, __v_62]; let __mq = record.memory_queries.get_mut(&12).ok_or(ExecError::InvalidMemorySize(12))?; if let Some(result) = __mq.get_mut(&__values[..]) { if !unconstrained { *result.multiplicity += G::ONE; } result.output[0] } else { let __ptr = G::from_usize(__mq.len()); __mq.insert(&__values[..], &[__ptr], G::from_bool(!unconstrained)); __ptr } }; - let __ret: [G; OUT_287] = [__v_63]; - if let Some(result) = record.function_queries[287].get_mut(&inp[..]) { debug_assert_eq!(result.output, &__ret[..]); if !unconstrained { *result.multiplicity += G::ONE; } } else { record.function_queries[287].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained)); }; + let __ret: [G; OUT_283] = [__v_63]; + if let Some(result) = record.function_queries[283].get_mut(&inp[..]) { debug_assert_eq!(result.output, &__ret[..]); if !unconstrained { *result.multiplicity += G::ONE; } } else { record.function_queries[283].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained)); }; return Ok(__ret); }, 2u64 => { let __v_49: G = G::from_u64(1); let __v_50: G = G::from_u64(1); let __v_51: G = { let __values: [G; 3] = [__v_49, __v_50, __v_50]; let __mq = record.memory_queries.get_mut(&3).ok_or(ExecError::InvalidMemorySize(3))?; if let Some(result) = __mq.get_mut(&__values[..]) { if !unconstrained { *result.multiplicity += G::ONE; } result.output[0] } else { let __ptr = G::from_usize(__mq.len()); __mq.insert(&__values[..], &[__ptr], G::from_bool(!unconstrained)); __ptr } }; - let __r_arr: [G; OUT_274] = { let __args: [G; IN_274] = [__v_2, __v_3, __v_4, __v_5, __v_6, __v_7, __v_8, __v_9, __v_10, __v_11, __v_46, __v_47, __v_51, __v_48]; let __cu = unconstrained; if let Some(result) = record.function_queries[274].get_mut(&__args[..]) { if !__cu && *result.multiplicity == G::ZERO { aiur_fn_274(__args, record, io_buffer, false)? } else { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_274] = unsafe { *(result.output.as_ptr() as *const [G; OUT_274]) }; __ret } } else { aiur_fn_274(__args, record, io_buffer, __cu)? } }; + let __r_arr: [G; OUT_270] = { let __args: [G; IN_270] = [__v_2, __v_3, __v_4, __v_5, __v_6, __v_7, __v_8, __v_9, __v_10, __v_11, __v_46, __v_47, __v_51, __v_48]; let __cu = unconstrained; if let Some(result) = record.function_queries[270].get_mut(&__args[..]) { if !__cu && *result.multiplicity == G::ZERO { aiur_fn_270(__args, record, io_buffer, false)? } else { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_270] = unsafe { *(result.output.as_ptr() as *const [G; OUT_270]) }; __ret } } else { aiur_fn_270(__args, record, io_buffer, __cu)? } }; let __v_52: G = __r_arr[0]; let __v_53: G = __r_arr[1]; let __v_54: G = __r_arr[2]; @@ -27114,15 +26840,15 @@ fn aiur_fn_287( let __v_62: G = __r_arr[10]; let __v_63: G = __r_arr[11]; let __v_64: G = { let __values: [G; 12] = [__v_52, __v_53, __v_54, __v_55, __v_56, __v_57, __v_58, __v_59, __v_60, __v_61, __v_62, __v_63]; let __mq = record.memory_queries.get_mut(&12).ok_or(ExecError::InvalidMemorySize(12))?; if let Some(result) = __mq.get_mut(&__values[..]) { if !unconstrained { *result.multiplicity += G::ONE; } result.output[0] } else { let __ptr = G::from_usize(__mq.len()); __mq.insert(&__values[..], &[__ptr], G::from_bool(!unconstrained)); __ptr } }; - let __ret: [G; OUT_287] = [__v_64]; - if let Some(result) = record.function_queries[287].get_mut(&inp[..]) { debug_assert_eq!(result.output, &__ret[..]); if !unconstrained { *result.multiplicity += G::ONE; } } else { record.function_queries[287].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained)); }; + let __ret: [G; OUT_283] = [__v_64]; + if let Some(result) = record.function_queries[283].get_mut(&inp[..]) { debug_assert_eq!(result.output, &__ret[..]); if !unconstrained { *result.multiplicity += G::ONE; } } else { record.function_queries[283].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained)); }; return Ok(__ret); }, 3u64 => { let __v_49: G = G::from_u64(1); let __v_50: G = G::from_u64(1); let __v_51: G = { let __values: [G; 3] = [__v_49, __v_50, __v_50]; let __mq = record.memory_queries.get_mut(&3).ok_or(ExecError::InvalidMemorySize(3))?; if let Some(result) = __mq.get_mut(&__values[..]) { if !unconstrained { *result.multiplicity += G::ONE; } result.output[0] } else { let __ptr = G::from_usize(__mq.len()); __mq.insert(&__values[..], &[__ptr], G::from_bool(!unconstrained)); __ptr } }; - let __r_arr: [G; OUT_275] = { let __args: [G; IN_275] = [__v_2, __v_3, __v_4, __v_5, __v_6, __v_7, __v_8, __v_9, __v_10, __v_11, __v_46, __v_47, __v_51, __v_48]; let __cu = unconstrained; if let Some(result) = record.function_queries[275].get_mut(&__args[..]) { if !__cu && *result.multiplicity == G::ZERO { aiur_fn_275(__args, record, io_buffer, false)? } else { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_275] = unsafe { *(result.output.as_ptr() as *const [G; OUT_275]) }; __ret } } else { aiur_fn_275(__args, record, io_buffer, __cu)? } }; + let __r_arr: [G; OUT_271] = { let __args: [G; IN_271] = [__v_2, __v_3, __v_4, __v_5, __v_6, __v_7, __v_8, __v_9, __v_10, __v_11, __v_46, __v_47, __v_51, __v_48]; let __cu = unconstrained; if let Some(result) = record.function_queries[271].get_mut(&__args[..]) { if !__cu && *result.multiplicity == G::ZERO { aiur_fn_271(__args, record, io_buffer, false)? } else { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_271] = unsafe { *(result.output.as_ptr() as *const [G; OUT_271]) }; __ret } } else { aiur_fn_271(__args, record, io_buffer, __cu)? } }; let __v_52: G = __r_arr[0]; let __v_53: G = __r_arr[1]; let __v_54: G = __r_arr[2]; @@ -27136,17 +26862,17 @@ fn aiur_fn_287( let __v_62: G = __r_arr[10]; let __v_63: G = __r_arr[11]; let __v_64: G = { let __values: [G; 12] = [__v_52, __v_53, __v_54, __v_55, __v_56, __v_57, __v_58, __v_59, __v_60, __v_61, __v_62, __v_63]; let __mq = record.memory_queries.get_mut(&12).ok_or(ExecError::InvalidMemorySize(12))?; if let Some(result) = __mq.get_mut(&__values[..]) { if !unconstrained { *result.multiplicity += G::ONE; } result.output[0] } else { let __ptr = G::from_usize(__mq.len()); __mq.insert(&__values[..], &[__ptr], G::from_bool(!unconstrained)); __ptr } }; - let __ret: [G; OUT_287] = [__v_64]; - if let Some(result) = record.function_queries[287].get_mut(&inp[..]) { debug_assert_eq!(result.output, &__ret[..]); if !unconstrained { *result.multiplicity += G::ONE; } } else { record.function_queries[287].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained)); }; + let __ret: [G; OUT_283] = [__v_64]; + if let Some(result) = record.function_queries[283].get_mut(&inp[..]) { debug_assert_eq!(result.output, &__ret[..]); if !unconstrained { *result.multiplicity += G::ONE; } } else { record.function_queries[283].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained)); }; return Ok(__ret); }, 7u64 => { match __v_2.as_canonical_u64() { _ => { - let __r_arr: [G; OUT_288] = { let __args: [G; IN_288] = [__v_0, __v_2, __v_3, __v_4, __v_5, __v_6, __v_7, __v_8, __v_9, __v_10]; let __cu = unconstrained; if let Some(result) = record.function_queries[288].get_mut(&__args[..]) { if !__cu && *result.multiplicity == G::ZERO { aiur_fn_288(__args, record, io_buffer, false)? } else { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_288] = unsafe { *(result.output.as_ptr() as *const [G; OUT_288]) }; __ret } } else { aiur_fn_288(__args, record, io_buffer, __cu)? } }; + let __r_arr: [G; OUT_284] = { let __args: [G; IN_284] = [__v_0, __v_2, __v_3, __v_4, __v_5, __v_6, __v_7, __v_8, __v_9, __v_10]; let __cu = unconstrained; if let Some(result) = record.function_queries[284].get_mut(&__args[..]) { if !__cu && *result.multiplicity == G::ZERO { aiur_fn_284(__args, record, io_buffer, false)? } else { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_284] = unsafe { *(result.output.as_ptr() as *const [G; OUT_284]) }; __ret } } else { aiur_fn_284(__args, record, io_buffer, __cu)? } }; let __v_49: G = __r_arr[0]; - let __ret: [G; OUT_287] = [__v_49]; - if let Some(result) = record.function_queries[287].get_mut(&inp[..]) { debug_assert_eq!(result.output, &__ret[..]); if !unconstrained { *result.multiplicity += G::ONE; } } else { record.function_queries[287].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained)); }; + let __ret: [G; OUT_283] = [__v_49]; + if let Some(result) = record.function_queries[283].get_mut(&inp[..]) { debug_assert_eq!(result.output, &__ret[..]); if !unconstrained { *result.multiplicity += G::ONE; } } else { record.function_queries[283].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained)); }; return Ok(__ret); }, } @@ -27156,10 +26882,10 @@ fn aiur_fn_287( _ => { let __r_arr: [G; OUT_16] = { let __args: [G; IN_16] = [__v_2, __v_3, __v_4, __v_5, __v_6, __v_7, __v_8, __v_9]; let __cu = unconstrained; if let Some(result) = record.function_queries[16].get_mut(&__args[..]) { if !__cu && *result.multiplicity == G::ZERO { aiur_fn_16(__args, record, io_buffer, false)? } else { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_16] = unsafe { *(result.output.as_ptr() as *const [G; OUT_16]) }; __ret } } else { aiur_fn_16(__args, record, io_buffer, __cu)? } }; let __v_49: G = __r_arr[0]; - let __r_arr: [G; OUT_289] = { let __args: [G; IN_289] = [__v_10, __v_49]; let __cu = unconstrained; if let Some(result) = record.function_queries[289].get_mut(&__args[..]) { if !__cu && *result.multiplicity == G::ZERO { aiur_fn_289(__args, record, io_buffer, false)? } else { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_289] = unsafe { *(result.output.as_ptr() as *const [G; OUT_289]) }; __ret } } else { aiur_fn_289(__args, record, io_buffer, __cu)? } }; + let __r_arr: [G; OUT_285] = { let __args: [G; IN_285] = [__v_10, __v_49]; let __cu = unconstrained; if let Some(result) = record.function_queries[285].get_mut(&__args[..]) { if !__cu && *result.multiplicity == G::ZERO { aiur_fn_285(__args, record, io_buffer, false)? } else { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_285] = unsafe { *(result.output.as_ptr() as *const [G; OUT_285]) }; __ret } } else { aiur_fn_285(__args, record, io_buffer, __cu)? } }; let __v_50: G = __r_arr[0]; - let __ret: [G; OUT_287] = [__v_50]; - if let Some(result) = record.function_queries[287].get_mut(&inp[..]) { debug_assert_eq!(result.output, &__ret[..]); if !unconstrained { *result.multiplicity += G::ONE; } } else { record.function_queries[287].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained)); }; + let __ret: [G; OUT_283] = [__v_50]; + if let Some(result) = record.function_queries[283].get_mut(&inp[..]) { debug_assert_eq!(result.output, &__ret[..]); if !unconstrained { *result.multiplicity += G::ONE; } } else { record.function_queries[283].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained)); }; return Ok(__ret); }, } @@ -27171,10 +26897,10 @@ fn aiur_fn_287( let __v_49: G = __r_arr[0]; let __r_arr: [G; OUT_16] = { let __args: [G; IN_16] = [__v_10, __v_11, __v_12, __v_13, __v_14, __v_15, __v_16, __v_17]; let __cu = unconstrained; if let Some(result) = record.function_queries[16].get_mut(&__args[..]) { if !__cu && *result.multiplicity == G::ZERO { aiur_fn_16(__args, record, io_buffer, false)? } else { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_16] = unsafe { *(result.output.as_ptr() as *const [G; OUT_16]) }; __ret } } else { aiur_fn_16(__args, record, io_buffer, __cu)? } }; let __v_50: G = __r_arr[0]; - let __r_arr: [G; OUT_290] = { let __args: [G; IN_290] = [__v_18, __v_49, __v_50]; let __cu = unconstrained; if let Some(result) = record.function_queries[290].get_mut(&__args[..]) { if !__cu && *result.multiplicity == G::ZERO { aiur_fn_290(__args, record, io_buffer, false)? } else { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_290] = unsafe { *(result.output.as_ptr() as *const [G; OUT_290]) }; __ret } } else { aiur_fn_290(__args, record, io_buffer, __cu)? } }; + let __r_arr: [G; OUT_286] = { let __args: [G; IN_286] = [__v_18, __v_49, __v_50]; let __cu = unconstrained; if let Some(result) = record.function_queries[286].get_mut(&__args[..]) { if !__cu && *result.multiplicity == G::ZERO { aiur_fn_286(__args, record, io_buffer, false)? } else { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_286] = unsafe { *(result.output.as_ptr() as *const [G; OUT_286]) }; __ret } } else { aiur_fn_286(__args, record, io_buffer, __cu)? } }; let __v_51: G = __r_arr[0]; - let __ret: [G; OUT_287] = [__v_51]; - if let Some(result) = record.function_queries[287].get_mut(&inp[..]) { debug_assert_eq!(result.output, &__ret[..]); if !unconstrained { *result.multiplicity += G::ONE; } } else { record.function_queries[287].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained)); }; + let __ret: [G; OUT_283] = [__v_51]; + if let Some(result) = record.function_queries[283].get_mut(&inp[..]) { debug_assert_eq!(result.output, &__ret[..]); if !unconstrained { *result.multiplicity += G::ONE; } } else { record.function_queries[283].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained)); }; return Ok(__ret); }, } @@ -27184,10 +26910,10 @@ fn aiur_fn_287( _ => { let __r_arr: [G; OUT_16] = { let __args: [G; IN_16] = [__v_2, __v_3, __v_4, __v_5, __v_6, __v_7, __v_8, __v_9]; let __cu = unconstrained; if let Some(result) = record.function_queries[16].get_mut(&__args[..]) { if !__cu && *result.multiplicity == G::ZERO { aiur_fn_16(__args, record, io_buffer, false)? } else { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_16] = unsafe { *(result.output.as_ptr() as *const [G; OUT_16]) }; __ret } } else { aiur_fn_16(__args, record, io_buffer, __cu)? } }; let __v_49: G = __r_arr[0]; - let __r_arr: [G; OUT_291] = { let __args: [G; IN_291] = [__v_10, __v_49]; let __cu = unconstrained; if let Some(result) = record.function_queries[291].get_mut(&__args[..]) { if !__cu && *result.multiplicity == G::ZERO { aiur_fn_291(__args, record, io_buffer, false)? } else { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_291] = unsafe { *(result.output.as_ptr() as *const [G; OUT_291]) }; __ret } } else { aiur_fn_291(__args, record, io_buffer, __cu)? } }; + let __r_arr: [G; OUT_287] = { let __args: [G; IN_287] = [__v_10, __v_49]; let __cu = unconstrained; if let Some(result) = record.function_queries[287].get_mut(&__args[..]) { if !__cu && *result.multiplicity == G::ZERO { aiur_fn_287(__args, record, io_buffer, false)? } else { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_287] = unsafe { *(result.output.as_ptr() as *const [G; OUT_287]) }; __ret } } else { aiur_fn_287(__args, record, io_buffer, __cu)? } }; let __v_50: G = __r_arr[0]; - let __ret: [G; OUT_287] = [__v_50]; - if let Some(result) = record.function_queries[287].get_mut(&inp[..]) { debug_assert_eq!(result.output, &__ret[..]); if !unconstrained { *result.multiplicity += G::ONE; } } else { record.function_queries[287].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained)); }; + let __ret: [G; OUT_283] = [__v_50]; + if let Some(result) = record.function_queries[283].get_mut(&inp[..]) { debug_assert_eq!(result.output, &__ret[..]); if !unconstrained { *result.multiplicity += G::ONE; } } else { record.function_queries[283].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained)); }; return Ok(__ret); }, } @@ -27199,7 +26925,7 @@ fn aiur_fn_287( let __v_52: G = { let __values: [G; 3] = [__v_50, __v_51, __v_51]; let __mq = record.memory_queries.get_mut(&3).ok_or(ExecError::InvalidMemorySize(3))?; if let Some(result) = __mq.get_mut(&__values[..]) { if !unconstrained { *result.multiplicity += G::ONE; } result.output[0] } else { let __ptr = G::from_usize(__mq.len()); __mq.insert(&__values[..], &[__ptr], G::from_bool(!unconstrained)); __ptr } }; let __v_53: G = { let __values: [G; 3] = [__v_49, __v_0, __v_52]; let __mq = record.memory_queries.get_mut(&3).ok_or(ExecError::InvalidMemorySize(3))?; if let Some(result) = __mq.get_mut(&__values[..]) { if !unconstrained { *result.multiplicity += G::ONE; } result.output[0] } else { let __ptr = G::from_usize(__mq.len()); __mq.insert(&__values[..], &[__ptr], G::from_bool(!unconstrained)); __ptr } }; let __v_54: G = G::from_u64(0); - let __r_arr: [G; OUT_281] = { let __args: [G; IN_281] = [__v_2, __v_3, __v_4, __v_5, __v_6, __v_7, __v_8, __v_9, __v_10, __v_11, __v_12, __v_13, __v_14, __v_15, __v_16, __v_17, __v_18, __v_19, __v_20, __v_21, __v_22, __v_23, __v_24, __v_25, __v_26, __v_27, __v_28, __v_29, __v_30, __v_31, __v_32, __v_33, __v_34, __v_35, __v_36, __v_37, __v_38, __v_39, __v_40, __v_41, __v_42, __v_43, __v_44, __v_45, __v_0, __v_54, __v_46, __v_47, __v_53, __v_48]; let __cu = unconstrained; if let Some(result) = record.function_queries[281].get_mut(&__args[..]) { if !__cu && *result.multiplicity == G::ZERO { aiur_fn_281(__args, record, io_buffer, false)? } else { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_281] = unsafe { *(result.output.as_ptr() as *const [G; OUT_281]) }; __ret } } else { aiur_fn_281(__args, record, io_buffer, __cu)? } }; + let __r_arr: [G; OUT_277] = { let __args: [G; IN_277] = [__v_2, __v_3, __v_4, __v_5, __v_6, __v_7, __v_8, __v_9, __v_10, __v_11, __v_12, __v_13, __v_14, __v_15, __v_16, __v_17, __v_18, __v_19, __v_20, __v_21, __v_22, __v_23, __v_24, __v_25, __v_26, __v_27, __v_28, __v_29, __v_30, __v_31, __v_32, __v_33, __v_34, __v_35, __v_36, __v_37, __v_38, __v_39, __v_40, __v_41, __v_42, __v_43, __v_44, __v_45, __v_0, __v_54, __v_46, __v_47, __v_53, __v_48]; let __cu = unconstrained; if let Some(result) = record.function_queries[277].get_mut(&__args[..]) { if !__cu && *result.multiplicity == G::ZERO { aiur_fn_277(__args, record, io_buffer, false)? } else { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_277] = unsafe { *(result.output.as_ptr() as *const [G; OUT_277]) }; __ret } } else { aiur_fn_277(__args, record, io_buffer, __cu)? } }; let __v_55: G = __r_arr[0]; let __v_56: G = __r_arr[1]; let __v_57: G = __r_arr[2]; @@ -27213,8 +26939,8 @@ fn aiur_fn_287( let __v_65: G = __r_arr[10]; let __v_66: G = __r_arr[11]; let __v_67: G = { let __values: [G; 12] = [__v_55, __v_56, __v_57, __v_58, __v_59, __v_60, __v_61, __v_62, __v_63, __v_64, __v_65, __v_66]; let __mq = record.memory_queries.get_mut(&12).ok_or(ExecError::InvalidMemorySize(12))?; if let Some(result) = __mq.get_mut(&__values[..]) { if !unconstrained { *result.multiplicity += G::ONE; } result.output[0] } else { let __ptr = G::from_usize(__mq.len()); __mq.insert(&__values[..], &[__ptr], G::from_bool(!unconstrained)); __ptr } }; - let __ret: [G; OUT_287] = [__v_67]; - if let Some(result) = record.function_queries[287].get_mut(&inp[..]) { debug_assert_eq!(result.output, &__ret[..]); if !unconstrained { *result.multiplicity += G::ONE; } } else { record.function_queries[287].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained)); }; + let __ret: [G; OUT_283] = [__v_67]; + if let Some(result) = record.function_queries[283].get_mut(&inp[..]) { debug_assert_eq!(result.output, &__ret[..]); if !unconstrained { *result.multiplicity += G::ONE; } } else { record.function_queries[283].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained)); }; return Ok(__ret); }, _ => { @@ -27226,15 +26952,15 @@ fn aiur_fn_287( }) } -const INPUT_SIZE_288: usize = 10; -const IN_288: usize = 10; -const OUT_288: usize = 1; -fn aiur_fn_288( - inp: [G; IN_288], +const INPUT_SIZE_284: usize = 10; +const IN_284: usize = 10; +const OUT_284: usize = 1; +fn aiur_fn_284( + inp: [G; IN_284], record: &mut QueryRecord, io_buffer: &mut IOBuffer, unconstrained: bool, -) -> Result<[G; OUT_288], ExecError> { +) -> Result<[G; OUT_284], ExecError> { stacker::maybe_grow(64 * 1024, 4 * 1024 * 1024, || { let __v_0: G = inp[0]; let __v_1: G = inp[1]; @@ -27246,7 +26972,7 @@ fn aiur_fn_288( let __v_7: G = inp[7]; let __v_8: G = inp[8]; let __v_9: G = inp[9]; - let __r_arr: [G; OUT_282] = { let __args: [G; IN_282] = [__v_9]; let __cu = unconstrained; if let Some(result) = record.function_queries[282].get_mut(&__args[..]) { if !__cu && *result.multiplicity == G::ZERO { aiur_fn_282(__args, record, io_buffer, false)? } else { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_282] = unsafe { *(result.output.as_ptr() as *const [G; OUT_282]) }; __ret } } else { aiur_fn_282(__args, record, io_buffer, __cu)? } }; + let __r_arr: [G; OUT_278] = { let __args: [G; IN_278] = [__v_9]; let __cu = unconstrained; if let Some(result) = record.function_queries[278].get_mut(&__args[..]) { if !__cu && *result.multiplicity == G::ZERO { aiur_fn_278(__args, record, io_buffer, false)? } else { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_278] = unsafe { *(result.output.as_ptr() as *const [G; OUT_278]) }; __ret } } else { aiur_fn_278(__args, record, io_buffer, __cu)? } }; let __v_10: G = __r_arr[0]; let __v_11: G = __r_arr[1]; let __v_12: G = __r_arr[2]; @@ -27299,7 +27025,7 @@ fn aiur_fn_288( _ => { match __v_10.as_canonical_u64() { 8u64 => { - let __r_arr: [G; OUT_768] = { let __args: [G; IN_768] = [__v_11, __v_1, __v_2, __v_3, __v_4, __v_5, __v_6, __v_7, __v_8]; let __cu = unconstrained; if let Some(result) = record.function_queries[768].get_mut(&__args[..]) { if !__cu && *result.multiplicity == G::ZERO { aiur_fn_768(__args, record, io_buffer, false)? } else { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_768] = unsafe { *(result.output.as_ptr() as *const [G; OUT_768]) }; __ret } } else { aiur_fn_768(__args, record, io_buffer, __cu)? } }; + let __r_arr: [G; OUT_764] = { let __args: [G; IN_764] = [__v_11, __v_1, __v_2, __v_3, __v_4, __v_5, __v_6, __v_7, __v_8]; let __cu = unconstrained; if let Some(result) = record.function_queries[764].get_mut(&__args[..]) { if !__cu && *result.multiplicity == G::ZERO { aiur_fn_764(__args, record, io_buffer, false)? } else { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_764] = unsafe { *(result.output.as_ptr() as *const [G; OUT_764]) }; __ret } } else { aiur_fn_764(__args, record, io_buffer, __cu)? } }; let __v_58: G = __r_arr[0]; let __v_59: G = __r_arr[1]; let __v_60: G = __r_arr[2]; @@ -27347,11 +27073,11 @@ fn aiur_fn_288( let __v_102: G = __r_arr[44]; match __v_58.as_canonical_u64() { 0u64 => { - let __r_arr: [G; OUT_283] = { let __args: [G; IN_283] = [__v_0]; let __cu = true; if let Some(result) = record.function_queries[283].get_mut(&__args[..]) { if !__cu && *result.multiplicity == G::ZERO { aiur_fn_283(__args, record, io_buffer, false)? } else { let __ret: [G; OUT_283] = unsafe { *(result.output.as_ptr() as *const [G; OUT_283]) }; __ret } } else { aiur_fn_283(__args, record, io_buffer, __cu)? } }; + let __r_arr: [G; OUT_279] = { let __args: [G; IN_279] = [__v_0]; let __cu = true; if let Some(result) = record.function_queries[279].get_mut(&__args[..]) { if !__cu && *result.multiplicity == G::ZERO { aiur_fn_279(__args, record, io_buffer, false)? } else { let __ret: [G; OUT_279] = unsafe { *(result.output.as_ptr() as *const [G; OUT_279]) }; __ret } } else { aiur_fn_279(__args, record, io_buffer, __cu)? } }; let __v_103: G = __r_arr[0]; - let __r_arr: [G; OUT_286] = { let __args: [G; IN_286] = [__v_59, __v_60, __v_61, __v_62, __v_63, __v_64, __v_65, __v_66, __v_67, __v_68, __v_69, __v_70, __v_11, __v_9]; let __cu = unconstrained; if let Some(result) = record.function_queries[286].get_mut(&__args[..]) { if !__cu && *result.multiplicity == G::ZERO { aiur_fn_286(__args, record, io_buffer, false)? } else { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_286] = unsafe { *(result.output.as_ptr() as *const [G; OUT_286]) }; __ret } } else { aiur_fn_286(__args, record, io_buffer, __cu)? } }; + let __r_arr: [G; OUT_282] = { let __args: [G; IN_282] = [__v_59, __v_60, __v_61, __v_62, __v_63, __v_64, __v_65, __v_66, __v_67, __v_68, __v_69, __v_70, __v_11, __v_9]; let __cu = unconstrained; if let Some(result) = record.function_queries[282].get_mut(&__args[..]) { if !__cu && *result.multiplicity == G::ZERO { aiur_fn_282(__args, record, io_buffer, false)? } else { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_282] = unsafe { *(result.output.as_ptr() as *const [G; OUT_282]) }; __ret } } else { aiur_fn_282(__args, record, io_buffer, __cu)? } }; let __v_104: G = __r_arr[0]; - let __r_arr: [G; OUT_273] = { let __args: [G; IN_273] = [__v_59, __v_60, __v_61, __v_62, __v_63, __v_64, __v_65, __v_66, __v_67, __v_68, __v_69, __v_70, __v_55, __v_56, __v_104, __v_57, __v_103]; let __cu = unconstrained; if let Some(result) = record.function_queries[273].get_mut(&__args[..]) { if !__cu && *result.multiplicity == G::ZERO { aiur_fn_273(__args, record, io_buffer, false)? } else { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_273] = unsafe { *(result.output.as_ptr() as *const [G; OUT_273]) }; __ret } } else { aiur_fn_273(__args, record, io_buffer, __cu)? } }; + let __r_arr: [G; OUT_269] = { let __args: [G; IN_269] = [__v_59, __v_60, __v_61, __v_62, __v_63, __v_64, __v_65, __v_66, __v_67, __v_68, __v_69, __v_70, __v_55, __v_56, __v_104, __v_57, __v_103]; let __cu = unconstrained; if let Some(result) = record.function_queries[269].get_mut(&__args[..]) { if !__cu && *result.multiplicity == G::ZERO { aiur_fn_269(__args, record, io_buffer, false)? } else { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_269] = unsafe { *(result.output.as_ptr() as *const [G; OUT_269]) }; __ret } } else { aiur_fn_269(__args, record, io_buffer, __cu)? } }; let __v_105: G = __r_arr[0]; let __v_106: G = __r_arr[1]; let __v_107: G = __r_arr[2]; @@ -27365,8 +27091,8 @@ fn aiur_fn_288( let __v_115: G = __r_arr[10]; let __v_116: G = __r_arr[11]; let __v_117: G = { let __values: [G; 12] = [__v_105, __v_106, __v_107, __v_108, __v_109, __v_110, __v_111, __v_112, __v_113, __v_114, __v_115, __v_116]; let __mq = record.memory_queries.get_mut(&12).ok_or(ExecError::InvalidMemorySize(12))?; if let Some(result) = __mq.get_mut(&__values[..]) { if !unconstrained { *result.multiplicity += G::ONE; } result.output[0] } else { let __ptr = G::from_usize(__mq.len()); __mq.insert(&__values[..], &[__ptr], G::from_bool(!unconstrained)); __ptr } }; - let __ret: [G; OUT_288] = [__v_117]; - if let Some(result) = record.function_queries[288].get_mut(&inp[..]) { debug_assert_eq!(result.output, &__ret[..]); if !unconstrained { *result.multiplicity += G::ONE; } } else { record.function_queries[288].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained)); }; + let __ret: [G; OUT_284] = [__v_117]; + if let Some(result) = record.function_queries[284].get_mut(&inp[..]) { debug_assert_eq!(result.output, &__ret[..]); if !unconstrained { *result.multiplicity += G::ONE; } } else { record.function_queries[284].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained)); }; return Ok(__ret); }, _ => { @@ -27383,19 +27109,19 @@ fn aiur_fn_288( }) } -const INPUT_SIZE_289: usize = 2; -const IN_289: usize = 2; -const OUT_289: usize = 1; -fn aiur_fn_289( - inp: [G; IN_289], +const INPUT_SIZE_285: usize = 2; +const IN_285: usize = 2; +const OUT_285: usize = 1; +fn aiur_fn_285( + inp: [G; IN_285], record: &mut QueryRecord, io_buffer: &mut IOBuffer, unconstrained: bool, -) -> Result<[G; OUT_289], ExecError> { +) -> Result<[G; OUT_285], ExecError> { stacker::maybe_grow(64 * 1024, 4 * 1024 * 1024, || { let __v_0: G = inp[0]; let __v_1: G = inp[1]; - let __r_arr: [G; OUT_282] = { let __args: [G; IN_282] = [__v_0]; let __cu = unconstrained; if let Some(result) = record.function_queries[282].get_mut(&__args[..]) { if !__cu && *result.multiplicity == G::ZERO { aiur_fn_282(__args, record, io_buffer, false)? } else { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_282] = unsafe { *(result.output.as_ptr() as *const [G; OUT_282]) }; __ret } } else { aiur_fn_282(__args, record, io_buffer, __cu)? } }; + let __r_arr: [G; OUT_278] = { let __args: [G; IN_278] = [__v_0]; let __cu = unconstrained; if let Some(result) = record.function_queries[278].get_mut(&__args[..]) { if !__cu && *result.multiplicity == G::ZERO { aiur_fn_278(__args, record, io_buffer, false)? } else { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_278] = unsafe { *(result.output.as_ptr() as *const [G; OUT_278]) }; __ret } } else { aiur_fn_278(__args, record, io_buffer, __cu)? } }; let __v_2: G = __r_arr[0]; let __v_3: G = __r_arr[1]; let __v_4: G = __r_arr[2]; @@ -27448,7 +27174,7 @@ fn aiur_fn_289( _ => { match __v_2.as_canonical_u64() { 8u64 => { - let __r_arr: [G; OUT_292] = { let __args: [G; IN_292] = [__v_3, __v_1]; let __cu = unconstrained; if let Some(result) = record.function_queries[292].get_mut(&__args[..]) { if !__cu && *result.multiplicity == G::ZERO { aiur_fn_292(__args, record, io_buffer, false)? } else { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_292] = unsafe { *(result.output.as_ptr() as *const [G; OUT_292]) }; __ret } } else { aiur_fn_292(__args, record, io_buffer, __cu)? } }; + let __r_arr: [G; OUT_288] = { let __args: [G; IN_288] = [__v_3, __v_1]; let __cu = unconstrained; if let Some(result) = record.function_queries[288].get_mut(&__args[..]) { if !__cu && *result.multiplicity == G::ZERO { aiur_fn_288(__args, record, io_buffer, false)? } else { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_288] = unsafe { *(result.output.as_ptr() as *const [G; OUT_288]) }; __ret } } else { aiur_fn_288(__args, record, io_buffer, __cu)? } }; let __v_50: G = __r_arr[0]; let __v_51: G = __r_arr[1]; let __v_52: G = __r_arr[2]; @@ -27496,9 +27222,9 @@ fn aiur_fn_289( let __v_94: G = __r_arr[44]; match __v_50.as_canonical_u64() { 1u64 => { - let __r_arr: [G; OUT_295] = { let __args: [G; IN_295] = [__v_3, __v_0]; let __cu = unconstrained; if let Some(result) = record.function_queries[295].get_mut(&__args[..]) { if !__cu && *result.multiplicity == G::ZERO { aiur_fn_295(__args, record, io_buffer, false)? } else { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_295] = unsafe { *(result.output.as_ptr() as *const [G; OUT_295]) }; __ret } } else { aiur_fn_295(__args, record, io_buffer, __cu)? } }; + let __r_arr: [G; OUT_291] = { let __args: [G; IN_291] = [__v_3, __v_0]; let __cu = unconstrained; if let Some(result) = record.function_queries[291].get_mut(&__args[..]) { if !__cu && *result.multiplicity == G::ZERO { aiur_fn_291(__args, record, io_buffer, false)? } else { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_291] = unsafe { *(result.output.as_ptr() as *const [G; OUT_291]) }; __ret } } else { aiur_fn_291(__args, record, io_buffer, __cu)? } }; let __v_95: G = __r_arr[0]; - let __r_arr: [G; OUT_278] = { let __args: [G; IN_278] = [__v_51, __v_52, __v_53, __v_54, __v_55, __v_56, __v_57, __v_58, __v_59, __v_60, __v_61, __v_62, __v_63, __v_64, __v_65, __v_66, __v_67, __v_68, __v_69, __v_70, __v_71, __v_72, __v_73, __v_74, __v_75, __v_76, __v_77, __v_0, __v_1, __v_47, __v_48, __v_95, __v_49]; let __cu = unconstrained; if let Some(result) = record.function_queries[278].get_mut(&__args[..]) { if !__cu && *result.multiplicity == G::ZERO { aiur_fn_278(__args, record, io_buffer, false)? } else { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_278] = unsafe { *(result.output.as_ptr() as *const [G; OUT_278]) }; __ret } } else { aiur_fn_278(__args, record, io_buffer, __cu)? } }; + let __r_arr: [G; OUT_274] = { let __args: [G; IN_274] = [__v_51, __v_52, __v_53, __v_54, __v_55, __v_56, __v_57, __v_58, __v_59, __v_60, __v_61, __v_62, __v_63, __v_64, __v_65, __v_66, __v_67, __v_68, __v_69, __v_70, __v_71, __v_72, __v_73, __v_74, __v_75, __v_76, __v_77, __v_0, __v_1, __v_47, __v_48, __v_95, __v_49]; let __cu = unconstrained; if let Some(result) = record.function_queries[274].get_mut(&__args[..]) { if !__cu && *result.multiplicity == G::ZERO { aiur_fn_274(__args, record, io_buffer, false)? } else { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_274] = unsafe { *(result.output.as_ptr() as *const [G; OUT_274]) }; __ret } } else { aiur_fn_274(__args, record, io_buffer, __cu)? } }; let __v_96: G = __r_arr[0]; let __v_97: G = __r_arr[1]; let __v_98: G = __r_arr[2]; @@ -27512,8 +27238,8 @@ fn aiur_fn_289( let __v_106: G = __r_arr[10]; let __v_107: G = __r_arr[11]; let __v_108: G = { let __values: [G; 12] = [__v_96, __v_97, __v_98, __v_99, __v_100, __v_101, __v_102, __v_103, __v_104, __v_105, __v_106, __v_107]; let __mq = record.memory_queries.get_mut(&12).ok_or(ExecError::InvalidMemorySize(12))?; if let Some(result) = __mq.get_mut(&__values[..]) { if !unconstrained { *result.multiplicity += G::ONE; } result.output[0] } else { let __ptr = G::from_usize(__mq.len()); __mq.insert(&__values[..], &[__ptr], G::from_bool(!unconstrained)); __ptr } }; - let __ret: [G; OUT_289] = [__v_108]; - if let Some(result) = record.function_queries[289].get_mut(&inp[..]) { debug_assert_eq!(result.output, &__ret[..]); if !unconstrained { *result.multiplicity += G::ONE; } } else { record.function_queries[289].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained)); }; + let __ret: [G; OUT_285] = [__v_108]; + if let Some(result) = record.function_queries[285].get_mut(&inp[..]) { debug_assert_eq!(result.output, &__ret[..]); if !unconstrained { *result.multiplicity += G::ONE; } } else { record.function_queries[285].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained)); }; return Ok(__ret); }, _ => { @@ -27530,20 +27256,20 @@ fn aiur_fn_289( }) } -const INPUT_SIZE_290: usize = 3; -const IN_290: usize = 3; -const OUT_290: usize = 1; -fn aiur_fn_290( - inp: [G; IN_290], +const INPUT_SIZE_286: usize = 3; +const IN_286: usize = 3; +const OUT_286: usize = 1; +fn aiur_fn_286( + inp: [G; IN_286], record: &mut QueryRecord, io_buffer: &mut IOBuffer, unconstrained: bool, -) -> Result<[G; OUT_290], ExecError> { +) -> Result<[G; OUT_286], ExecError> { stacker::maybe_grow(64 * 1024, 4 * 1024 * 1024, || { let __v_0: G = inp[0]; let __v_1: G = inp[1]; let __v_2: G = inp[2]; - let __r_arr: [G; OUT_282] = { let __args: [G; IN_282] = [__v_0]; let __cu = unconstrained; if let Some(result) = record.function_queries[282].get_mut(&__args[..]) { if !__cu && *result.multiplicity == G::ZERO { aiur_fn_282(__args, record, io_buffer, false)? } else { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_282] = unsafe { *(result.output.as_ptr() as *const [G; OUT_282]) }; __ret } } else { aiur_fn_282(__args, record, io_buffer, __cu)? } }; + let __r_arr: [G; OUT_278] = { let __args: [G; IN_278] = [__v_0]; let __cu = unconstrained; if let Some(result) = record.function_queries[278].get_mut(&__args[..]) { if !__cu && *result.multiplicity == G::ZERO { aiur_fn_278(__args, record, io_buffer, false)? } else { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_278] = unsafe { *(result.output.as_ptr() as *const [G; OUT_278]) }; __ret } } else { aiur_fn_278(__args, record, io_buffer, __cu)? } }; let __v_3: G = __r_arr[0]; let __v_4: G = __r_arr[1]; let __v_5: G = __r_arr[2]; @@ -27596,7 +27322,7 @@ fn aiur_fn_290( _ => { match __v_3.as_canonical_u64() { 8u64 => { - let __r_arr: [G; OUT_292] = { let __args: [G; IN_292] = [__v_4, __v_1]; let __cu = unconstrained; if let Some(result) = record.function_queries[292].get_mut(&__args[..]) { if !__cu && *result.multiplicity == G::ZERO { aiur_fn_292(__args, record, io_buffer, false)? } else { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_292] = unsafe { *(result.output.as_ptr() as *const [G; OUT_292]) }; __ret } } else { aiur_fn_292(__args, record, io_buffer, __cu)? } }; + let __r_arr: [G; OUT_288] = { let __args: [G; IN_288] = [__v_4, __v_1]; let __cu = unconstrained; if let Some(result) = record.function_queries[288].get_mut(&__args[..]) { if !__cu && *result.multiplicity == G::ZERO { aiur_fn_288(__args, record, io_buffer, false)? } else { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_288] = unsafe { *(result.output.as_ptr() as *const [G; OUT_288]) }; __ret } } else { aiur_fn_288(__args, record, io_buffer, __cu)? } }; let __v_51: G = __r_arr[0]; let __v_52: G = __r_arr[1]; let __v_53: G = __r_arr[2]; @@ -27646,7 +27372,7 @@ fn aiur_fn_290( 1u64 => { match __v_52.as_canonical_u64() { _ => { - let __r_arr: [G; OUT_277] = { let __args: [G; IN_277] = [__v_78, __v_2]; let __cu = unconstrained; if let Some(result) = record.function_queries[277].get_mut(&__args[..]) { if !__cu && *result.multiplicity == G::ZERO { aiur_fn_277(__args, record, io_buffer, false)? } else { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_277] = unsafe { *(result.output.as_ptr() as *const [G; OUT_277]) }; __ret } } else { aiur_fn_277(__args, record, io_buffer, __cu)? } }; + let __r_arr: [G; OUT_273] = { let __args: [G; IN_273] = [__v_78, __v_2]; let __cu = unconstrained; if let Some(result) = record.function_queries[273].get_mut(&__args[..]) { if !__cu && *result.multiplicity == G::ZERO { aiur_fn_273(__args, record, io_buffer, false)? } else { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_273] = unsafe { *(result.output.as_ptr() as *const [G; OUT_273]) }; __ret } } else { aiur_fn_273(__args, record, io_buffer, __cu)? } }; let __v_96: G = __r_arr[0]; let __v_97: G = __r_arr[1]; let __v_98: G = __r_arr[2]; @@ -27681,9 +27407,9 @@ fn aiur_fn_290( let __v_127: G = __r_arr[31]; let __v_128: G = __r_arr[32]; let __v_129: G = __r_arr[33]; - let __r_arr: [G; OUT_295] = { let __args: [G; IN_295] = [__v_4, __v_0]; let __cu = unconstrained; if let Some(result) = record.function_queries[295].get_mut(&__args[..]) { if !__cu && *result.multiplicity == G::ZERO { aiur_fn_295(__args, record, io_buffer, false)? } else { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_295] = unsafe { *(result.output.as_ptr() as *const [G; OUT_295]) }; __ret } } else { aiur_fn_295(__args, record, io_buffer, __cu)? } }; + let __r_arr: [G; OUT_291] = { let __args: [G; IN_291] = [__v_4, __v_0]; let __cu = unconstrained; if let Some(result) = record.function_queries[291].get_mut(&__args[..]) { if !__cu && *result.multiplicity == G::ZERO { aiur_fn_291(__args, record, io_buffer, false)? } else { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_291] = unsafe { *(result.output.as_ptr() as *const [G; OUT_291]) }; __ret } } else { aiur_fn_291(__args, record, io_buffer, __cu)? } }; let __v_130: G = __r_arr[0]; - let __r_arr: [G; OUT_279] = { let __args: [G; IN_279] = [__v_96, __v_97, __v_98, __v_99, __v_100, __v_101, __v_102, __v_103, __v_104, __v_105, __v_106, __v_107, __v_108, __v_109, __v_110, __v_111, __v_112, __v_113, __v_114, __v_115, __v_116, __v_117, __v_118, __v_119, __v_120, __v_121, __v_122, __v_123, __v_124, __v_125, __v_126, __v_127, __v_128, __v_129, __v_0, __v_1, __v_48, __v_49, __v_130, __v_50]; let __cu = unconstrained; if let Some(result) = record.function_queries[279].get_mut(&__args[..]) { if !__cu && *result.multiplicity == G::ZERO { aiur_fn_279(__args, record, io_buffer, false)? } else { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_279] = unsafe { *(result.output.as_ptr() as *const [G; OUT_279]) }; __ret } } else { aiur_fn_279(__args, record, io_buffer, __cu)? } }; + let __r_arr: [G; OUT_275] = { let __args: [G; IN_275] = [__v_96, __v_97, __v_98, __v_99, __v_100, __v_101, __v_102, __v_103, __v_104, __v_105, __v_106, __v_107, __v_108, __v_109, __v_110, __v_111, __v_112, __v_113, __v_114, __v_115, __v_116, __v_117, __v_118, __v_119, __v_120, __v_121, __v_122, __v_123, __v_124, __v_125, __v_126, __v_127, __v_128, __v_129, __v_0, __v_1, __v_48, __v_49, __v_130, __v_50]; let __cu = unconstrained; if let Some(result) = record.function_queries[275].get_mut(&__args[..]) { if !__cu && *result.multiplicity == G::ZERO { aiur_fn_275(__args, record, io_buffer, false)? } else { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_275] = unsafe { *(result.output.as_ptr() as *const [G; OUT_275]) }; __ret } } else { aiur_fn_275(__args, record, io_buffer, __cu)? } }; let __v_131: G = __r_arr[0]; let __v_132: G = __r_arr[1]; let __v_133: G = __r_arr[2]; @@ -27697,8 +27423,8 @@ fn aiur_fn_290( let __v_141: G = __r_arr[10]; let __v_142: G = __r_arr[11]; let __v_143: G = { let __values: [G; 12] = [__v_131, __v_132, __v_133, __v_134, __v_135, __v_136, __v_137, __v_138, __v_139, __v_140, __v_141, __v_142]; let __mq = record.memory_queries.get_mut(&12).ok_or(ExecError::InvalidMemorySize(12))?; if let Some(result) = __mq.get_mut(&__values[..]) { if !unconstrained { *result.multiplicity += G::ONE; } result.output[0] } else { let __ptr = G::from_usize(__mq.len()); __mq.insert(&__values[..], &[__ptr], G::from_bool(!unconstrained)); __ptr } }; - let __ret: [G; OUT_290] = [__v_143]; - if let Some(result) = record.function_queries[290].get_mut(&inp[..]) { debug_assert_eq!(result.output, &__ret[..]); if !unconstrained { *result.multiplicity += G::ONE; } } else { record.function_queries[290].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained)); }; + let __ret: [G; OUT_286] = [__v_143]; + if let Some(result) = record.function_queries[286].get_mut(&inp[..]) { debug_assert_eq!(result.output, &__ret[..]); if !unconstrained { *result.multiplicity += G::ONE; } } else { record.function_queries[286].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained)); }; return Ok(__ret); }, } @@ -27717,19 +27443,19 @@ fn aiur_fn_290( }) } -const INPUT_SIZE_291: usize = 2; -const IN_291: usize = 2; -const OUT_291: usize = 1; -fn aiur_fn_291( - inp: [G; IN_291], +const INPUT_SIZE_287: usize = 2; +const IN_287: usize = 2; +const OUT_287: usize = 1; +fn aiur_fn_287( + inp: [G; IN_287], record: &mut QueryRecord, io_buffer: &mut IOBuffer, unconstrained: bool, -) -> Result<[G; OUT_291], ExecError> { +) -> Result<[G; OUT_287], ExecError> { stacker::maybe_grow(64 * 1024, 4 * 1024 * 1024, || { let __v_0: G = inp[0]; let __v_1: G = inp[1]; - let __r_arr: [G; OUT_282] = { let __args: [G; IN_282] = [__v_0]; let __cu = unconstrained; if let Some(result) = record.function_queries[282].get_mut(&__args[..]) { if !__cu && *result.multiplicity == G::ZERO { aiur_fn_282(__args, record, io_buffer, false)? } else { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_282] = unsafe { *(result.output.as_ptr() as *const [G; OUT_282]) }; __ret } } else { aiur_fn_282(__args, record, io_buffer, __cu)? } }; + let __r_arr: [G; OUT_278] = { let __args: [G; IN_278] = [__v_0]; let __cu = unconstrained; if let Some(result) = record.function_queries[278].get_mut(&__args[..]) { if !__cu && *result.multiplicity == G::ZERO { aiur_fn_278(__args, record, io_buffer, false)? } else { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_278] = unsafe { *(result.output.as_ptr() as *const [G; OUT_278]) }; __ret } } else { aiur_fn_278(__args, record, io_buffer, __cu)? } }; let __v_2: G = __r_arr[0]; let __v_3: G = __r_arr[1]; let __v_4: G = __r_arr[2]; @@ -27782,7 +27508,7 @@ fn aiur_fn_291( _ => { match __v_2.as_canonical_u64() { 8u64 => { - let __r_arr: [G; OUT_292] = { let __args: [G; IN_292] = [__v_3, __v_1]; let __cu = unconstrained; if let Some(result) = record.function_queries[292].get_mut(&__args[..]) { if !__cu && *result.multiplicity == G::ZERO { aiur_fn_292(__args, record, io_buffer, false)? } else { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_292] = unsafe { *(result.output.as_ptr() as *const [G; OUT_292]) }; __ret } } else { aiur_fn_292(__args, record, io_buffer, __cu)? } }; + let __r_arr: [G; OUT_288] = { let __args: [G; IN_288] = [__v_3, __v_1]; let __cu = unconstrained; if let Some(result) = record.function_queries[288].get_mut(&__args[..]) { if !__cu && *result.multiplicity == G::ZERO { aiur_fn_288(__args, record, io_buffer, false)? } else { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_288] = unsafe { *(result.output.as_ptr() as *const [G; OUT_288]) }; __ret } } else { aiur_fn_288(__args, record, io_buffer, __cu)? } }; let __v_50: G = __r_arr[0]; let __v_51: G = __r_arr[1]; let __v_52: G = __r_arr[2]; @@ -27830,9 +27556,9 @@ fn aiur_fn_291( let __v_94: G = __r_arr[44]; match __v_50.as_canonical_u64() { 2u64 => { - let __r_arr: [G; OUT_295] = { let __args: [G; IN_295] = [__v_3, __v_0]; let __cu = unconstrained; if let Some(result) = record.function_queries[295].get_mut(&__args[..]) { if !__cu && *result.multiplicity == G::ZERO { aiur_fn_295(__args, record, io_buffer, false)? } else { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_295] = unsafe { *(result.output.as_ptr() as *const [G; OUT_295]) }; __ret } } else { aiur_fn_295(__args, record, io_buffer, __cu)? } }; + let __r_arr: [G; OUT_291] = { let __args: [G; IN_291] = [__v_3, __v_0]; let __cu = unconstrained; if let Some(result) = record.function_queries[291].get_mut(&__args[..]) { if !__cu && *result.multiplicity == G::ZERO { aiur_fn_291(__args, record, io_buffer, false)? } else { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_291] = unsafe { *(result.output.as_ptr() as *const [G; OUT_291]) }; __ret } } else { aiur_fn_291(__args, record, io_buffer, __cu)? } }; let __v_95: G = __r_arr[0]; - let __r_arr: [G; OUT_281] = { let __args: [G; IN_281] = [__v_51, __v_52, __v_53, __v_54, __v_55, __v_56, __v_57, __v_58, __v_59, __v_60, __v_61, __v_62, __v_63, __v_64, __v_65, __v_66, __v_67, __v_68, __v_69, __v_70, __v_71, __v_72, __v_73, __v_74, __v_75, __v_76, __v_77, __v_78, __v_79, __v_80, __v_81, __v_82, __v_83, __v_84, __v_85, __v_86, __v_87, __v_88, __v_89, __v_90, __v_91, __v_92, __v_93, __v_94, __v_0, __v_1, __v_47, __v_48, __v_95, __v_49]; let __cu = unconstrained; if let Some(result) = record.function_queries[281].get_mut(&__args[..]) { if !__cu && *result.multiplicity == G::ZERO { aiur_fn_281(__args, record, io_buffer, false)? } else { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_281] = unsafe { *(result.output.as_ptr() as *const [G; OUT_281]) }; __ret } } else { aiur_fn_281(__args, record, io_buffer, __cu)? } }; + let __r_arr: [G; OUT_277] = { let __args: [G; IN_277] = [__v_51, __v_52, __v_53, __v_54, __v_55, __v_56, __v_57, __v_58, __v_59, __v_60, __v_61, __v_62, __v_63, __v_64, __v_65, __v_66, __v_67, __v_68, __v_69, __v_70, __v_71, __v_72, __v_73, __v_74, __v_75, __v_76, __v_77, __v_78, __v_79, __v_80, __v_81, __v_82, __v_83, __v_84, __v_85, __v_86, __v_87, __v_88, __v_89, __v_90, __v_91, __v_92, __v_93, __v_94, __v_0, __v_1, __v_47, __v_48, __v_95, __v_49]; let __cu = unconstrained; if let Some(result) = record.function_queries[277].get_mut(&__args[..]) { if !__cu && *result.multiplicity == G::ZERO { aiur_fn_277(__args, record, io_buffer, false)? } else { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_277] = unsafe { *(result.output.as_ptr() as *const [G; OUT_277]) }; __ret } } else { aiur_fn_277(__args, record, io_buffer, __cu)? } }; let __v_96: G = __r_arr[0]; let __v_97: G = __r_arr[1]; let __v_98: G = __r_arr[2]; @@ -27846,8 +27572,8 @@ fn aiur_fn_291( let __v_106: G = __r_arr[10]; let __v_107: G = __r_arr[11]; let __v_108: G = { let __values: [G; 12] = [__v_96, __v_97, __v_98, __v_99, __v_100, __v_101, __v_102, __v_103, __v_104, __v_105, __v_106, __v_107]; let __mq = record.memory_queries.get_mut(&12).ok_or(ExecError::InvalidMemorySize(12))?; if let Some(result) = __mq.get_mut(&__values[..]) { if !unconstrained { *result.multiplicity += G::ONE; } result.output[0] } else { let __ptr = G::from_usize(__mq.len()); __mq.insert(&__values[..], &[__ptr], G::from_bool(!unconstrained)); __ptr } }; - let __ret: [G; OUT_291] = [__v_108]; - if let Some(result) = record.function_queries[291].get_mut(&inp[..]) { debug_assert_eq!(result.output, &__ret[..]); if !unconstrained { *result.multiplicity += G::ONE; } } else { record.function_queries[291].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained)); }; + let __ret: [G; OUT_287] = [__v_108]; + if let Some(result) = record.function_queries[287].get_mut(&inp[..]) { debug_assert_eq!(result.output, &__ret[..]); if !unconstrained { *result.multiplicity += G::ONE; } } else { record.function_queries[287].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained)); }; return Ok(__ret); }, _ => { @@ -27864,15 +27590,15 @@ fn aiur_fn_291( }) } -const INPUT_SIZE_292: usize = 2; -const IN_292: usize = 2; -const OUT_292: usize = 45; -fn aiur_fn_292( - inp: [G; IN_292], +const INPUT_SIZE_288: usize = 2; +const IN_288: usize = 2; +const OUT_288: usize = 45; +fn aiur_fn_288( + inp: [G; IN_288], record: &mut QueryRecord, io_buffer: &mut IOBuffer, unconstrained: bool, -) -> Result<[G; OUT_292], ExecError> { +) -> Result<[G; OUT_288], ExecError> { stacker::maybe_grow(64 * 1024, 4 * 1024 * 1024, || { let __v_0: G = inp[0]; let __v_1: G = inp[1]; @@ -27928,14 +27654,14 @@ fn aiur_fn_292( 0u64 => { match __v_1.as_canonical_u64() { 0u64 => { - let __ret: [G; OUT_292] = [__v_3, __v_4, __v_5, __v_6, __v_7, __v_8, __v_9, __v_10, __v_11, __v_12, __v_13, __v_14, __v_15, __v_16, __v_17, __v_18, __v_19, __v_20, __v_21, __v_22, __v_23, __v_24, __v_25, __v_26, __v_27, __v_28, __v_29, __v_30, __v_31, __v_32, __v_33, __v_34, __v_35, __v_36, __v_37, __v_38, __v_39, __v_40, __v_41, __v_42, __v_43, __v_44, __v_45, __v_46, __v_47]; - if let Some(result) = record.function_queries[292].get_mut(&inp[..]) { debug_assert_eq!(result.output, &__ret[..]); if !unconstrained { *result.multiplicity += G::ONE; } } else { record.function_queries[292].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained)); }; + let __ret: [G; OUT_288] = [__v_3, __v_4, __v_5, __v_6, __v_7, __v_8, __v_9, __v_10, __v_11, __v_12, __v_13, __v_14, __v_15, __v_16, __v_17, __v_18, __v_19, __v_20, __v_21, __v_22, __v_23, __v_24, __v_25, __v_26, __v_27, __v_28, __v_29, __v_30, __v_31, __v_32, __v_33, __v_34, __v_35, __v_36, __v_37, __v_38, __v_39, __v_40, __v_41, __v_42, __v_43, __v_44, __v_45, __v_46, __v_47]; + if let Some(result) = record.function_queries[288].get_mut(&inp[..]) { debug_assert_eq!(result.output, &__ret[..]); if !unconstrained { *result.multiplicity += G::ONE; } } else { record.function_queries[288].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained)); }; return Ok(__ret); }, _ => { let __v_49: G = G::from_u64(1); let __v_50: G = (__v_1 - __v_49); - let __r_arr: [G; OUT_292] = { let __args: [G; IN_292] = [__v_48, __v_50]; let __cu = unconstrained; if let Some(result) = record.function_queries[292].get_mut(&__args[..]) { if !__cu && *result.multiplicity == G::ZERO { aiur_fn_292(__args, record, io_buffer, false)? } else { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_292] = unsafe { *(result.output.as_ptr() as *const [G; OUT_292]) }; __ret } } else { aiur_fn_292(__args, record, io_buffer, __cu)? } }; + let __r_arr: [G; OUT_288] = { let __args: [G; IN_288] = [__v_48, __v_50]; let __cu = unconstrained; if let Some(result) = record.function_queries[288].get_mut(&__args[..]) { if !__cu && *result.multiplicity == G::ZERO { aiur_fn_288(__args, record, io_buffer, false)? } else { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_288] = unsafe { *(result.output.as_ptr() as *const [G; OUT_288]) }; __ret } } else { aiur_fn_288(__args, record, io_buffer, __cu)? } }; let __v_51: G = __r_arr[0]; let __v_52: G = __r_arr[1]; let __v_53: G = __r_arr[2]; @@ -27981,8 +27707,8 @@ fn aiur_fn_292( let __v_93: G = __r_arr[42]; let __v_94: G = __r_arr[43]; let __v_95: G = __r_arr[44]; - let __ret: [G; OUT_292] = [__v_51, __v_52, __v_53, __v_54, __v_55, __v_56, __v_57, __v_58, __v_59, __v_60, __v_61, __v_62, __v_63, __v_64, __v_65, __v_66, __v_67, __v_68, __v_69, __v_70, __v_71, __v_72, __v_73, __v_74, __v_75, __v_76, __v_77, __v_78, __v_79, __v_80, __v_81, __v_82, __v_83, __v_84, __v_85, __v_86, __v_87, __v_88, __v_89, __v_90, __v_91, __v_92, __v_93, __v_94, __v_95]; - if let Some(result) = record.function_queries[292].get_mut(&inp[..]) { debug_assert_eq!(result.output, &__ret[..]); if !unconstrained { *result.multiplicity += G::ONE; } } else { record.function_queries[292].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained)); }; + let __ret: [G; OUT_288] = [__v_51, __v_52, __v_53, __v_54, __v_55, __v_56, __v_57, __v_58, __v_59, __v_60, __v_61, __v_62, __v_63, __v_64, __v_65, __v_66, __v_67, __v_68, __v_69, __v_70, __v_71, __v_72, __v_73, __v_74, __v_75, __v_76, __v_77, __v_78, __v_79, __v_80, __v_81, __v_82, __v_83, __v_84, __v_85, __v_86, __v_87, __v_88, __v_89, __v_90, __v_91, __v_92, __v_93, __v_94, __v_95]; + if let Some(result) = record.function_queries[288].get_mut(&inp[..]) { debug_assert_eq!(result.output, &__ret[..]); if !unconstrained { *result.multiplicity += G::ONE; } } else { record.function_queries[288].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained)); }; return Ok(__ret); }, } @@ -27994,15 +27720,15 @@ fn aiur_fn_292( }) } -const INPUT_SIZE_293: usize = 1; -const IN_293: usize = 1; -const OUT_293: usize = 8; -fn aiur_fn_293( - inp: [G; IN_293], +const INPUT_SIZE_289: usize = 1; +const IN_289: usize = 1; +const OUT_289: usize = 8; +fn aiur_fn_289( + inp: [G; IN_289], record: &mut QueryRecord, io_buffer: &mut IOBuffer, unconstrained: bool, -) -> Result<[G; OUT_293], ExecError> { +) -> Result<[G; OUT_289], ExecError> { stacker::maybe_grow(64 * 1024, 4 * 1024 * 1024, || { let __v_0: G = inp[0]; let __gb: [u8; 8] = __v_0.as_canonical_u64().to_le_bytes(); @@ -28023,26 +27749,26 @@ fn aiur_fn_293( if (__v_9 != __v_0) { return Err(ExecError::AssertEqMismatch { lhs: __v_9.as_canonical_u64(), rhs: __v_0.as_canonical_u64(), msg: Some("projection index bytes do not recompose to the index".to_string()) }); } - let __ret: [G; OUT_293] = [__v_1, __v_2, __v_3, __v_4, __v_5, __v_6, __v_7, __v_8]; - if let Some(result) = record.function_queries[293].get_mut(&inp[..]) { debug_assert_eq!(result.output, &__ret[..]); if !unconstrained { *result.multiplicity += G::ONE; } } else { record.function_queries[293].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained)); }; + let __ret: [G; OUT_289] = [__v_1, __v_2, __v_3, __v_4, __v_5, __v_6, __v_7, __v_8]; + if let Some(result) = record.function_queries[289].get_mut(&inp[..]) { debug_assert_eq!(result.output, &__ret[..]); if !unconstrained { *result.multiplicity += G::ONE; } } else { record.function_queries[289].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained)); }; return Ok(__ret); }) } -const INPUT_SIZE_294: usize = 3; -const IN_294: usize = 3; -const OUT_294: usize = 1; -fn aiur_fn_294( - inp: [G; IN_294], +const INPUT_SIZE_290: usize = 3; +const IN_290: usize = 3; +const OUT_290: usize = 1; +fn aiur_fn_290( + inp: [G; IN_290], record: &mut QueryRecord, io_buffer: &mut IOBuffer, unconstrained: bool, -) -> Result<[G; OUT_294], ExecError> { +) -> Result<[G; OUT_290], ExecError> { stacker::maybe_grow(64 * 1024, 4 * 1024 * 1024, || { let __v_0: G = inp[0]; let __v_1: G = inp[1]; let __v_2: G = inp[2]; - let __r_arr: [G; OUT_292] = { let __args: [G; IN_292] = [__v_0, __v_2]; let __cu = unconstrained; if let Some(result) = record.function_queries[292].get_mut(&__args[..]) { if !__cu && *result.multiplicity == G::ZERO { aiur_fn_292(__args, record, io_buffer, false)? } else { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_292] = unsafe { *(result.output.as_ptr() as *const [G; OUT_292]) }; __ret } } else { aiur_fn_292(__args, record, io_buffer, __cu)? } }; + let __r_arr: [G; OUT_288] = { let __args: [G; IN_288] = [__v_0, __v_2]; let __cu = unconstrained; if let Some(result) = record.function_queries[288].get_mut(&__args[..]) { if !__cu && *result.multiplicity == G::ZERO { aiur_fn_288(__args, record, io_buffer, false)? } else { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_288] = unsafe { *(result.output.as_ptr() as *const [G; OUT_288]) }; __ret } } else { aiur_fn_288(__args, record, io_buffer, __cu)? } }; let __v_3: G = __r_arr[0]; let __v_4: G = __r_arr[1]; let __v_5: G = __r_arr[2]; @@ -28088,7 +27814,7 @@ fn aiur_fn_294( let __v_45: G = __r_arr[42]; let __v_46: G = __r_arr[43]; let __v_47: G = __r_arr[44]; - let __r_arr: [G; OUT_293] = { let __args: [G; IN_293] = [__v_2]; let __cu = unconstrained; if let Some(result) = record.function_queries[293].get_mut(&__args[..]) { if !__cu && *result.multiplicity == G::ZERO { aiur_fn_293(__args, record, io_buffer, false)? } else { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_293] = unsafe { *(result.output.as_ptr() as *const [G; OUT_293]) }; __ret } } else { aiur_fn_293(__args, record, io_buffer, __cu)? } }; + let __r_arr: [G; OUT_289] = { let __args: [G; IN_289] = [__v_2]; let __cu = unconstrained; if let Some(result) = record.function_queries[289].get_mut(&__args[..]) { if !__cu && *result.multiplicity == G::ZERO { aiur_fn_289(__args, record, io_buffer, false)? } else { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_289] = unsafe { *(result.output.as_ptr() as *const [G; OUT_289]) }; __ret } } else { aiur_fn_289(__args, record, io_buffer, __cu)? } }; let __v_48: G = __r_arr[0]; let __v_49: G = __r_arr[1]; let __v_50: G = __r_arr[2]; @@ -28179,42 +27905,42 @@ fn aiur_fn_294( let __v_113: G = __r_arr[0]; let __r_arr: [G; OUT_21] = { let __args: [G; IN_21] = [__v_113]; let __cu = unconstrained; if let Some(result) = record.function_queries[21].get_mut(&__args[..]) { if !__cu && *result.multiplicity == G::ZERO { aiur_fn_21(__args, record, io_buffer, false)? } else { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_21] = unsafe { *(result.output.as_ptr() as *const [G; OUT_21]) }; __ret } } else { aiur_fn_21(__args, record, io_buffer, __cu)? } }; let __v_114: G = __r_arr[0]; - let __ret: [G; OUT_294] = [__v_114]; - if let Some(result) = record.function_queries[294].get_mut(&inp[..]) { debug_assert_eq!(result.output, &__ret[..]); if !unconstrained { *result.multiplicity += G::ONE; } } else { record.function_queries[294].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained)); }; + let __ret: [G; OUT_290] = [__v_114]; + if let Some(result) = record.function_queries[290].get_mut(&inp[..]) { debug_assert_eq!(result.output, &__ret[..]); if !unconstrained { *result.multiplicity += G::ONE; } } else { record.function_queries[290].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained)); }; return Ok(__ret); }) } -const INPUT_SIZE_295: usize = 2; -const IN_295: usize = 2; -const OUT_295: usize = 1; -fn aiur_fn_295( - inp: [G; IN_295], +const INPUT_SIZE_291: usize = 2; +const IN_291: usize = 2; +const OUT_291: usize = 1; +fn aiur_fn_291( + inp: [G; IN_291], record: &mut QueryRecord, io_buffer: &mut IOBuffer, unconstrained: bool, -) -> Result<[G; OUT_295], ExecError> { +) -> Result<[G; OUT_291], ExecError> { stacker::maybe_grow(64 * 1024, 4 * 1024 * 1024, || { let __v_0: G = inp[0]; let __v_1: G = inp[1]; let __v_2: G = G::from_u64(0); - let __r_arr: [G; OUT_296] = { let __args: [G; IN_296] = [__v_0, __v_1, __v_0, __v_2]; let __cu = unconstrained; if let Some(result) = record.function_queries[296].get_mut(&__args[..]) { if !__cu && *result.multiplicity == G::ZERO { aiur_fn_296(__args, record, io_buffer, false)? } else { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_296] = unsafe { *(result.output.as_ptr() as *const [G; OUT_296]) }; __ret } } else { aiur_fn_296(__args, record, io_buffer, __cu)? } }; + let __r_arr: [G; OUT_292] = { let __args: [G; IN_292] = [__v_0, __v_1, __v_0, __v_2]; let __cu = unconstrained; if let Some(result) = record.function_queries[292].get_mut(&__args[..]) { if !__cu && *result.multiplicity == G::ZERO { aiur_fn_292(__args, record, io_buffer, false)? } else { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_292] = unsafe { *(result.output.as_ptr() as *const [G; OUT_292]) }; __ret } } else { aiur_fn_292(__args, record, io_buffer, __cu)? } }; let __v_3: G = __r_arr[0]; - let __ret: [G; OUT_295] = [__v_3]; - if let Some(result) = record.function_queries[295].get_mut(&inp[..]) { debug_assert_eq!(result.output, &__ret[..]); if !unconstrained { *result.multiplicity += G::ONE; } } else { record.function_queries[295].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained)); }; + let __ret: [G; OUT_291] = [__v_3]; + if let Some(result) = record.function_queries[291].get_mut(&inp[..]) { debug_assert_eq!(result.output, &__ret[..]); if !unconstrained { *result.multiplicity += G::ONE; } } else { record.function_queries[291].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained)); }; return Ok(__ret); }) } -const INPUT_SIZE_296: usize = 4; -const IN_296: usize = 4; -const OUT_296: usize = 1; -fn aiur_fn_296( - inp: [G; IN_296], +const INPUT_SIZE_292: usize = 4; +const IN_292: usize = 4; +const OUT_292: usize = 1; +fn aiur_fn_292( + inp: [G; IN_292], record: &mut QueryRecord, io_buffer: &mut IOBuffer, unconstrained: bool, -) -> Result<[G; OUT_296], ExecError> { +) -> Result<[G; OUT_292], ExecError> { stacker::maybe_grow(64 * 1024, 4 * 1024 * 1024, || { let __v_0: G = inp[0]; let __v_1: G = inp[1]; @@ -28273,21 +27999,21 @@ fn aiur_fn_296( let __v_51: G = G::from_u64(1); let __v_52: G = G::from_u64(1); let __v_53: G = { let __values: [G; 3] = [__v_51, __v_52, __v_52]; let __mq = record.memory_queries.get_mut(&3).ok_or(ExecError::InvalidMemorySize(3))?; if let Some(result) = __mq.get_mut(&__values[..]) { if !unconstrained { *result.multiplicity += G::ONE; } result.output[0] } else { let __ptr = G::from_usize(__mq.len()); __mq.insert(&__values[..], &[__ptr], G::from_bool(!unconstrained)); __ptr } }; - let __ret: [G; OUT_296] = [__v_53]; - if let Some(result) = record.function_queries[296].get_mut(&inp[..]) { debug_assert_eq!(result.output, &__ret[..]); if !unconstrained { *result.multiplicity += G::ONE; } } else { record.function_queries[296].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained)); }; + let __ret: [G; OUT_292] = [__v_53]; + if let Some(result) = record.function_queries[292].get_mut(&inp[..]) { debug_assert_eq!(result.output, &__ret[..]); if !unconstrained { *result.multiplicity += G::ONE; } } else { record.function_queries[292].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained)); }; return Ok(__ret); }, 0u64 => { let __v_51: G = G::from_u64(0); - let __r_arr: [G; OUT_294] = { let __args: [G; IN_294] = [__v_0, __v_1, __v_3]; let __cu = unconstrained; if let Some(result) = record.function_queries[294].get_mut(&__args[..]) { if !__cu && *result.multiplicity == G::ZERO { aiur_fn_294(__args, record, io_buffer, false)? } else { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_294] = unsafe { *(result.output.as_ptr() as *const [G; OUT_294]) }; __ret } } else { aiur_fn_294(__args, record, io_buffer, __cu)? } }; + let __r_arr: [G; OUT_290] = { let __args: [G; IN_290] = [__v_0, __v_1, __v_3]; let __cu = unconstrained; if let Some(result) = record.function_queries[290].get_mut(&__args[..]) { if !__cu && *result.multiplicity == G::ZERO { aiur_fn_290(__args, record, io_buffer, false)? } else { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_290] = unsafe { *(result.output.as_ptr() as *const [G; OUT_290]) }; __ret } } else { aiur_fn_290(__args, record, io_buffer, __cu)? } }; let __v_52: G = __r_arr[0]; let __v_53: G = G::from_u64(1); let __v_54: G = (__v_3 + __v_53); - let __r_arr: [G; OUT_296] = { let __args: [G; IN_296] = [__v_0, __v_1, __v_50, __v_54]; let __cu = unconstrained; if let Some(result) = record.function_queries[296].get_mut(&__args[..]) { if !__cu && *result.multiplicity == G::ZERO { aiur_fn_296(__args, record, io_buffer, false)? } else { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_296] = unsafe { *(result.output.as_ptr() as *const [G; OUT_296]) }; __ret } } else { aiur_fn_296(__args, record, io_buffer, __cu)? } }; + let __r_arr: [G; OUT_292] = { let __args: [G; IN_292] = [__v_0, __v_1, __v_50, __v_54]; let __cu = unconstrained; if let Some(result) = record.function_queries[292].get_mut(&__args[..]) { if !__cu && *result.multiplicity == G::ZERO { aiur_fn_292(__args, record, io_buffer, false)? } else { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_292] = unsafe { *(result.output.as_ptr() as *const [G; OUT_292]) }; __ret } } else { aiur_fn_292(__args, record, io_buffer, __cu)? } }; let __v_55: G = __r_arr[0]; let __v_56: G = { let __values: [G; 3] = [__v_51, __v_52, __v_55]; let __mq = record.memory_queries.get_mut(&3).ok_or(ExecError::InvalidMemorySize(3))?; if let Some(result) = __mq.get_mut(&__values[..]) { if !unconstrained { *result.multiplicity += G::ONE; } result.output[0] } else { let __ptr = G::from_usize(__mq.len()); __mq.insert(&__values[..], &[__ptr], G::from_bool(!unconstrained)); __ptr } }; - let __ret: [G; OUT_296] = [__v_56]; - if let Some(result) = record.function_queries[296].get_mut(&inp[..]) { debug_assert_eq!(result.output, &__ret[..]); if !unconstrained { *result.multiplicity += G::ONE; } } else { record.function_queries[296].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained)); }; + let __ret: [G; OUT_292] = [__v_56]; + if let Some(result) = record.function_queries[292].get_mut(&inp[..]) { debug_assert_eq!(result.output, &__ret[..]); if !unconstrained { *result.multiplicity += G::ONE; } } else { record.function_queries[292].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained)); }; return Ok(__ret); }, _ => { @@ -28297,15 +28023,15 @@ fn aiur_fn_296( }) } -const INPUT_SIZE_297: usize = 1; -const IN_297: usize = 1; -const OUT_297: usize = 1; -fn aiur_fn_297( - inp: [G; IN_297], +const INPUT_SIZE_293: usize = 1; +const IN_293: usize = 1; +const OUT_293: usize = 1; +fn aiur_fn_293( + inp: [G; IN_293], record: &mut QueryRecord, io_buffer: &mut IOBuffer, unconstrained: bool, -) -> Result<[G; OUT_297], ExecError> { +) -> Result<[G; OUT_293], ExecError> { stacker::maybe_grow(64 * 1024, 4 * 1024 * 1024, || { let __v_0: G = inp[0]; let __loaded: [G; 3] = { let __mq = record.memory_queries.get_mut(&3).ok_or(ExecError::InvalidMemorySize(3))?; let __ptr_u64 = __v_0.as_canonical_u64(); let __ptr_usize = usize::try_from(__ptr_u64).ok().ok_or(ExecError::PointerTooLarge(__ptr_u64))?; let (__args, __mult) = __mq.get_index_mut(__ptr_usize).ok_or(ExecError::UnboundPointer { ptr: __ptr_u64, size: 3 })?; if !unconstrained { *__mult += G::ONE; } let __arr: [G; 3] = __args[..3].try_into().unwrap(); __arr }; @@ -28315,57 +28041,57 @@ fn aiur_fn_297( match __v_1.as_canonical_u64() { 0u64 => { let __v_4: G = G::from_u64(0); - let __ret: [G; OUT_297] = [__v_4]; - if let Some(result) = record.function_queries[297].get_mut(&inp[..]) { debug_assert_eq!(result.output, &__ret[..]); if !unconstrained { *result.multiplicity += G::ONE; } } else { record.function_queries[297].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained)); }; + let __ret: [G; OUT_293] = [__v_4]; + if let Some(result) = record.function_queries[293].get_mut(&inp[..]) { debug_assert_eq!(result.output, &__ret[..]); if !unconstrained { *result.multiplicity += G::ONE; } } else { record.function_queries[293].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained)); }; return Ok(__ret); }, 4u64 => { let __v_4: G = G::from_u64(0); - let __ret: [G; OUT_297] = [__v_4]; - if let Some(result) = record.function_queries[297].get_mut(&inp[..]) { debug_assert_eq!(result.output, &__ret[..]); if !unconstrained { *result.multiplicity += G::ONE; } } else { record.function_queries[297].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained)); }; + let __ret: [G; OUT_293] = [__v_4]; + if let Some(result) = record.function_queries[293].get_mut(&inp[..]) { debug_assert_eq!(result.output, &__ret[..]); if !unconstrained { *result.multiplicity += G::ONE; } } else { record.function_queries[293].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained)); }; return Ok(__ret); }, 1u64 => { let __v_4: G = G::from_u64(1); - let __ret: [G; OUT_297] = [__v_4]; - if let Some(result) = record.function_queries[297].get_mut(&inp[..]) { debug_assert_eq!(result.output, &__ret[..]); if !unconstrained { *result.multiplicity += G::ONE; } } else { record.function_queries[297].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained)); }; + let __ret: [G; OUT_293] = [__v_4]; + if let Some(result) = record.function_queries[293].get_mut(&inp[..]) { debug_assert_eq!(result.output, &__ret[..]); if !unconstrained { *result.multiplicity += G::ONE; } } else { record.function_queries[293].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained)); }; return Ok(__ret); }, 2u64 => { - let __r_arr: [G; OUT_297] = { let __args: [G; IN_297] = [__v_2]; let __cu = unconstrained; if let Some(result) = record.function_queries[297].get_mut(&__args[..]) { if !__cu && *result.multiplicity == G::ZERO { aiur_fn_297(__args, record, io_buffer, false)? } else { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_297] = unsafe { *(result.output.as_ptr() as *const [G; OUT_297]) }; __ret } } else { aiur_fn_297(__args, record, io_buffer, __cu)? } }; + let __r_arr: [G; OUT_293] = { let __args: [G; IN_293] = [__v_2]; let __cu = unconstrained; if let Some(result) = record.function_queries[293].get_mut(&__args[..]) { if !__cu && *result.multiplicity == G::ZERO { aiur_fn_293(__args, record, io_buffer, false)? } else { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_293] = unsafe { *(result.output.as_ptr() as *const [G; OUT_293]) }; __ret } } else { aiur_fn_293(__args, record, io_buffer, __cu)? } }; let __v_4: G = __r_arr[0]; - let __r_arr: [G; OUT_297] = { let __args: [G; IN_297] = [__v_3]; let __cu = unconstrained; if let Some(result) = record.function_queries[297].get_mut(&__args[..]) { if !__cu && *result.multiplicity == G::ZERO { aiur_fn_297(__args, record, io_buffer, false)? } else { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_297] = unsafe { *(result.output.as_ptr() as *const [G; OUT_297]) }; __ret } } else { aiur_fn_297(__args, record, io_buffer, __cu)? } }; + let __r_arr: [G; OUT_293] = { let __args: [G; IN_293] = [__v_3]; let __cu = unconstrained; if let Some(result) = record.function_queries[293].get_mut(&__args[..]) { if !__cu && *result.multiplicity == G::ZERO { aiur_fn_293(__args, record, io_buffer, false)? } else { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_293] = unsafe { *(result.output.as_ptr() as *const [G; OUT_293]) }; __ret } } else { aiur_fn_293(__args, record, io_buffer, __cu)? } }; let __v_5: G = __r_arr[0]; match __v_4.as_canonical_u64() { 0u64 => { match __v_5.as_canonical_u64() { 0u64 => { let __v_6: G = G::from_u64(0); - let __ret: [G; OUT_297] = [__v_6]; - if let Some(result) = record.function_queries[297].get_mut(&inp[..]) { debug_assert_eq!(result.output, &__ret[..]); if !unconstrained { *result.multiplicity += G::ONE; } } else { record.function_queries[297].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained)); }; + let __ret: [G; OUT_293] = [__v_6]; + if let Some(result) = record.function_queries[293].get_mut(&inp[..]) { debug_assert_eq!(result.output, &__ret[..]); if !unconstrained { *result.multiplicity += G::ONE; } } else { record.function_queries[293].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained)); }; return Ok(__ret); }, _ => { let __v_6: G = G::from_u64(1); - let __ret: [G; OUT_297] = [__v_6]; - if let Some(result) = record.function_queries[297].get_mut(&inp[..]) { debug_assert_eq!(result.output, &__ret[..]); if !unconstrained { *result.multiplicity += G::ONE; } } else { record.function_queries[297].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained)); }; + let __ret: [G; OUT_293] = [__v_6]; + if let Some(result) = record.function_queries[293].get_mut(&inp[..]) { debug_assert_eq!(result.output, &__ret[..]); if !unconstrained { *result.multiplicity += G::ONE; } } else { record.function_queries[293].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained)); }; return Ok(__ret); }, } }, _ => { let __v_6: G = G::from_u64(1); - let __ret: [G; OUT_297] = [__v_6]; - if let Some(result) = record.function_queries[297].get_mut(&inp[..]) { debug_assert_eq!(result.output, &__ret[..]); if !unconstrained { *result.multiplicity += G::ONE; } } else { record.function_queries[297].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained)); }; + let __ret: [G; OUT_293] = [__v_6]; + if let Some(result) = record.function_queries[293].get_mut(&inp[..]) { debug_assert_eq!(result.output, &__ret[..]); if !unconstrained { *result.multiplicity += G::ONE; } } else { record.function_queries[293].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained)); }; return Ok(__ret); }, } }, 3u64 => { - let __r_arr: [G; OUT_297] = { let __args: [G; IN_297] = [__v_3]; let __cu = unconstrained; if let Some(result) = record.function_queries[297].get_mut(&__args[..]) { if !__cu && *result.multiplicity == G::ZERO { aiur_fn_297(__args, record, io_buffer, false)? } else { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_297] = unsafe { *(result.output.as_ptr() as *const [G; OUT_297]) }; __ret } } else { aiur_fn_297(__args, record, io_buffer, __cu)? } }; + let __r_arr: [G; OUT_293] = { let __args: [G; IN_293] = [__v_3]; let __cu = unconstrained; if let Some(result) = record.function_queries[293].get_mut(&__args[..]) { if !__cu && *result.multiplicity == G::ZERO { aiur_fn_293(__args, record, io_buffer, false)? } else { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_293] = unsafe { *(result.output.as_ptr() as *const [G; OUT_293]) }; __ret } } else { aiur_fn_293(__args, record, io_buffer, __cu)? } }; let __v_4: G = __r_arr[0]; - let __ret: [G; OUT_297] = [__v_4]; - if let Some(result) = record.function_queries[297].get_mut(&inp[..]) { debug_assert_eq!(result.output, &__ret[..]); if !unconstrained { *result.multiplicity += G::ONE; } } else { record.function_queries[297].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained)); }; + let __ret: [G; OUT_293] = [__v_4]; + if let Some(result) = record.function_queries[293].get_mut(&inp[..]) { debug_assert_eq!(result.output, &__ret[..]); if !unconstrained { *result.multiplicity += G::ONE; } } else { record.function_queries[293].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained)); }; return Ok(__ret); }, _ => { @@ -28375,15 +28101,15 @@ fn aiur_fn_297( }) } -const INPUT_SIZE_298: usize = 2; -const IN_298: usize = 2; -const OUT_298: usize = 1; -fn aiur_fn_298( - inp: [G; IN_298], +const INPUT_SIZE_294: usize = 2; +const IN_294: usize = 2; +const OUT_294: usize = 1; +fn aiur_fn_294( + inp: [G; IN_294], record: &mut QueryRecord, io_buffer: &mut IOBuffer, unconstrained: bool, -) -> Result<[G; OUT_298], ExecError> { +) -> Result<[G; OUT_294], ExecError> { stacker::maybe_grow(64 * 1024, 4 * 1024 * 1024, || { let __v_0: G = inp[0]; let __v_1: G = inp[1]; @@ -28400,14 +28126,14 @@ fn aiur_fn_298( match __v_5.as_canonical_u64() { 0u64 => { let __v_8: G = G::from_u64(1); - let __ret: [G; OUT_298] = [__v_8]; - if let Some(result) = record.function_queries[298].get_mut(&inp[..]) { debug_assert_eq!(result.output, &__ret[..]); if !unconstrained { *result.multiplicity += G::ONE; } } else { record.function_queries[298].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained)); }; + let __ret: [G; OUT_294] = [__v_8]; + if let Some(result) = record.function_queries[294].get_mut(&inp[..]) { debug_assert_eq!(result.output, &__ret[..]); if !unconstrained { *result.multiplicity += G::ONE; } } else { record.function_queries[294].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained)); }; return Ok(__ret); }, _ => { let __v_8: G = G::from_u64(0); - let __ret: [G; OUT_298] = [__v_8]; - if let Some(result) = record.function_queries[298].get_mut(&inp[..]) { debug_assert_eq!(result.output, &__ret[..]); if !unconstrained { *result.multiplicity += G::ONE; } } else { record.function_queries[298].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained)); }; + let __ret: [G; OUT_294] = [__v_8]; + if let Some(result) = record.function_queries[294].get_mut(&inp[..]) { debug_assert_eq!(result.output, &__ret[..]); if !unconstrained { *result.multiplicity += G::ONE; } } else { record.function_queries[294].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained)); }; return Ok(__ret); }, } @@ -28419,16 +28145,16 @@ fn aiur_fn_298( let __v_7: G = __loaded[2]; match __v_5.as_canonical_u64() { 1u64 => { - let __r_arr: [G; OUT_298] = { let __args: [G; IN_298] = [__v_3, __v_6]; let __cu = unconstrained; if let Some(result) = record.function_queries[298].get_mut(&__args[..]) { if !__cu && *result.multiplicity == G::ZERO { aiur_fn_298(__args, record, io_buffer, false)? } else { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_298] = unsafe { *(result.output.as_ptr() as *const [G; OUT_298]) }; __ret } } else { aiur_fn_298(__args, record, io_buffer, __cu)? } }; + let __r_arr: [G; OUT_294] = { let __args: [G; IN_294] = [__v_3, __v_6]; let __cu = unconstrained; if let Some(result) = record.function_queries[294].get_mut(&__args[..]) { if !__cu && *result.multiplicity == G::ZERO { aiur_fn_294(__args, record, io_buffer, false)? } else { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_294] = unsafe { *(result.output.as_ptr() as *const [G; OUT_294]) }; __ret } } else { aiur_fn_294(__args, record, io_buffer, __cu)? } }; let __v_8: G = __r_arr[0]; - let __ret: [G; OUT_298] = [__v_8]; - if let Some(result) = record.function_queries[298].get_mut(&inp[..]) { debug_assert_eq!(result.output, &__ret[..]); if !unconstrained { *result.multiplicity += G::ONE; } } else { record.function_queries[298].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained)); }; + let __ret: [G; OUT_294] = [__v_8]; + if let Some(result) = record.function_queries[294].get_mut(&inp[..]) { debug_assert_eq!(result.output, &__ret[..]); if !unconstrained { *result.multiplicity += G::ONE; } } else { record.function_queries[294].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained)); }; return Ok(__ret); }, _ => { let __v_8: G = G::from_u64(0); - let __ret: [G; OUT_298] = [__v_8]; - if let Some(result) = record.function_queries[298].get_mut(&inp[..]) { debug_assert_eq!(result.output, &__ret[..]); if !unconstrained { *result.multiplicity += G::ONE; } } else { record.function_queries[298].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained)); }; + let __ret: [G; OUT_294] = [__v_8]; + if let Some(result) = record.function_queries[294].get_mut(&inp[..]) { debug_assert_eq!(result.output, &__ret[..]); if !unconstrained { *result.multiplicity += G::ONE; } } else { record.function_queries[294].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained)); }; return Ok(__ret); }, } @@ -28440,19 +28166,19 @@ fn aiur_fn_298( let __v_7: G = __loaded[2]; match __v_5.as_canonical_u64() { 2u64 => { - let __r_arr: [G; OUT_298] = { let __args: [G; IN_298] = [__v_3, __v_6]; let __cu = unconstrained; if let Some(result) = record.function_queries[298].get_mut(&__args[..]) { if !__cu && *result.multiplicity == G::ZERO { aiur_fn_298(__args, record, io_buffer, false)? } else { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_298] = unsafe { *(result.output.as_ptr() as *const [G; OUT_298]) }; __ret } } else { aiur_fn_298(__args, record, io_buffer, __cu)? } }; + let __r_arr: [G; OUT_294] = { let __args: [G; IN_294] = [__v_3, __v_6]; let __cu = unconstrained; if let Some(result) = record.function_queries[294].get_mut(&__args[..]) { if !__cu && *result.multiplicity == G::ZERO { aiur_fn_294(__args, record, io_buffer, false)? } else { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_294] = unsafe { *(result.output.as_ptr() as *const [G; OUT_294]) }; __ret } } else { aiur_fn_294(__args, record, io_buffer, __cu)? } }; let __v_8: G = __r_arr[0]; - let __r_arr: [G; OUT_298] = { let __args: [G; IN_298] = [__v_4, __v_7]; let __cu = unconstrained; if let Some(result) = record.function_queries[298].get_mut(&__args[..]) { if !__cu && *result.multiplicity == G::ZERO { aiur_fn_298(__args, record, io_buffer, false)? } else { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_298] = unsafe { *(result.output.as_ptr() as *const [G; OUT_298]) }; __ret } } else { aiur_fn_298(__args, record, io_buffer, __cu)? } }; + let __r_arr: [G; OUT_294] = { let __args: [G; IN_294] = [__v_4, __v_7]; let __cu = unconstrained; if let Some(result) = record.function_queries[294].get_mut(&__args[..]) { if !__cu && *result.multiplicity == G::ZERO { aiur_fn_294(__args, record, io_buffer, false)? } else { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_294] = unsafe { *(result.output.as_ptr() as *const [G; OUT_294]) }; __ret } } else { aiur_fn_294(__args, record, io_buffer, __cu)? } }; let __v_9: G = __r_arr[0]; let __v_10: G = (__v_8 * __v_9); - let __ret: [G; OUT_298] = [__v_10]; - if let Some(result) = record.function_queries[298].get_mut(&inp[..]) { debug_assert_eq!(result.output, &__ret[..]); if !unconstrained { *result.multiplicity += G::ONE; } } else { record.function_queries[298].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained)); }; + let __ret: [G; OUT_294] = [__v_10]; + if let Some(result) = record.function_queries[294].get_mut(&inp[..]) { debug_assert_eq!(result.output, &__ret[..]); if !unconstrained { *result.multiplicity += G::ONE; } } else { record.function_queries[294].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained)); }; return Ok(__ret); }, _ => { let __v_8: G = G::from_u64(0); - let __ret: [G; OUT_298] = [__v_8]; - if let Some(result) = record.function_queries[298].get_mut(&inp[..]) { debug_assert_eq!(result.output, &__ret[..]); if !unconstrained { *result.multiplicity += G::ONE; } } else { record.function_queries[298].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained)); }; + let __ret: [G; OUT_294] = [__v_8]; + if let Some(result) = record.function_queries[294].get_mut(&inp[..]) { debug_assert_eq!(result.output, &__ret[..]); if !unconstrained { *result.multiplicity += G::ONE; } } else { record.function_queries[294].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained)); }; return Ok(__ret); }, } @@ -28464,19 +28190,19 @@ fn aiur_fn_298( let __v_7: G = __loaded[2]; match __v_5.as_canonical_u64() { 3u64 => { - let __r_arr: [G; OUT_298] = { let __args: [G; IN_298] = [__v_3, __v_6]; let __cu = unconstrained; if let Some(result) = record.function_queries[298].get_mut(&__args[..]) { if !__cu && *result.multiplicity == G::ZERO { aiur_fn_298(__args, record, io_buffer, false)? } else { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_298] = unsafe { *(result.output.as_ptr() as *const [G; OUT_298]) }; __ret } } else { aiur_fn_298(__args, record, io_buffer, __cu)? } }; + let __r_arr: [G; OUT_294] = { let __args: [G; IN_294] = [__v_3, __v_6]; let __cu = unconstrained; if let Some(result) = record.function_queries[294].get_mut(&__args[..]) { if !__cu && *result.multiplicity == G::ZERO { aiur_fn_294(__args, record, io_buffer, false)? } else { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_294] = unsafe { *(result.output.as_ptr() as *const [G; OUT_294]) }; __ret } } else { aiur_fn_294(__args, record, io_buffer, __cu)? } }; let __v_8: G = __r_arr[0]; - let __r_arr: [G; OUT_298] = { let __args: [G; IN_298] = [__v_4, __v_7]; let __cu = unconstrained; if let Some(result) = record.function_queries[298].get_mut(&__args[..]) { if !__cu && *result.multiplicity == G::ZERO { aiur_fn_298(__args, record, io_buffer, false)? } else { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_298] = unsafe { *(result.output.as_ptr() as *const [G; OUT_298]) }; __ret } } else { aiur_fn_298(__args, record, io_buffer, __cu)? } }; + let __r_arr: [G; OUT_294] = { let __args: [G; IN_294] = [__v_4, __v_7]; let __cu = unconstrained; if let Some(result) = record.function_queries[294].get_mut(&__args[..]) { if !__cu && *result.multiplicity == G::ZERO { aiur_fn_294(__args, record, io_buffer, false)? } else { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_294] = unsafe { *(result.output.as_ptr() as *const [G; OUT_294]) }; __ret } } else { aiur_fn_294(__args, record, io_buffer, __cu)? } }; let __v_9: G = __r_arr[0]; let __v_10: G = (__v_8 * __v_9); - let __ret: [G; OUT_298] = [__v_10]; - if let Some(result) = record.function_queries[298].get_mut(&inp[..]) { debug_assert_eq!(result.output, &__ret[..]); if !unconstrained { *result.multiplicity += G::ONE; } } else { record.function_queries[298].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained)); }; + let __ret: [G; OUT_294] = [__v_10]; + if let Some(result) = record.function_queries[294].get_mut(&inp[..]) { debug_assert_eq!(result.output, &__ret[..]); if !unconstrained { *result.multiplicity += G::ONE; } } else { record.function_queries[294].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained)); }; return Ok(__ret); }, _ => { let __v_8: G = G::from_u64(0); - let __ret: [G; OUT_298] = [__v_8]; - if let Some(result) = record.function_queries[298].get_mut(&inp[..]) { debug_assert_eq!(result.output, &__ret[..]); if !unconstrained { *result.multiplicity += G::ONE; } } else { record.function_queries[298].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained)); }; + let __ret: [G; OUT_294] = [__v_8]; + if let Some(result) = record.function_queries[294].get_mut(&inp[..]) { debug_assert_eq!(result.output, &__ret[..]); if !unconstrained { *result.multiplicity += G::ONE; } } else { record.function_queries[294].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained)); }; return Ok(__ret); }, } @@ -28490,14 +28216,14 @@ fn aiur_fn_298( 4u64 => { let __v_8: G = (__v_3 - __v_6); let __v_9: G = G::from_bool((__v_8 == G::ZERO)); - let __ret: [G; OUT_298] = [__v_9]; - if let Some(result) = record.function_queries[298].get_mut(&inp[..]) { debug_assert_eq!(result.output, &__ret[..]); if !unconstrained { *result.multiplicity += G::ONE; } } else { record.function_queries[298].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained)); }; + let __ret: [G; OUT_294] = [__v_9]; + if let Some(result) = record.function_queries[294].get_mut(&inp[..]) { debug_assert_eq!(result.output, &__ret[..]); if !unconstrained { *result.multiplicity += G::ONE; } } else { record.function_queries[294].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained)); }; return Ok(__ret); }, _ => { let __v_8: G = G::from_u64(0); - let __ret: [G; OUT_298] = [__v_8]; - if let Some(result) = record.function_queries[298].get_mut(&inp[..]) { debug_assert_eq!(result.output, &__ret[..]); if !unconstrained { *result.multiplicity += G::ONE; } } else { record.function_queries[298].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained)); }; + let __ret: [G; OUT_294] = [__v_8]; + if let Some(result) = record.function_queries[294].get_mut(&inp[..]) { debug_assert_eq!(result.output, &__ret[..]); if !unconstrained { *result.multiplicity += G::ONE; } } else { record.function_queries[294].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained)); }; return Ok(__ret); }, } @@ -28509,15 +28235,15 @@ fn aiur_fn_298( }) } -const INPUT_SIZE_299: usize = 2; -const IN_299: usize = 2; -const OUT_299: usize = 1; -fn aiur_fn_299( - inp: [G; IN_299], +const INPUT_SIZE_295: usize = 2; +const IN_295: usize = 2; +const OUT_295: usize = 1; +fn aiur_fn_295( + inp: [G; IN_295], record: &mut QueryRecord, io_buffer: &mut IOBuffer, unconstrained: bool, -) -> Result<[G; OUT_299], ExecError> { +) -> Result<[G; OUT_295], ExecError> { stacker::maybe_grow(64 * 1024, 4 * 1024 * 1024, || { let __v_0: G = inp[0]; let __v_1: G = inp[1]; @@ -28534,14 +28260,14 @@ fn aiur_fn_299( match __v_5.as_canonical_u64() { 1u64 => { let __v_8: G = G::from_u64(0); - let __ret: [G; OUT_299] = [__v_8]; - if let Some(result) = record.function_queries[299].get_mut(&inp[..]) { debug_assert_eq!(result.output, &__ret[..]); if !unconstrained { *result.multiplicity += G::ONE; } } else { record.function_queries[299].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained)); }; + let __ret: [G; OUT_295] = [__v_8]; + if let Some(result) = record.function_queries[295].get_mut(&inp[..]) { debug_assert_eq!(result.output, &__ret[..]); if !unconstrained { *result.multiplicity += G::ONE; } } else { record.function_queries[295].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained)); }; return Ok(__ret); }, 0u64 => { let __v_8: G = G::from_u64(1); - let __ret: [G; OUT_299] = [__v_8]; - if let Some(result) = record.function_queries[299].get_mut(&inp[..]) { debug_assert_eq!(result.output, &__ret[..]); if !unconstrained { *result.multiplicity += G::ONE; } } else { record.function_queries[299].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained)); }; + let __ret: [G; OUT_295] = [__v_8]; + if let Some(result) = record.function_queries[295].get_mut(&inp[..]) { debug_assert_eq!(result.output, &__ret[..]); if !unconstrained { *result.multiplicity += G::ONE; } } else { record.function_queries[295].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained)); }; return Ok(__ret); }, _ => { @@ -28557,8 +28283,8 @@ fn aiur_fn_299( match __v_5.as_canonical_u64() { 1u64 => { let __v_8: G = G::from_u64(2); - let __ret: [G; OUT_299] = [__v_8]; - if let Some(result) = record.function_queries[299].get_mut(&inp[..]) { debug_assert_eq!(result.output, &__ret[..]); if !unconstrained { *result.multiplicity += G::ONE; } } else { record.function_queries[299].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained)); }; + let __ret: [G; OUT_295] = [__v_8]; + if let Some(result) = record.function_queries[295].get_mut(&inp[..]) { debug_assert_eq!(result.output, &__ret[..]); if !unconstrained { *result.multiplicity += G::ONE; } } else { record.function_queries[295].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained)); }; return Ok(__ret); }, 0u64 => { @@ -28566,8 +28292,8 @@ fn aiur_fn_299( match __v_8.as_canonical_u64() { 1u64 => { let __v_9: G = G::from_u64(1); - let __ret: [G; OUT_299] = [__v_9]; - if let Some(result) = record.function_queries[299].get_mut(&inp[..]) { debug_assert_eq!(result.output, &__ret[..]); if !unconstrained { *result.multiplicity += G::ONE; } } else { record.function_queries[299].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained)); }; + let __ret: [G; OUT_295] = [__v_9]; + if let Some(result) = record.function_queries[295].get_mut(&inp[..]) { debug_assert_eq!(result.output, &__ret[..]); if !unconstrained { *result.multiplicity += G::ONE; } } else { record.function_queries[295].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained)); }; return Ok(__ret); }, 0u64 => { @@ -28575,15 +28301,15 @@ fn aiur_fn_299( match __v_9.as_canonical_u64() { 1u64 => { let __v_10: G = G::from_u64(2); - let __ret: [G; OUT_299] = [__v_10]; - if let Some(result) = record.function_queries[299].get_mut(&inp[..]) { debug_assert_eq!(result.output, &__ret[..]); if !unconstrained { *result.multiplicity += G::ONE; } } else { record.function_queries[299].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained)); }; + let __ret: [G; OUT_295] = [__v_10]; + if let Some(result) = record.function_queries[295].get_mut(&inp[..]) { debug_assert_eq!(result.output, &__ret[..]); if !unconstrained { *result.multiplicity += G::ONE; } } else { record.function_queries[295].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained)); }; return Ok(__ret); }, 0u64 => { - let __r_arr: [G; OUT_299] = { let __args: [G; IN_299] = [__v_4, __v_7]; let __cu = unconstrained; if let Some(result) = record.function_queries[299].get_mut(&__args[..]) { if !__cu && *result.multiplicity == G::ZERO { aiur_fn_299(__args, record, io_buffer, false)? } else { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_299] = unsafe { *(result.output.as_ptr() as *const [G; OUT_299]) }; __ret } } else { aiur_fn_299(__args, record, io_buffer, __cu)? } }; + let __r_arr: [G; OUT_295] = { let __args: [G; IN_295] = [__v_4, __v_7]; let __cu = unconstrained; if let Some(result) = record.function_queries[295].get_mut(&__args[..]) { if !__cu && *result.multiplicity == G::ZERO { aiur_fn_295(__args, record, io_buffer, false)? } else { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_295] = unsafe { *(result.output.as_ptr() as *const [G; OUT_295]) }; __ret } } else { aiur_fn_295(__args, record, io_buffer, __cu)? } }; let __v_10: G = __r_arr[0]; - let __ret: [G; OUT_299] = [__v_10]; - if let Some(result) = record.function_queries[299].get_mut(&inp[..]) { debug_assert_eq!(result.output, &__ret[..]); if !unconstrained { *result.multiplicity += G::ONE; } } else { record.function_queries[299].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained)); }; + let __ret: [G; OUT_295] = [__v_10]; + if let Some(result) = record.function_queries[295].get_mut(&inp[..]) { debug_assert_eq!(result.output, &__ret[..]); if !unconstrained { *result.multiplicity += G::ONE; } } else { record.function_queries[295].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained)); }; return Ok(__ret); }, _ => { @@ -28608,15 +28334,15 @@ fn aiur_fn_299( }) } -const INPUT_SIZE_300: usize = 2; -const IN_300: usize = 2; -const OUT_300: usize = 1; -fn aiur_fn_300( - inp: [G; IN_300], +const INPUT_SIZE_296: usize = 2; +const IN_296: usize = 2; +const OUT_296: usize = 1; +fn aiur_fn_296( + inp: [G; IN_296], record: &mut QueryRecord, io_buffer: &mut IOBuffer, unconstrained: bool, -) -> Result<[G; OUT_300], ExecError> { +) -> Result<[G; OUT_296], ExecError> { stacker::maybe_grow(64 * 1024, 4 * 1024 * 1024, || { let __v_0: G = inp[0]; let __v_1: G = inp[1]; @@ -28627,8 +28353,8 @@ fn aiur_fn_300( match __v_2.as_canonical_u64() { 1u64 => { let __v_5: G = G::from_u64(1); - let __ret: [G; OUT_300] = [__v_5]; - if let Some(result) = record.function_queries[300].get_mut(&inp[..]) { debug_assert_eq!(result.output, &__ret[..]); if !unconstrained { *result.multiplicity += G::ONE; } } else { record.function_queries[300].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained)); }; + let __ret: [G; OUT_296] = [__v_5]; + if let Some(result) = record.function_queries[296].get_mut(&inp[..]) { debug_assert_eq!(result.output, &__ret[..]); if !unconstrained { *result.multiplicity += G::ONE; } } else { record.function_queries[296].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained)); }; return Ok(__ret); }, 0u64 => { @@ -28639,8 +28365,8 @@ fn aiur_fn_300( match __v_5.as_canonical_u64() { 1u64 => { let __v_8: G = G::from_u64(0); - let __ret: [G; OUT_300] = [__v_8]; - if let Some(result) = record.function_queries[300].get_mut(&inp[..]) { debug_assert_eq!(result.output, &__ret[..]); if !unconstrained { *result.multiplicity += G::ONE; } } else { record.function_queries[300].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained)); }; + let __ret: [G; OUT_296] = [__v_8]; + if let Some(result) = record.function_queries[296].get_mut(&inp[..]) { debug_assert_eq!(result.output, &__ret[..]); if !unconstrained { *result.multiplicity += G::ONE; } } else { record.function_queries[296].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained)); }; return Ok(__ret); }, 0u64 => { @@ -28648,25 +28374,25 @@ fn aiur_fn_300( match __v_8.as_canonical_u64() { 1u64 => { let __v_9: G = G::from_u64(0); - let __ret: [G; OUT_300] = [__v_9]; - if let Some(result) = record.function_queries[300].get_mut(&inp[..]) { debug_assert_eq!(result.output, &__ret[..]); if !unconstrained { *result.multiplicity += G::ONE; } } else { record.function_queries[300].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained)); }; + let __ret: [G; OUT_296] = [__v_9]; + if let Some(result) = record.function_queries[296].get_mut(&inp[..]) { debug_assert_eq!(result.output, &__ret[..]); if !unconstrained { *result.multiplicity += G::ONE; } } else { record.function_queries[296].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained)); }; return Ok(__ret); }, 0u64 => { let __v_9: G = { let __a_val = __v_6.as_canonical_u64(); let __b_val = __v_3.as_canonical_u64(); let __a_u32 = u32::try_from(__a_val).ok().ok_or(ExecError::U32OutOfRange(__a_val))?; let __b_u32 = u32::try_from(__b_val).ok().ok_or(ExecError::U32OutOfRange(__b_val))?; let __result = G::from_bool(__a_u32 < __b_u32); if !unconstrained { let __x_bytes = __a_u32.to_le_bytes(); let __z_bytes = __b_u32.to_le_bytes(); let __c_u32 = __b_u32.wrapping_sub(__a_u32).wrapping_sub(1); let __y_bytes = __c_u32.to_le_bytes(); record.bytes2_queries.bump_range_check(&G::from_u8(__x_bytes[0]), &G::from_u8(__x_bytes[1])); record.bytes2_queries.bump_range_check(&G::from_u8(__x_bytes[2]), &G::from_u8(__x_bytes[3])); record.bytes2_queries.bump_range_check(&G::from_u8(__y_bytes[0]), &G::from_u8(__y_bytes[1])); record.bytes2_queries.bump_range_check(&G::from_u8(__y_bytes[2]), &G::from_u8(__y_bytes[3])); record.bytes2_queries.bump_range_check(&G::from_u8(__z_bytes[0]), &G::from_u8(__z_bytes[1])); record.bytes2_queries.bump_range_check(&G::from_u8(__z_bytes[2]), &G::from_u8(__z_bytes[3])); } __result }; match __v_9.as_canonical_u64() { 1u64 => { - let __r_arr: [G; OUT_300] = { let __args: [G; IN_300] = [__v_0, __v_7]; let __cu = unconstrained; if let Some(result) = record.function_queries[300].get_mut(&__args[..]) { if !__cu && *result.multiplicity == G::ZERO { aiur_fn_300(__args, record, io_buffer, false)? } else { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_300] = unsafe { *(result.output.as_ptr() as *const [G; OUT_300]) }; __ret } } else { aiur_fn_300(__args, record, io_buffer, __cu)? } }; + let __r_arr: [G; OUT_296] = { let __args: [G; IN_296] = [__v_0, __v_7]; let __cu = unconstrained; if let Some(result) = record.function_queries[296].get_mut(&__args[..]) { if !__cu && *result.multiplicity == G::ZERO { aiur_fn_296(__args, record, io_buffer, false)? } else { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_296] = unsafe { *(result.output.as_ptr() as *const [G; OUT_296]) }; __ret } } else { aiur_fn_296(__args, record, io_buffer, __cu)? } }; let __v_10: G = __r_arr[0]; - let __ret: [G; OUT_300] = [__v_10]; - if let Some(result) = record.function_queries[300].get_mut(&inp[..]) { debug_assert_eq!(result.output, &__ret[..]); if !unconstrained { *result.multiplicity += G::ONE; } } else { record.function_queries[300].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained)); }; + let __ret: [G; OUT_296] = [__v_10]; + if let Some(result) = record.function_queries[296].get_mut(&inp[..]) { debug_assert_eq!(result.output, &__ret[..]); if !unconstrained { *result.multiplicity += G::ONE; } } else { record.function_queries[296].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained)); }; return Ok(__ret); }, 0u64 => { - let __r_arr: [G; OUT_300] = { let __args: [G; IN_300] = [__v_4, __v_7]; let __cu = unconstrained; if let Some(result) = record.function_queries[300].get_mut(&__args[..]) { if !__cu && *result.multiplicity == G::ZERO { aiur_fn_300(__args, record, io_buffer, false)? } else { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_300] = unsafe { *(result.output.as_ptr() as *const [G; OUT_300]) }; __ret } } else { aiur_fn_300(__args, record, io_buffer, __cu)? } }; + let __r_arr: [G; OUT_296] = { let __args: [G; IN_296] = [__v_4, __v_7]; let __cu = unconstrained; if let Some(result) = record.function_queries[296].get_mut(&__args[..]) { if !__cu && *result.multiplicity == G::ZERO { aiur_fn_296(__args, record, io_buffer, false)? } else { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_296] = unsafe { *(result.output.as_ptr() as *const [G; OUT_296]) }; __ret } } else { aiur_fn_296(__args, record, io_buffer, __cu)? } }; let __v_10: G = __r_arr[0]; - let __ret: [G; OUT_300] = [__v_10]; - if let Some(result) = record.function_queries[300].get_mut(&inp[..]) { debug_assert_eq!(result.output, &__ret[..]); if !unconstrained { *result.multiplicity += G::ONE; } } else { record.function_queries[300].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained)); }; + let __ret: [G; OUT_296] = [__v_10]; + if let Some(result) = record.function_queries[296].get_mut(&inp[..]) { debug_assert_eq!(result.output, &__ret[..]); if !unconstrained { *result.multiplicity += G::ONE; } } else { record.function_queries[296].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained)); }; return Ok(__ret); }, _ => { @@ -28691,15 +28417,15 @@ fn aiur_fn_300( }) } -const INPUT_SIZE_301: usize = 2; -const IN_301: usize = 2; -const OUT_301: usize = 1; -fn aiur_fn_301( - inp: [G; IN_301], +const INPUT_SIZE_297: usize = 2; +const IN_297: usize = 2; +const OUT_297: usize = 1; +fn aiur_fn_297( + inp: [G; IN_297], record: &mut QueryRecord, io_buffer: &mut IOBuffer, unconstrained: bool, -) -> Result<[G; OUT_301], ExecError> { +) -> Result<[G; OUT_297], ExecError> { stacker::maybe_grow(64 * 1024, 4 * 1024 * 1024, || { let __v_0: G = inp[0]; let __v_1: G = inp[1]; @@ -28716,14 +28442,14 @@ fn aiur_fn_301( match __v_5.as_canonical_u64() { 1u64 => { let __v_8: G = G::from_u64(1); - let __ret: [G; OUT_301] = [__v_8]; - if let Some(result) = record.function_queries[301].get_mut(&inp[..]) { debug_assert_eq!(result.output, &__ret[..]); if !unconstrained { *result.multiplicity += G::ONE; } } else { record.function_queries[301].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained)); }; + let __ret: [G; OUT_297] = [__v_8]; + if let Some(result) = record.function_queries[297].get_mut(&inp[..]) { debug_assert_eq!(result.output, &__ret[..]); if !unconstrained { *result.multiplicity += G::ONE; } } else { record.function_queries[297].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained)); }; return Ok(__ret); }, 0u64 => { let __v_8: G = G::from_u64(0); - let __ret: [G; OUT_301] = [__v_8]; - if let Some(result) = record.function_queries[301].get_mut(&inp[..]) { debug_assert_eq!(result.output, &__ret[..]); if !unconstrained { *result.multiplicity += G::ONE; } } else { record.function_queries[301].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained)); }; + let __ret: [G; OUT_297] = [__v_8]; + if let Some(result) = record.function_queries[297].get_mut(&inp[..]) { debug_assert_eq!(result.output, &__ret[..]); if !unconstrained { *result.multiplicity += G::ONE; } } else { record.function_queries[297].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained)); }; return Ok(__ret); }, _ => { @@ -28739,15 +28465,15 @@ fn aiur_fn_301( match __v_5.as_canonical_u64() { 1u64 => { let __v_8: G = G::from_u64(0); - let __ret: [G; OUT_301] = [__v_8]; - if let Some(result) = record.function_queries[301].get_mut(&inp[..]) { debug_assert_eq!(result.output, &__ret[..]); if !unconstrained { *result.multiplicity += G::ONE; } } else { record.function_queries[301].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained)); }; + let __ret: [G; OUT_297] = [__v_8]; + if let Some(result) = record.function_queries[297].get_mut(&inp[..]) { debug_assert_eq!(result.output, &__ret[..]); if !unconstrained { *result.multiplicity += G::ONE; } } else { record.function_queries[297].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained)); }; return Ok(__ret); }, 0u64 => { - let __r_arr: [G; OUT_301] = { let __args: [G; IN_301] = [__v_4, __v_7]; let __cu = unconstrained; if let Some(result) = record.function_queries[301].get_mut(&__args[..]) { if !__cu && *result.multiplicity == G::ZERO { aiur_fn_301(__args, record, io_buffer, false)? } else { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_301] = unsafe { *(result.output.as_ptr() as *const [G; OUT_301]) }; __ret } } else { aiur_fn_301(__args, record, io_buffer, __cu)? } }; + let __r_arr: [G; OUT_297] = { let __args: [G; IN_297] = [__v_4, __v_7]; let __cu = unconstrained; if let Some(result) = record.function_queries[297].get_mut(&__args[..]) { if !__cu && *result.multiplicity == G::ZERO { aiur_fn_297(__args, record, io_buffer, false)? } else { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_297] = unsafe { *(result.output.as_ptr() as *const [G; OUT_297]) }; __ret } } else { aiur_fn_297(__args, record, io_buffer, __cu)? } }; let __v_8: G = __r_arr[0]; - let __ret: [G; OUT_301] = [__v_8]; - if let Some(result) = record.function_queries[301].get_mut(&inp[..]) { debug_assert_eq!(result.output, &__ret[..]); if !unconstrained { *result.multiplicity += G::ONE; } } else { record.function_queries[301].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained)); }; + let __ret: [G; OUT_297] = [__v_8]; + if let Some(result) = record.function_queries[297].get_mut(&inp[..]) { debug_assert_eq!(result.output, &__ret[..]); if !unconstrained { *result.multiplicity += G::ONE; } } else { record.function_queries[297].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained)); }; return Ok(__ret); }, _ => { @@ -28762,15 +28488,15 @@ fn aiur_fn_301( }) } -const INPUT_SIZE_302: usize = 2; -const IN_302: usize = 2; -const OUT_302: usize = 2; -fn aiur_fn_302( - inp: [G; IN_302], +const INPUT_SIZE_298: usize = 2; +const IN_298: usize = 2; +const OUT_298: usize = 2; +fn aiur_fn_298( + inp: [G; IN_298], record: &mut QueryRecord, io_buffer: &mut IOBuffer, unconstrained: bool, -) -> Result<[G; OUT_302], ExecError> { +) -> Result<[G; OUT_298], ExecError> { stacker::maybe_grow(64 * 1024, 4 * 1024 * 1024, || { let __v_0: G = inp[0]; let __v_1: G = inp[1]; @@ -28786,8 +28512,8 @@ fn aiur_fn_302( let __v_8: G = G::from_u64(1); let __v_9: G = { let __values: [G; 3] = [__v_7, __v_8, __v_8]; let __mq = record.memory_queries.get_mut(&3).ok_or(ExecError::InvalidMemorySize(3))?; if let Some(result) = __mq.get_mut(&__values[..]) { if !unconstrained { *result.multiplicity += G::ONE; } result.output[0] } else { let __ptr = G::from_usize(__mq.len()); __mq.insert(&__values[..], &[__ptr], G::from_bool(!unconstrained)); __ptr } }; let __v_10: G = { let __values: [G; 3] = [__v_6, __v_0, __v_9]; let __mq = record.memory_queries.get_mut(&3).ok_or(ExecError::InvalidMemorySize(3))?; if let Some(result) = __mq.get_mut(&__values[..]) { if !unconstrained { *result.multiplicity += G::ONE; } result.output[0] } else { let __ptr = G::from_usize(__mq.len()); __mq.insert(&__values[..], &[__ptr], G::from_bool(!unconstrained)); __ptr } }; - let __ret: [G; OUT_302] = [__v_5, __v_10]; - if let Some(result) = record.function_queries[302].get_mut(&inp[..]) { debug_assert_eq!(result.output, &__ret[..]); if !unconstrained { *result.multiplicity += G::ONE; } } else { record.function_queries[302].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained)); }; + let __ret: [G; OUT_298] = [__v_5, __v_10]; + if let Some(result) = record.function_queries[298].get_mut(&inp[..]) { debug_assert_eq!(result.output, &__ret[..]); if !unconstrained { *result.multiplicity += G::ONE; } } else { record.function_queries[298].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained)); }; return Ok(__ret); }, 0u64 => { @@ -28797,8 +28523,8 @@ fn aiur_fn_302( let __v_6: G = G::from_u64(1); let __v_7: G = G::from_u64(0); let __v_8: G = { let __values: [G; 3] = [__v_7, __v_0, __v_1]; let __mq = record.memory_queries.get_mut(&3).ok_or(ExecError::InvalidMemorySize(3))?; if let Some(result) = __mq.get_mut(&__values[..]) { if !unconstrained { *result.multiplicity += G::ONE; } result.output[0] } else { let __ptr = G::from_usize(__mq.len()); __mq.insert(&__values[..], &[__ptr], G::from_bool(!unconstrained)); __ptr } }; - let __ret: [G; OUT_302] = [__v_6, __v_8]; - if let Some(result) = record.function_queries[302].get_mut(&inp[..]) { debug_assert_eq!(result.output, &__ret[..]); if !unconstrained { *result.multiplicity += G::ONE; } } else { record.function_queries[302].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained)); }; + let __ret: [G; OUT_298] = [__v_6, __v_8]; + if let Some(result) = record.function_queries[298].get_mut(&inp[..]) { debug_assert_eq!(result.output, &__ret[..]); if !unconstrained { *result.multiplicity += G::ONE; } } else { record.function_queries[298].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained)); }; return Ok(__ret); }, 0u64 => { @@ -28806,18 +28532,18 @@ fn aiur_fn_302( match __v_6.as_canonical_u64() { 0u64 => { let __v_7: G = G::from_u64(0); - let __ret: [G; OUT_302] = [__v_7, __v_1]; - if let Some(result) = record.function_queries[302].get_mut(&inp[..]) { debug_assert_eq!(result.output, &__ret[..]); if !unconstrained { *result.multiplicity += G::ONE; } } else { record.function_queries[302].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained)); }; + let __ret: [G; OUT_298] = [__v_7, __v_1]; + if let Some(result) = record.function_queries[298].get_mut(&inp[..]) { debug_assert_eq!(result.output, &__ret[..]); if !unconstrained { *result.multiplicity += G::ONE; } } else { record.function_queries[298].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained)); }; return Ok(__ret); }, 1u64 => { - let __r_arr: [G; OUT_302] = { let __args: [G; IN_302] = [__v_0, __v_4]; let __cu = unconstrained; if let Some(result) = record.function_queries[302].get_mut(&__args[..]) { if !__cu && *result.multiplicity == G::ZERO { aiur_fn_302(__args, record, io_buffer, false)? } else { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_302] = unsafe { *(result.output.as_ptr() as *const [G; OUT_302]) }; __ret } } else { aiur_fn_302(__args, record, io_buffer, __cu)? } }; + let __r_arr: [G; OUT_298] = { let __args: [G; IN_298] = [__v_0, __v_4]; let __cu = unconstrained; if let Some(result) = record.function_queries[298].get_mut(&__args[..]) { if !__cu && *result.multiplicity == G::ZERO { aiur_fn_298(__args, record, io_buffer, false)? } else { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_298] = unsafe { *(result.output.as_ptr() as *const [G; OUT_298]) }; __ret } } else { aiur_fn_298(__args, record, io_buffer, __cu)? } }; let __v_7: G = __r_arr[0]; let __v_8: G = __r_arr[1]; let __v_9: G = G::from_u64(0); let __v_10: G = { let __values: [G; 3] = [__v_9, __v_3, __v_8]; let __mq = record.memory_queries.get_mut(&3).ok_or(ExecError::InvalidMemorySize(3))?; if let Some(result) = __mq.get_mut(&__values[..]) { if !unconstrained { *result.multiplicity += G::ONE; } result.output[0] } else { let __ptr = G::from_usize(__mq.len()); __mq.insert(&__values[..], &[__ptr], G::from_bool(!unconstrained)); __ptr } }; - let __ret: [G; OUT_302] = [__v_7, __v_10]; - if let Some(result) = record.function_queries[302].get_mut(&inp[..]) { debug_assert_eq!(result.output, &__ret[..]); if !unconstrained { *result.multiplicity += G::ONE; } } else { record.function_queries[302].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained)); }; + let __ret: [G; OUT_298] = [__v_7, __v_10]; + if let Some(result) = record.function_queries[298].get_mut(&inp[..]) { debug_assert_eq!(result.output, &__ret[..]); if !unconstrained { *result.multiplicity += G::ONE; } } else { record.function_queries[298].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained)); }; return Ok(__ret); }, _ => { @@ -28837,15 +28563,15 @@ fn aiur_fn_302( }) } -const INPUT_SIZE_303: usize = 3; -const IN_303: usize = 3; -const OUT_303: usize = 1; -fn aiur_fn_303( - inp: [G; IN_303], +const INPUT_SIZE_299: usize = 3; +const IN_299: usize = 3; +const OUT_299: usize = 1; +fn aiur_fn_299( + inp: [G; IN_299], record: &mut QueryRecord, io_buffer: &mut IOBuffer, unconstrained: bool, -) -> Result<[G; OUT_303], ExecError> { +) -> Result<[G; OUT_299], ExecError> { stacker::maybe_grow(64 * 1024, 4 * 1024 * 1024, || { let __v_0: G = inp[0]; let __v_1: G = inp[1]; @@ -28862,8 +28588,8 @@ fn aiur_fn_303( let __v_9: G = G::from_u64(1); let __v_10: G = { let __values: [G; 3] = [__v_8, __v_9, __v_9]; let __mq = record.memory_queries.get_mut(&3).ok_or(ExecError::InvalidMemorySize(3))?; if let Some(result) = __mq.get_mut(&__values[..]) { if !unconstrained { *result.multiplicity += G::ONE; } result.output[0] } else { let __ptr = G::from_usize(__mq.len()); __mq.insert(&__values[..], &[__ptr], G::from_bool(!unconstrained)); __ptr } }; let __v_11: G = { let __values: [G; 3] = [__v_6, __v_7, __v_10]; let __mq = record.memory_queries.get_mut(&3).ok_or(ExecError::InvalidMemorySize(3))?; if let Some(result) = __mq.get_mut(&__values[..]) { if !unconstrained { *result.multiplicity += G::ONE; } result.output[0] } else { let __ptr = G::from_usize(__mq.len()); __mq.insert(&__values[..], &[__ptr], G::from_bool(!unconstrained)); __ptr } }; - let __ret: [G; OUT_303] = [__v_11]; - if let Some(result) = record.function_queries[303].get_mut(&inp[..]) { debug_assert_eq!(result.output, &__ret[..]); if !unconstrained { *result.multiplicity += G::ONE; } } else { record.function_queries[303].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained)); }; + let __ret: [G; OUT_299] = [__v_11]; + if let Some(result) = record.function_queries[299].get_mut(&inp[..]) { debug_assert_eq!(result.output, &__ret[..]); if !unconstrained { *result.multiplicity += G::ONE; } } else { record.function_queries[299].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained)); }; return Ok(__ret); }, 0u64 => { @@ -28878,8 +28604,8 @@ fn aiur_fn_303( let __v_9: G = G::from_u64(0); let __v_10: G = { let __values: [G; 2] = [__v_1, __v_2]; let __mq = record.memory_queries.get_mut(&2).ok_or(ExecError::InvalidMemorySize(2))?; if let Some(result) = __mq.get_mut(&__values[..]) { if !unconstrained { *result.multiplicity += G::ONE; } result.output[0] } else { let __ptr = G::from_usize(__mq.len()); __mq.insert(&__values[..], &[__ptr], G::from_bool(!unconstrained)); __ptr } }; let __v_11: G = { let __values: [G; 3] = [__v_9, __v_10, __v_0]; let __mq = record.memory_queries.get_mut(&3).ok_or(ExecError::InvalidMemorySize(3))?; if let Some(result) = __mq.get_mut(&__values[..]) { if !unconstrained { *result.multiplicity += G::ONE; } result.output[0] } else { let __ptr = G::from_usize(__mq.len()); __mq.insert(&__values[..], &[__ptr], G::from_bool(!unconstrained)); __ptr } }; - let __ret: [G; OUT_303] = [__v_11]; - if let Some(result) = record.function_queries[303].get_mut(&inp[..]) { debug_assert_eq!(result.output, &__ret[..]); if !unconstrained { *result.multiplicity += G::ONE; } } else { record.function_queries[303].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained)); }; + let __ret: [G; OUT_299] = [__v_11]; + if let Some(result) = record.function_queries[299].get_mut(&inp[..]) { debug_assert_eq!(result.output, &__ret[..]); if !unconstrained { *result.multiplicity += G::ONE; } } else { record.function_queries[299].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained)); }; return Ok(__ret); }, 0u64 => { @@ -28887,11 +28613,11 @@ fn aiur_fn_303( match __v_9.as_canonical_u64() { 1u64 => { let __v_10: G = G::from_u64(0); - let __r_arr: [G; OUT_303] = { let __args: [G; IN_303] = [__v_5, __v_1, __v_2]; let __cu = unconstrained; if let Some(result) = record.function_queries[303].get_mut(&__args[..]) { if !__cu && *result.multiplicity == G::ZERO { aiur_fn_303(__args, record, io_buffer, false)? } else { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_303] = unsafe { *(result.output.as_ptr() as *const [G; OUT_303]) }; __ret } } else { aiur_fn_303(__args, record, io_buffer, __cu)? } }; + let __r_arr: [G; OUT_299] = { let __args: [G; IN_299] = [__v_5, __v_1, __v_2]; let __cu = unconstrained; if let Some(result) = record.function_queries[299].get_mut(&__args[..]) { if !__cu && *result.multiplicity == G::ZERO { aiur_fn_299(__args, record, io_buffer, false)? } else { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_299] = unsafe { *(result.output.as_ptr() as *const [G; OUT_299]) }; __ret } } else { aiur_fn_299(__args, record, io_buffer, __cu)? } }; let __v_11: G = __r_arr[0]; let __v_12: G = { let __values: [G; 3] = [__v_10, __v_4, __v_11]; let __mq = record.memory_queries.get_mut(&3).ok_or(ExecError::InvalidMemorySize(3))?; if let Some(result) = __mq.get_mut(&__values[..]) { if !unconstrained { *result.multiplicity += G::ONE; } result.output[0] } else { let __ptr = G::from_usize(__mq.len()); __mq.insert(&__values[..], &[__ptr], G::from_bool(!unconstrained)); __ptr } }; - let __ret: [G; OUT_303] = [__v_12]; - if let Some(result) = record.function_queries[303].get_mut(&inp[..]) { debug_assert_eq!(result.output, &__ret[..]); if !unconstrained { *result.multiplicity += G::ONE; } } else { record.function_queries[303].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained)); }; + let __ret: [G; OUT_299] = [__v_12]; + if let Some(result) = record.function_queries[299].get_mut(&inp[..]) { debug_assert_eq!(result.output, &__ret[..]); if !unconstrained { *result.multiplicity += G::ONE; } } else { record.function_queries[299].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained)); }; return Ok(__ret); }, 0u64 => { @@ -28901,13 +28627,13 @@ fn aiur_fn_303( let __v_11: G = G::from_u64(0); let __v_12: G = { let __values: [G; 2] = [__v_6, __v_2]; let __mq = record.memory_queries.get_mut(&2).ok_or(ExecError::InvalidMemorySize(2))?; if let Some(result) = __mq.get_mut(&__values[..]) { if !unconstrained { *result.multiplicity += G::ONE; } result.output[0] } else { let __ptr = G::from_usize(__mq.len()); __mq.insert(&__values[..], &[__ptr], G::from_bool(!unconstrained)); __ptr } }; let __v_13: G = { let __values: [G; 3] = [__v_11, __v_12, __v_5]; let __mq = record.memory_queries.get_mut(&3).ok_or(ExecError::InvalidMemorySize(3))?; if let Some(result) = __mq.get_mut(&__values[..]) { if !unconstrained { *result.multiplicity += G::ONE; } result.output[0] } else { let __ptr = G::from_usize(__mq.len()); __mq.insert(&__values[..], &[__ptr], G::from_bool(!unconstrained)); __ptr } }; - let __ret: [G; OUT_303] = [__v_13]; - if let Some(result) = record.function_queries[303].get_mut(&inp[..]) { debug_assert_eq!(result.output, &__ret[..]); if !unconstrained { *result.multiplicity += G::ONE; } } else { record.function_queries[303].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained)); }; + let __ret: [G; OUT_299] = [__v_13]; + if let Some(result) = record.function_queries[299].get_mut(&inp[..]) { debug_assert_eq!(result.output, &__ret[..]); if !unconstrained { *result.multiplicity += G::ONE; } } else { record.function_queries[299].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained)); }; return Ok(__ret); }, 0u64 => { - let __ret: [G; OUT_303] = [__v_0]; - if let Some(result) = record.function_queries[303].get_mut(&inp[..]) { debug_assert_eq!(result.output, &__ret[..]); if !unconstrained { *result.multiplicity += G::ONE; } } else { record.function_queries[303].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained)); }; + let __ret: [G; OUT_299] = [__v_0]; + if let Some(result) = record.function_queries[299].get_mut(&inp[..]) { debug_assert_eq!(result.output, &__ret[..]); if !unconstrained { *result.multiplicity += G::ONE; } } else { record.function_queries[299].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained)); }; return Ok(__ret); }, _ => { @@ -28934,15 +28660,15 @@ fn aiur_fn_303( }) } -const INPUT_SIZE_304: usize = 2; -const IN_304: usize = 2; -const OUT_304: usize = 1; -fn aiur_fn_304( - inp: [G; IN_304], +const INPUT_SIZE_300: usize = 2; +const IN_300: usize = 2; +const OUT_300: usize = 1; +fn aiur_fn_300( + inp: [G; IN_300], record: &mut QueryRecord, io_buffer: &mut IOBuffer, unconstrained: bool, -) -> Result<[G; OUT_304], ExecError> { +) -> Result<[G; OUT_300], ExecError> { stacker::maybe_grow(64 * 1024, 4 * 1024 * 1024, || { let __v_0: G = inp[0]; let __v_1: G = inp[1]; @@ -28959,14 +28685,14 @@ fn aiur_fn_304( match __v_5.as_canonical_u64() { 1u64 => { let __v_8: G = G::from_u64(1); - let __ret: [G; OUT_304] = [__v_8]; - if let Some(result) = record.function_queries[304].get_mut(&inp[..]) { debug_assert_eq!(result.output, &__ret[..]); if !unconstrained { *result.multiplicity += G::ONE; } } else { record.function_queries[304].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained)); }; + let __ret: [G; OUT_300] = [__v_8]; + if let Some(result) = record.function_queries[300].get_mut(&inp[..]) { debug_assert_eq!(result.output, &__ret[..]); if !unconstrained { *result.multiplicity += G::ONE; } } else { record.function_queries[300].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained)); }; return Ok(__ret); }, 0u64 => { let __v_8: G = G::from_u64(0); - let __ret: [G; OUT_304] = [__v_8]; - if let Some(result) = record.function_queries[304].get_mut(&inp[..]) { debug_assert_eq!(result.output, &__ret[..]); if !unconstrained { *result.multiplicity += G::ONE; } } else { record.function_queries[304].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained)); }; + let __ret: [G; OUT_300] = [__v_8]; + if let Some(result) = record.function_queries[300].get_mut(&inp[..]) { debug_assert_eq!(result.output, &__ret[..]); if !unconstrained { *result.multiplicity += G::ONE; } } else { record.function_queries[300].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained)); }; return Ok(__ret); }, _ => { @@ -28982,8 +28708,8 @@ fn aiur_fn_304( match __v_5.as_canonical_u64() { 1u64 => { let __v_8: G = G::from_u64(0); - let __ret: [G; OUT_304] = [__v_8]; - if let Some(result) = record.function_queries[304].get_mut(&inp[..]) { debug_assert_eq!(result.output, &__ret[..]); if !unconstrained { *result.multiplicity += G::ONE; } } else { record.function_queries[304].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained)); }; + let __ret: [G; OUT_300] = [__v_8]; + if let Some(result) = record.function_queries[300].get_mut(&inp[..]) { debug_assert_eq!(result.output, &__ret[..]); if !unconstrained { *result.multiplicity += G::ONE; } } else { record.function_queries[300].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained)); }; return Ok(__ret); }, 0u64 => { @@ -29003,24 +28729,24 @@ fn aiur_fn_304( let __v_13: G = (__v_9 - __v_11); match __v_13.as_canonical_u64() { 0u64 => { - let __r_arr: [G; OUT_304] = { let __args: [G; IN_304] = [__v_4, __v_7]; let __cu = unconstrained; if let Some(result) = record.function_queries[304].get_mut(&__args[..]) { if !__cu && *result.multiplicity == G::ZERO { aiur_fn_304(__args, record, io_buffer, false)? } else { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_304] = unsafe { *(result.output.as_ptr() as *const [G; OUT_304]) }; __ret } } else { aiur_fn_304(__args, record, io_buffer, __cu)? } }; + let __r_arr: [G; OUT_300] = { let __args: [G; IN_300] = [__v_4, __v_7]; let __cu = unconstrained; if let Some(result) = record.function_queries[300].get_mut(&__args[..]) { if !__cu && *result.multiplicity == G::ZERO { aiur_fn_300(__args, record, io_buffer, false)? } else { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_300] = unsafe { *(result.output.as_ptr() as *const [G; OUT_300]) }; __ret } } else { aiur_fn_300(__args, record, io_buffer, __cu)? } }; let __v_14: G = __r_arr[0]; - let __ret: [G; OUT_304] = [__v_14]; - if let Some(result) = record.function_queries[304].get_mut(&inp[..]) { debug_assert_eq!(result.output, &__ret[..]); if !unconstrained { *result.multiplicity += G::ONE; } } else { record.function_queries[304].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained)); }; + let __ret: [G; OUT_300] = [__v_14]; + if let Some(result) = record.function_queries[300].get_mut(&inp[..]) { debug_assert_eq!(result.output, &__ret[..]); if !unconstrained { *result.multiplicity += G::ONE; } } else { record.function_queries[300].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained)); }; return Ok(__ret); }, _ => { let __v_14: G = G::from_u64(0); - let __ret: [G; OUT_304] = [__v_14]; - if let Some(result) = record.function_queries[304].get_mut(&inp[..]) { debug_assert_eq!(result.output, &__ret[..]); if !unconstrained { *result.multiplicity += G::ONE; } } else { record.function_queries[304].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained)); }; + let __ret: [G; OUT_300] = [__v_14]; + if let Some(result) = record.function_queries[300].get_mut(&inp[..]) { debug_assert_eq!(result.output, &__ret[..]); if !unconstrained { *result.multiplicity += G::ONE; } } else { record.function_queries[300].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained)); }; return Ok(__ret); }, } }, _ => { let __v_13: G = G::from_u64(0); - let __ret: [G; OUT_304] = [__v_13]; - if let Some(result) = record.function_queries[304].get_mut(&inp[..]) { debug_assert_eq!(result.output, &__ret[..]); if !unconstrained { *result.multiplicity += G::ONE; } } else { record.function_queries[304].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained)); }; + let __ret: [G; OUT_300] = [__v_13]; + if let Some(result) = record.function_queries[300].get_mut(&inp[..]) { debug_assert_eq!(result.output, &__ret[..]); if !unconstrained { *result.multiplicity += G::ONE; } } else { record.function_queries[300].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained)); }; return Ok(__ret); }, } @@ -29041,15 +28767,15 @@ fn aiur_fn_304( }) } -const INPUT_SIZE_305: usize = 1; -const IN_305: usize = 1; -const OUT_305: usize = 1; -fn aiur_fn_305( - inp: [G; IN_305], +const INPUT_SIZE_301: usize = 1; +const IN_301: usize = 1; +const OUT_301: usize = 1; +fn aiur_fn_301( + inp: [G; IN_301], record: &mut QueryRecord, io_buffer: &mut IOBuffer, unconstrained: bool, -) -> Result<[G; OUT_305], ExecError> { +) -> Result<[G; OUT_301], ExecError> { stacker::maybe_grow(64 * 1024, 4 * 1024 * 1024, || { let __v_0: G = inp[0]; let __loaded: [G; 3] = { let __mq = record.memory_queries.get_mut(&3).ok_or(ExecError::InvalidMemorySize(3))?; let __ptr_u64 = __v_0.as_canonical_u64(); let __ptr_usize = usize::try_from(__ptr_u64).ok().ok_or(ExecError::PointerTooLarge(__ptr_u64))?; let (__args, __mult) = __mq.get_index_mut(__ptr_usize).ok_or(ExecError::UnboundPointer { ptr: __ptr_u64, size: 3 })?; if !unconstrained { *__mult += G::ONE; } let __arr: [G; 3] = __args[..3].try_into().unwrap(); __arr }; @@ -29059,8 +28785,8 @@ fn aiur_fn_305( match __v_1.as_canonical_u64() { 1u64 => { let __v_4: G = G::from_u64(0); - let __ret: [G; OUT_305] = [__v_4]; - if let Some(result) = record.function_queries[305].get_mut(&inp[..]) { debug_assert_eq!(result.output, &__ret[..]); if !unconstrained { *result.multiplicity += G::ONE; } } else { record.function_queries[305].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained)); }; + let __ret: [G; OUT_301] = [__v_4]; + if let Some(result) = record.function_queries[301].get_mut(&inp[..]) { debug_assert_eq!(result.output, &__ret[..]); if !unconstrained { *result.multiplicity += G::ONE; } } else { record.function_queries[301].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained)); }; return Ok(__ret); }, 0u64 => { @@ -29069,18 +28795,18 @@ fn aiur_fn_305( let __v_5: G = __loaded[1]; match __v_4.as_canonical_u64() { _ => { - let __r_arr: [G; OUT_305] = { let __args: [G; IN_305] = [__v_3]; let __cu = unconstrained; if let Some(result) = record.function_queries[305].get_mut(&__args[..]) { if !__cu && *result.multiplicity == G::ZERO { aiur_fn_305(__args, record, io_buffer, false)? } else { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_305] = unsafe { *(result.output.as_ptr() as *const [G; OUT_305]) }; __ret } } else { aiur_fn_305(__args, record, io_buffer, __cu)? } }; + let __r_arr: [G; OUT_301] = { let __args: [G; IN_301] = [__v_3]; let __cu = unconstrained; if let Some(result) = record.function_queries[301].get_mut(&__args[..]) { if !__cu && *result.multiplicity == G::ZERO { aiur_fn_301(__args, record, io_buffer, false)? } else { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_301] = unsafe { *(result.output.as_ptr() as *const [G; OUT_301]) }; __ret } } else { aiur_fn_301(__args, record, io_buffer, __cu)? } }; let __v_6: G = __r_arr[0]; let __v_7: G = { let __a_val = __v_6.as_canonical_u64(); let __b_val = __v_5.as_canonical_u64(); let __a_u32 = u32::try_from(__a_val).ok().ok_or(ExecError::U32OutOfRange(__a_val))?; let __b_u32 = u32::try_from(__b_val).ok().ok_or(ExecError::U32OutOfRange(__b_val))?; let __result = G::from_bool(__a_u32 < __b_u32); if !unconstrained { let __x_bytes = __a_u32.to_le_bytes(); let __z_bytes = __b_u32.to_le_bytes(); let __c_u32 = __b_u32.wrapping_sub(__a_u32).wrapping_sub(1); let __y_bytes = __c_u32.to_le_bytes(); record.bytes2_queries.bump_range_check(&G::from_u8(__x_bytes[0]), &G::from_u8(__x_bytes[1])); record.bytes2_queries.bump_range_check(&G::from_u8(__x_bytes[2]), &G::from_u8(__x_bytes[3])); record.bytes2_queries.bump_range_check(&G::from_u8(__y_bytes[0]), &G::from_u8(__y_bytes[1])); record.bytes2_queries.bump_range_check(&G::from_u8(__y_bytes[2]), &G::from_u8(__y_bytes[3])); record.bytes2_queries.bump_range_check(&G::from_u8(__z_bytes[0]), &G::from_u8(__z_bytes[1])); record.bytes2_queries.bump_range_check(&G::from_u8(__z_bytes[2]), &G::from_u8(__z_bytes[3])); } __result }; match __v_7.as_canonical_u64() { 1u64 => { - let __ret: [G; OUT_305] = [__v_5]; - if let Some(result) = record.function_queries[305].get_mut(&inp[..]) { debug_assert_eq!(result.output, &__ret[..]); if !unconstrained { *result.multiplicity += G::ONE; } } else { record.function_queries[305].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained)); }; + let __ret: [G; OUT_301] = [__v_5]; + if let Some(result) = record.function_queries[301].get_mut(&inp[..]) { debug_assert_eq!(result.output, &__ret[..]); if !unconstrained { *result.multiplicity += G::ONE; } } else { record.function_queries[301].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained)); }; return Ok(__ret); }, 0u64 => { - let __ret: [G; OUT_305] = [__v_6]; - if let Some(result) = record.function_queries[305].get_mut(&inp[..]) { debug_assert_eq!(result.output, &__ret[..]); if !unconstrained { *result.multiplicity += G::ONE; } } else { record.function_queries[305].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained)); }; + let __ret: [G; OUT_301] = [__v_6]; + if let Some(result) = record.function_queries[301].get_mut(&inp[..]) { debug_assert_eq!(result.output, &__ret[..]); if !unconstrained { *result.multiplicity += G::ONE; } } else { record.function_queries[301].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained)); }; return Ok(__ret); }, _ => { @@ -29097,15 +28823,15 @@ fn aiur_fn_305( }) } -const INPUT_SIZE_306: usize = 2; -const IN_306: usize = 2; -const OUT_306: usize = 1; -fn aiur_fn_306( - inp: [G; IN_306], +const INPUT_SIZE_302: usize = 2; +const IN_302: usize = 2; +const OUT_302: usize = 1; +fn aiur_fn_302( + inp: [G; IN_302], record: &mut QueryRecord, io_buffer: &mut IOBuffer, unconstrained: bool, -) -> Result<[G; OUT_306], ExecError> { +) -> Result<[G; OUT_302], ExecError> { stacker::maybe_grow(64 * 1024, 4 * 1024 * 1024, || { let __v_0: G = inp[0]; let __v_1: G = inp[1]; @@ -29115,8 +28841,8 @@ fn aiur_fn_306( let __v_4: G = __loaded[2]; match __v_2.as_canonical_u64() { 1u64 => { - let __ret: [G; OUT_306] = [__v_0]; - if let Some(result) = record.function_queries[306].get_mut(&inp[..]) { debug_assert_eq!(result.output, &__ret[..]); if !unconstrained { *result.multiplicity += G::ONE; } } else { record.function_queries[306].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained)); }; + let __ret: [G; OUT_302] = [__v_0]; + if let Some(result) = record.function_queries[302].get_mut(&inp[..]) { debug_assert_eq!(result.output, &__ret[..]); if !unconstrained { *result.multiplicity += G::ONE; } } else { record.function_queries[302].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained)); }; return Ok(__ret); }, 0u64 => { @@ -29126,8 +28852,8 @@ fn aiur_fn_306( let __v_7: G = __loaded[2]; match __v_5.as_canonical_u64() { 1u64 => { - let __ret: [G; OUT_306] = [__v_0]; - if let Some(result) = record.function_queries[306].get_mut(&inp[..]) { debug_assert_eq!(result.output, &__ret[..]); if !unconstrained { *result.multiplicity += G::ONE; } } else { record.function_queries[306].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained)); }; + let __ret: [G; OUT_302] = [__v_0]; + if let Some(result) = record.function_queries[302].get_mut(&inp[..]) { debug_assert_eq!(result.output, &__ret[..]); if !unconstrained { *result.multiplicity += G::ONE; } } else { record.function_queries[302].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained)); }; return Ok(__ret); }, 0u64 => { @@ -29145,21 +28871,21 @@ fn aiur_fn_306( match __v_12.as_canonical_u64() { 1u64 => { let __v_13: G = G::from_u64(0); - let __r_arr: [G; OUT_306] = { let __args: [G; IN_306] = [__v_4, __v_1]; let __cu = unconstrained; if let Some(result) = record.function_queries[306].get_mut(&__args[..]) { if !__cu && *result.multiplicity == G::ZERO { aiur_fn_306(__args, record, io_buffer, false)? } else { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_306] = unsafe { *(result.output.as_ptr() as *const [G; OUT_306]) }; __ret } } else { aiur_fn_306(__args, record, io_buffer, __cu)? } }; + let __r_arr: [G; OUT_302] = { let __args: [G; IN_302] = [__v_4, __v_1]; let __cu = unconstrained; if let Some(result) = record.function_queries[302].get_mut(&__args[..]) { if !__cu && *result.multiplicity == G::ZERO { aiur_fn_302(__args, record, io_buffer, false)? } else { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_302] = unsafe { *(result.output.as_ptr() as *const [G; OUT_302]) }; __ret } } else { aiur_fn_302(__args, record, io_buffer, __cu)? } }; let __v_14: G = __r_arr[0]; let __v_15: G = { let __values: [G; 3] = [__v_13, __v_3, __v_14]; let __mq = record.memory_queries.get_mut(&3).ok_or(ExecError::InvalidMemorySize(3))?; if let Some(result) = __mq.get_mut(&__values[..]) { if !unconstrained { *result.multiplicity += G::ONE; } result.output[0] } else { let __ptr = G::from_usize(__mq.len()); __mq.insert(&__values[..], &[__ptr], G::from_bool(!unconstrained)); __ptr } }; - let __ret: [G; OUT_306] = [__v_15]; - if let Some(result) = record.function_queries[306].get_mut(&inp[..]) { debug_assert_eq!(result.output, &__ret[..]); if !unconstrained { *result.multiplicity += G::ONE; } } else { record.function_queries[306].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained)); }; + let __ret: [G; OUT_302] = [__v_15]; + if let Some(result) = record.function_queries[302].get_mut(&inp[..]) { debug_assert_eq!(result.output, &__ret[..]); if !unconstrained { *result.multiplicity += G::ONE; } } else { record.function_queries[302].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained)); }; return Ok(__ret); }, 0u64 => { let __v_13: G = { let __a_val = __v_10.as_canonical_u64(); let __b_val = __v_8.as_canonical_u64(); let __a_u32 = u32::try_from(__a_val).ok().ok_or(ExecError::U32OutOfRange(__a_val))?; let __b_u32 = u32::try_from(__b_val).ok().ok_or(ExecError::U32OutOfRange(__b_val))?; let __result = G::from_bool(__a_u32 < __b_u32); if !unconstrained { let __x_bytes = __a_u32.to_le_bytes(); let __z_bytes = __b_u32.to_le_bytes(); let __c_u32 = __b_u32.wrapping_sub(__a_u32).wrapping_sub(1); let __y_bytes = __c_u32.to_le_bytes(); record.bytes2_queries.bump_range_check(&G::from_u8(__x_bytes[0]), &G::from_u8(__x_bytes[1])); record.bytes2_queries.bump_range_check(&G::from_u8(__x_bytes[2]), &G::from_u8(__x_bytes[3])); record.bytes2_queries.bump_range_check(&G::from_u8(__y_bytes[0]), &G::from_u8(__y_bytes[1])); record.bytes2_queries.bump_range_check(&G::from_u8(__y_bytes[2]), &G::from_u8(__y_bytes[3])); record.bytes2_queries.bump_range_check(&G::from_u8(__z_bytes[0]), &G::from_u8(__z_bytes[1])); record.bytes2_queries.bump_range_check(&G::from_u8(__z_bytes[2]), &G::from_u8(__z_bytes[3])); } __result }; match __v_13.as_canonical_u64() { 1u64 => { - let __r_arr: [G; OUT_306] = { let __args: [G; IN_306] = [__v_0, __v_7]; let __cu = unconstrained; if let Some(result) = record.function_queries[306].get_mut(&__args[..]) { if !__cu && *result.multiplicity == G::ZERO { aiur_fn_306(__args, record, io_buffer, false)? } else { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_306] = unsafe { *(result.output.as_ptr() as *const [G; OUT_306]) }; __ret } } else { aiur_fn_306(__args, record, io_buffer, __cu)? } }; + let __r_arr: [G; OUT_302] = { let __args: [G; IN_302] = [__v_0, __v_7]; let __cu = unconstrained; if let Some(result) = record.function_queries[302].get_mut(&__args[..]) { if !__cu && *result.multiplicity == G::ZERO { aiur_fn_302(__args, record, io_buffer, false)? } else { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_302] = unsafe { *(result.output.as_ptr() as *const [G; OUT_302]) }; __ret } } else { aiur_fn_302(__args, record, io_buffer, __cu)? } }; let __v_14: G = __r_arr[0]; - let __ret: [G; OUT_306] = [__v_14]; - if let Some(result) = record.function_queries[306].get_mut(&inp[..]) { debug_assert_eq!(result.output, &__ret[..]); if !unconstrained { *result.multiplicity += G::ONE; } } else { record.function_queries[306].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained)); }; + let __ret: [G; OUT_302] = [__v_14]; + if let Some(result) = record.function_queries[302].get_mut(&inp[..]) { debug_assert_eq!(result.output, &__ret[..]); if !unconstrained { *result.multiplicity += G::ONE; } } else { record.function_queries[302].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained)); }; return Ok(__ret); }, 0u64 => { @@ -29167,18 +28893,18 @@ fn aiur_fn_306( match __v_14.as_canonical_u64() { 1u64 => { let __v_15: G = G::from_u64(0); - let __r_arr: [G; OUT_306] = { let __args: [G; IN_306] = [__v_4, __v_7]; let __cu = unconstrained; if let Some(result) = record.function_queries[306].get_mut(&__args[..]) { if !__cu && *result.multiplicity == G::ZERO { aiur_fn_306(__args, record, io_buffer, false)? } else { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_306] = unsafe { *(result.output.as_ptr() as *const [G; OUT_306]) }; __ret } } else { aiur_fn_306(__args, record, io_buffer, __cu)? } }; + let __r_arr: [G; OUT_302] = { let __args: [G; IN_302] = [__v_4, __v_7]; let __cu = unconstrained; if let Some(result) = record.function_queries[302].get_mut(&__args[..]) { if !__cu && *result.multiplicity == G::ZERO { aiur_fn_302(__args, record, io_buffer, false)? } else { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_302] = unsafe { *(result.output.as_ptr() as *const [G; OUT_302]) }; __ret } } else { aiur_fn_302(__args, record, io_buffer, __cu)? } }; let __v_16: G = __r_arr[0]; let __v_17: G = { let __values: [G; 3] = [__v_15, __v_3, __v_16]; let __mq = record.memory_queries.get_mut(&3).ok_or(ExecError::InvalidMemorySize(3))?; if let Some(result) = __mq.get_mut(&__values[..]) { if !unconstrained { *result.multiplicity += G::ONE; } result.output[0] } else { let __ptr = G::from_usize(__mq.len()); __mq.insert(&__values[..], &[__ptr], G::from_bool(!unconstrained)); __ptr } }; - let __ret: [G; OUT_306] = [__v_17]; - if let Some(result) = record.function_queries[306].get_mut(&inp[..]) { debug_assert_eq!(result.output, &__ret[..]); if !unconstrained { *result.multiplicity += G::ONE; } } else { record.function_queries[306].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained)); }; + let __ret: [G; OUT_302] = [__v_17]; + if let Some(result) = record.function_queries[302].get_mut(&inp[..]) { debug_assert_eq!(result.output, &__ret[..]); if !unconstrained { *result.multiplicity += G::ONE; } } else { record.function_queries[302].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained)); }; return Ok(__ret); }, 0u64 => { - let __r_arr: [G; OUT_306] = { let __args: [G; IN_306] = [__v_4, __v_7]; let __cu = unconstrained; if let Some(result) = record.function_queries[306].get_mut(&__args[..]) { if !__cu && *result.multiplicity == G::ZERO { aiur_fn_306(__args, record, io_buffer, false)? } else { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_306] = unsafe { *(result.output.as_ptr() as *const [G; OUT_306]) }; __ret } } else { aiur_fn_306(__args, record, io_buffer, __cu)? } }; + let __r_arr: [G; OUT_302] = { let __args: [G; IN_302] = [__v_4, __v_7]; let __cu = unconstrained; if let Some(result) = record.function_queries[302].get_mut(&__args[..]) { if !__cu && *result.multiplicity == G::ZERO { aiur_fn_302(__args, record, io_buffer, false)? } else { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_302] = unsafe { *(result.output.as_ptr() as *const [G; OUT_302]) }; __ret } } else { aiur_fn_302(__args, record, io_buffer, __cu)? } }; let __v_15: G = __r_arr[0]; - let __ret: [G; OUT_306] = [__v_15]; - if let Some(result) = record.function_queries[306].get_mut(&inp[..]) { debug_assert_eq!(result.output, &__ret[..]); if !unconstrained { *result.multiplicity += G::ONE; } } else { record.function_queries[306].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained)); }; + let __ret: [G; OUT_302] = [__v_15]; + if let Some(result) = record.function_queries[302].get_mut(&inp[..]) { debug_assert_eq!(result.output, &__ret[..]); if !unconstrained { *result.multiplicity += G::ONE; } } else { record.function_queries[302].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained)); }; return Ok(__ret); }, _ => { @@ -29212,23 +28938,23 @@ fn aiur_fn_306( }) } -const INPUT_SIZE_307: usize = 3; -const IN_307: usize = 3; -const OUT_307: usize = 1; -fn aiur_fn_307( - inp: [G; IN_307], +const INPUT_SIZE_303: usize = 3; +const IN_303: usize = 3; +const OUT_303: usize = 1; +fn aiur_fn_303( + inp: [G; IN_303], record: &mut QueryRecord, io_buffer: &mut IOBuffer, unconstrained: bool, -) -> Result<[G; OUT_307], ExecError> { +) -> Result<[G; OUT_303], ExecError> { stacker::maybe_grow(64 * 1024, 4 * 1024 * 1024, || { let __v_0: G = inp[0]; let __v_1: G = inp[1]; let __v_2: G = inp[2]; match __v_2.as_canonical_u64() { 0u64 => { - let __ret: [G; OUT_307] = [__v_0]; - if let Some(result) = record.function_queries[307].get_mut(&inp[..]) { debug_assert_eq!(result.output, &__ret[..]); if !unconstrained { *result.multiplicity += G::ONE; } } else { record.function_queries[307].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained)); }; + let __ret: [G; OUT_303] = [__v_0]; + if let Some(result) = record.function_queries[303].get_mut(&inp[..]) { debug_assert_eq!(result.output, &__ret[..]); if !unconstrained { *result.multiplicity += G::ONE; } } else { record.function_queries[303].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained)); }; return Ok(__ret); }, 1u64 => { @@ -29238,15 +28964,15 @@ fn aiur_fn_307( let __v_5: G = __loaded[2]; match __v_3.as_canonical_u64() { 1u64 => { - let __r_arr: [G; OUT_308] = { let __args: [G; IN_308] = [__v_0, __v_1, __v_2]; let __cu = unconstrained; if let Some(result) = record.function_queries[308].get_mut(&__args[..]) { if !__cu && *result.multiplicity == G::ZERO { aiur_fn_308(__args, record, io_buffer, false)? } else { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_308] = unsafe { *(result.output.as_ptr() as *const [G; OUT_308]) }; __ret } } else { aiur_fn_308(__args, record, io_buffer, __cu)? } }; + let __r_arr: [G; OUT_304] = { let __args: [G; IN_304] = [__v_0, __v_1, __v_2]; let __cu = unconstrained; if let Some(result) = record.function_queries[304].get_mut(&__args[..]) { if !__cu && *result.multiplicity == G::ZERO { aiur_fn_304(__args, record, io_buffer, false)? } else { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_304] = unsafe { *(result.output.as_ptr() as *const [G; OUT_304]) }; __ret } } else { aiur_fn_304(__args, record, io_buffer, __cu)? } }; let __v_6: G = __r_arr[0]; - let __ret: [G; OUT_307] = [__v_6]; - if let Some(result) = record.function_queries[307].get_mut(&inp[..]) { debug_assert_eq!(result.output, &__ret[..]); if !unconstrained { *result.multiplicity += G::ONE; } } else { record.function_queries[307].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained)); }; + let __ret: [G; OUT_303] = [__v_6]; + if let Some(result) = record.function_queries[303].get_mut(&inp[..]) { debug_assert_eq!(result.output, &__ret[..]); if !unconstrained { *result.multiplicity += G::ONE; } } else { record.function_queries[303].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained)); }; return Ok(__ret); }, 0u64 => { - let __ret: [G; OUT_307] = [__v_0]; - if let Some(result) = record.function_queries[307].get_mut(&inp[..]) { debug_assert_eq!(result.output, &__ret[..]); if !unconstrained { *result.multiplicity += G::ONE; } } else { record.function_queries[307].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained)); }; + let __ret: [G; OUT_303] = [__v_0]; + if let Some(result) = record.function_queries[303].get_mut(&inp[..]) { debug_assert_eq!(result.output, &__ret[..]); if !unconstrained { *result.multiplicity += G::ONE; } } else { record.function_queries[303].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained)); }; return Ok(__ret); }, _ => { @@ -29255,25 +28981,25 @@ fn aiur_fn_307( } }, _ => { - let __r_arr: [G; OUT_308] = { let __args: [G; IN_308] = [__v_0, __v_1, __v_2]; let __cu = unconstrained; if let Some(result) = record.function_queries[308].get_mut(&__args[..]) { if !__cu && *result.multiplicity == G::ZERO { aiur_fn_308(__args, record, io_buffer, false)? } else { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_308] = unsafe { *(result.output.as_ptr() as *const [G; OUT_308]) }; __ret } } else { aiur_fn_308(__args, record, io_buffer, __cu)? } }; + let __r_arr: [G; OUT_304] = { let __args: [G; IN_304] = [__v_0, __v_1, __v_2]; let __cu = unconstrained; if let Some(result) = record.function_queries[304].get_mut(&__args[..]) { if !__cu && *result.multiplicity == G::ZERO { aiur_fn_304(__args, record, io_buffer, false)? } else { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_304] = unsafe { *(result.output.as_ptr() as *const [G; OUT_304]) }; __ret } } else { aiur_fn_304(__args, record, io_buffer, __cu)? } }; let __v_3: G = __r_arr[0]; - let __ret: [G; OUT_307] = [__v_3]; - if let Some(result) = record.function_queries[307].get_mut(&inp[..]) { debug_assert_eq!(result.output, &__ret[..]); if !unconstrained { *result.multiplicity += G::ONE; } } else { record.function_queries[307].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained)); }; + let __ret: [G; OUT_303] = [__v_3]; + if let Some(result) = record.function_queries[303].get_mut(&inp[..]) { debug_assert_eq!(result.output, &__ret[..]); if !unconstrained { *result.multiplicity += G::ONE; } } else { record.function_queries[303].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained)); }; return Ok(__ret); }, } }) } -const INPUT_SIZE_308: usize = 3; -const IN_308: usize = 3; -const OUT_308: usize = 1; -fn aiur_fn_308( - inp: [G; IN_308], +const INPUT_SIZE_304: usize = 3; +const IN_304: usize = 3; +const OUT_304: usize = 1; +fn aiur_fn_304( + inp: [G; IN_304], record: &mut QueryRecord, io_buffer: &mut IOBuffer, unconstrained: bool, -) -> Result<[G; OUT_308], ExecError> { +) -> Result<[G; OUT_304], ExecError> { stacker::maybe_grow(64 * 1024, 4 * 1024 * 1024, || { let __v_0: G = inp[0]; let __v_1: G = inp[1]; @@ -29293,8 +29019,8 @@ fn aiur_fn_308( let __v_12: G = G::from_u64(1); let __v_13: G = { let __values: [G; 3] = [__v_11, __v_12, __v_12]; let __mq = record.memory_queries.get_mut(&3).ok_or(ExecError::InvalidMemorySize(3))?; if let Some(result) = __mq.get_mut(&__values[..]) { if !unconstrained { *result.multiplicity += G::ONE; } result.output[0] } else { let __ptr = G::from_usize(__mq.len()); __mq.insert(&__values[..], &[__ptr], G::from_bool(!unconstrained)); __ptr } }; let __v_14: G = { let __values: [G; 3] = [__v_6, __v_10, __v_13]; let __mq = record.memory_queries.get_mut(&3).ok_or(ExecError::InvalidMemorySize(3))?; if let Some(result) = __mq.get_mut(&__values[..]) { if !unconstrained { *result.multiplicity += G::ONE; } result.output[0] } else { let __ptr = G::from_usize(__mq.len()); __mq.insert(&__values[..], &[__ptr], G::from_bool(!unconstrained)); __ptr } }; - let __ret: [G; OUT_308] = [__v_14]; - if let Some(result) = record.function_queries[308].get_mut(&inp[..]) { debug_assert_eq!(result.output, &__ret[..]); if !unconstrained { *result.multiplicity += G::ONE; } } else { record.function_queries[308].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained)); }; + let __ret: [G; OUT_304] = [__v_14]; + if let Some(result) = record.function_queries[304].get_mut(&inp[..]) { debug_assert_eq!(result.output, &__ret[..]); if !unconstrained { *result.multiplicity += G::ONE; } } else { record.function_queries[304].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained)); }; return Ok(__ret); }, 0u64 => { @@ -29304,7 +29030,7 @@ fn aiur_fn_308( let __v_8: G = __loaded[2]; match __v_6.as_canonical_u64() { _ => { - let __r_arr: [G; OUT_299] = { let __args: [G; IN_299] = [__v_1, __v_6]; let __cu = unconstrained; if let Some(result) = record.function_queries[299].get_mut(&__args[..]) { if !__cu && *result.multiplicity == G::ZERO { aiur_fn_299(__args, record, io_buffer, false)? } else { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_299] = unsafe { *(result.output.as_ptr() as *const [G; OUT_299]) }; __ret } } else { aiur_fn_299(__args, record, io_buffer, __cu)? } }; + let __r_arr: [G; OUT_295] = { let __args: [G; IN_295] = [__v_1, __v_6]; let __cu = unconstrained; if let Some(result) = record.function_queries[295].get_mut(&__args[..]) { if !__cu && *result.multiplicity == G::ZERO { aiur_fn_295(__args, record, io_buffer, false)? } else { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_295] = unsafe { *(result.output.as_ptr() as *const [G; OUT_295]) }; __ret } } else { aiur_fn_295(__args, record, io_buffer, __cu)? } }; let __v_9: G = __r_arr[0]; match __v_9.as_canonical_u64() { 0u64 => { @@ -29314,13 +29040,13 @@ fn aiur_fn_308( let __v_11: G = G::from_u64(0); let __v_12: G = { let __values: [G; 3] = [__v_6, __v_2, __v_8]; let __mq = record.memory_queries.get_mut(&3).ok_or(ExecError::InvalidMemorySize(3))?; if let Some(result) = __mq.get_mut(&__values[..]) { if !unconstrained { *result.multiplicity += G::ONE; } result.output[0] } else { let __ptr = G::from_usize(__mq.len()); __mq.insert(&__values[..], &[__ptr], G::from_bool(!unconstrained)); __ptr } }; let __v_13: G = { let __values: [G; 3] = [__v_11, __v_12, __v_5]; let __mq = record.memory_queries.get_mut(&3).ok_or(ExecError::InvalidMemorySize(3))?; if let Some(result) = __mq.get_mut(&__values[..]) { if !unconstrained { *result.multiplicity += G::ONE; } result.output[0] } else { let __ptr = G::from_usize(__mq.len()); __mq.insert(&__values[..], &[__ptr], G::from_bool(!unconstrained)); __ptr } }; - let __ret: [G; OUT_308] = [__v_13]; - if let Some(result) = record.function_queries[308].get_mut(&inp[..]) { debug_assert_eq!(result.output, &__ret[..]); if !unconstrained { *result.multiplicity += G::ONE; } } else { record.function_queries[308].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained)); }; + let __ret: [G; OUT_304] = [__v_13]; + if let Some(result) = record.function_queries[304].get_mut(&inp[..]) { debug_assert_eq!(result.output, &__ret[..]); if !unconstrained { *result.multiplicity += G::ONE; } } else { record.function_queries[304].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained)); }; return Ok(__ret); }, 0u64 => { - let __ret: [G; OUT_308] = [__v_0]; - if let Some(result) = record.function_queries[308].get_mut(&inp[..]) { debug_assert_eq!(result.output, &__ret[..]); if !unconstrained { *result.multiplicity += G::ONE; } } else { record.function_queries[308].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained)); }; + let __ret: [G; OUT_304] = [__v_0]; + if let Some(result) = record.function_queries[304].get_mut(&inp[..]) { debug_assert_eq!(result.output, &__ret[..]); if !unconstrained { *result.multiplicity += G::ONE; } } else { record.function_queries[304].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained)); }; return Ok(__ret); }, _ => { @@ -29335,17 +29061,17 @@ fn aiur_fn_308( let __v_13: G = { let __values: [G; 3] = [__v_11, __v_12, __v_12]; let __mq = record.memory_queries.get_mut(&3).ok_or(ExecError::InvalidMemorySize(3))?; if let Some(result) = __mq.get_mut(&__values[..]) { if !unconstrained { *result.multiplicity += G::ONE; } result.output[0] } else { let __ptr = G::from_usize(__mq.len()); __mq.insert(&__values[..], &[__ptr], G::from_bool(!unconstrained)); __ptr } }; let __v_14: G = { let __values: [G; 3] = [__v_1, __v_2, __v_13]; let __mq = record.memory_queries.get_mut(&3).ok_or(ExecError::InvalidMemorySize(3))?; if let Some(result) = __mq.get_mut(&__values[..]) { if !unconstrained { *result.multiplicity += G::ONE; } result.output[0] } else { let __ptr = G::from_usize(__mq.len()); __mq.insert(&__values[..], &[__ptr], G::from_bool(!unconstrained)); __ptr } }; let __v_15: G = { let __values: [G; 3] = [__v_10, __v_14, __v_0]; let __mq = record.memory_queries.get_mut(&3).ok_or(ExecError::InvalidMemorySize(3))?; if let Some(result) = __mq.get_mut(&__values[..]) { if !unconstrained { *result.multiplicity += G::ONE; } result.output[0] } else { let __ptr = G::from_usize(__mq.len()); __mq.insert(&__values[..], &[__ptr], G::from_bool(!unconstrained)); __ptr } }; - let __ret: [G; OUT_308] = [__v_15]; - if let Some(result) = record.function_queries[308].get_mut(&inp[..]) { debug_assert_eq!(result.output, &__ret[..]); if !unconstrained { *result.multiplicity += G::ONE; } } else { record.function_queries[308].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained)); }; + let __ret: [G; OUT_304] = [__v_15]; + if let Some(result) = record.function_queries[304].get_mut(&inp[..]) { debug_assert_eq!(result.output, &__ret[..]); if !unconstrained { *result.multiplicity += G::ONE; } } else { record.function_queries[304].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained)); }; return Ok(__ret); }, _ => { let __v_10: G = G::from_u64(0); - let __r_arr: [G; OUT_308] = { let __args: [G; IN_308] = [__v_5, __v_1, __v_2]; let __cu = unconstrained; if let Some(result) = record.function_queries[308].get_mut(&__args[..]) { if !__cu && *result.multiplicity == G::ZERO { aiur_fn_308(__args, record, io_buffer, false)? } else { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_308] = unsafe { *(result.output.as_ptr() as *const [G; OUT_308]) }; __ret } } else { aiur_fn_308(__args, record, io_buffer, __cu)? } }; + let __r_arr: [G; OUT_304] = { let __args: [G; IN_304] = [__v_5, __v_1, __v_2]; let __cu = unconstrained; if let Some(result) = record.function_queries[304].get_mut(&__args[..]) { if !__cu && *result.multiplicity == G::ZERO { aiur_fn_304(__args, record, io_buffer, false)? } else { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_304] = unsafe { *(result.output.as_ptr() as *const [G; OUT_304]) }; __ret } } else { aiur_fn_304(__args, record, io_buffer, __cu)? } }; let __v_11: G = __r_arr[0]; let __v_12: G = { let __values: [G; 3] = [__v_10, __v_4, __v_11]; let __mq = record.memory_queries.get_mut(&3).ok_or(ExecError::InvalidMemorySize(3))?; if let Some(result) = __mq.get_mut(&__values[..]) { if !unconstrained { *result.multiplicity += G::ONE; } result.output[0] } else { let __ptr = G::from_usize(__mq.len()); __mq.insert(&__values[..], &[__ptr], G::from_bool(!unconstrained)); __ptr } }; - let __ret: [G; OUT_308] = [__v_12]; - if let Some(result) = record.function_queries[308].get_mut(&inp[..]) { debug_assert_eq!(result.output, &__ret[..]); if !unconstrained { *result.multiplicity += G::ONE; } } else { record.function_queries[308].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained)); }; + let __ret: [G; OUT_304] = [__v_12]; + if let Some(result) = record.function_queries[304].get_mut(&inp[..]) { debug_assert_eq!(result.output, &__ret[..]); if !unconstrained { *result.multiplicity += G::ONE; } } else { record.function_queries[304].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained)); }; return Ok(__ret); }, } @@ -29359,15 +29085,15 @@ fn aiur_fn_308( }) } -const INPUT_SIZE_309: usize = 4; -const IN_309: usize = 4; -const OUT_309: usize = 1; -fn aiur_fn_309( - inp: [G; IN_309], +const INPUT_SIZE_305: usize = 4; +const IN_305: usize = 4; +const OUT_305: usize = 1; +fn aiur_fn_305( + inp: [G; IN_305], record: &mut QueryRecord, io_buffer: &mut IOBuffer, unconstrained: bool, -) -> Result<[G; OUT_309], ExecError> { +) -> Result<[G; OUT_305], ExecError> { stacker::maybe_grow(64 * 1024, 4 * 1024 * 1024, || { let __v_0: G = inp[0]; let __v_1: G = inp[1]; @@ -29392,8 +29118,8 @@ fn aiur_fn_309( let __v_17: G = G::from_u64(1); let __v_18: G = { let __values: [G; 3] = [__v_16, __v_17, __v_17]; let __mq = record.memory_queries.get_mut(&3).ok_or(ExecError::InvalidMemorySize(3))?; if let Some(result) = __mq.get_mut(&__values[..]) { if !unconstrained { *result.multiplicity += G::ONE; } result.output[0] } else { let __ptr = G::from_usize(__mq.len()); __mq.insert(&__values[..], &[__ptr], G::from_bool(!unconstrained)); __ptr } }; let __v_19: G = { let __values: [G; 3] = [__v_7, __v_15, __v_18]; let __mq = record.memory_queries.get_mut(&3).ok_or(ExecError::InvalidMemorySize(3))?; if let Some(result) = __mq.get_mut(&__values[..]) { if !unconstrained { *result.multiplicity += G::ONE; } result.output[0] } else { let __ptr = G::from_usize(__mq.len()); __mq.insert(&__values[..], &[__ptr], G::from_bool(!unconstrained)); __ptr } }; - let __ret: [G; OUT_309] = [__v_19]; - if let Some(result) = record.function_queries[309].get_mut(&inp[..]) { debug_assert_eq!(result.output, &__ret[..]); if !unconstrained { *result.multiplicity += G::ONE; } } else { record.function_queries[309].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained)); }; + let __ret: [G; OUT_305] = [__v_19]; + if let Some(result) = record.function_queries[305].get_mut(&inp[..]) { debug_assert_eq!(result.output, &__ret[..]); if !unconstrained { *result.multiplicity += G::ONE; } } else { record.function_queries[305].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained)); }; return Ok(__ret); }, 0u64 => { @@ -29403,17 +29129,17 @@ fn aiur_fn_309( let __v_9: G = __loaded[2]; match __v_7.as_canonical_u64() { _ => { - let __r_arr: [G; OUT_299] = { let __args: [G; IN_299] = [__v_1, __v_7]; let __cu = unconstrained; if let Some(result) = record.function_queries[299].get_mut(&__args[..]) { if !__cu && *result.multiplicity == G::ZERO { aiur_fn_299(__args, record, io_buffer, false)? } else { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_299] = unsafe { *(result.output.as_ptr() as *const [G; OUT_299]) }; __ret } } else { aiur_fn_299(__args, record, io_buffer, __cu)? } }; + let __r_arr: [G; OUT_295] = { let __args: [G; IN_295] = [__v_1, __v_7]; let __cu = unconstrained; if let Some(result) = record.function_queries[295].get_mut(&__args[..]) { if !__cu && *result.multiplicity == G::ZERO { aiur_fn_295(__args, record, io_buffer, false)? } else { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_295] = unsafe { *(result.output.as_ptr() as *const [G; OUT_295]) }; __ret } } else { aiur_fn_295(__args, record, io_buffer, __cu)? } }; let __v_10: G = __r_arr[0]; match __v_10.as_canonical_u64() { 0u64 => { let __v_11: G = G::from_u64(0); - let __r_arr: [G; OUT_303] = { let __args: [G; IN_303] = [__v_9, __v_2, __v_3]; let __cu = unconstrained; if let Some(result) = record.function_queries[303].get_mut(&__args[..]) { if !__cu && *result.multiplicity == G::ZERO { aiur_fn_303(__args, record, io_buffer, false)? } else { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_303] = unsafe { *(result.output.as_ptr() as *const [G; OUT_303]) }; __ret } } else { aiur_fn_303(__args, record, io_buffer, __cu)? } }; + let __r_arr: [G; OUT_299] = { let __args: [G; IN_299] = [__v_9, __v_2, __v_3]; let __cu = unconstrained; if let Some(result) = record.function_queries[299].get_mut(&__args[..]) { if !__cu && *result.multiplicity == G::ZERO { aiur_fn_299(__args, record, io_buffer, false)? } else { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_299] = unsafe { *(result.output.as_ptr() as *const [G; OUT_299]) }; __ret } } else { aiur_fn_299(__args, record, io_buffer, __cu)? } }; let __v_12: G = __r_arr[0]; let __v_13: G = { let __values: [G; 3] = [__v_7, __v_8, __v_12]; let __mq = record.memory_queries.get_mut(&3).ok_or(ExecError::InvalidMemorySize(3))?; if let Some(result) = __mq.get_mut(&__values[..]) { if !unconstrained { *result.multiplicity += G::ONE; } result.output[0] } else { let __ptr = G::from_usize(__mq.len()); __mq.insert(&__values[..], &[__ptr], G::from_bool(!unconstrained)); __ptr } }; let __v_14: G = { let __values: [G; 3] = [__v_11, __v_13, __v_6]; let __mq = record.memory_queries.get_mut(&3).ok_or(ExecError::InvalidMemorySize(3))?; if let Some(result) = __mq.get_mut(&__values[..]) { if !unconstrained { *result.multiplicity += G::ONE; } result.output[0] } else { let __ptr = G::from_usize(__mq.len()); __mq.insert(&__values[..], &[__ptr], G::from_bool(!unconstrained)); __ptr } }; - let __ret: [G; OUT_309] = [__v_14]; - if let Some(result) = record.function_queries[309].get_mut(&inp[..]) { debug_assert_eq!(result.output, &__ret[..]); if !unconstrained { *result.multiplicity += G::ONE; } } else { record.function_queries[309].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained)); }; + let __ret: [G; OUT_305] = [__v_14]; + if let Some(result) = record.function_queries[305].get_mut(&inp[..]) { debug_assert_eq!(result.output, &__ret[..]); if !unconstrained { *result.multiplicity += G::ONE; } } else { record.function_queries[305].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained)); }; return Ok(__ret); }, 1u64 => { @@ -29427,17 +29153,17 @@ fn aiur_fn_309( let __v_18: G = { let __values: [G; 3] = [__v_13, __v_14, __v_17]; let __mq = record.memory_queries.get_mut(&3).ok_or(ExecError::InvalidMemorySize(3))?; if let Some(result) = __mq.get_mut(&__values[..]) { if !unconstrained { *result.multiplicity += G::ONE; } result.output[0] } else { let __ptr = G::from_usize(__mq.len()); __mq.insert(&__values[..], &[__ptr], G::from_bool(!unconstrained)); __ptr } }; let __v_19: G = { let __values: [G; 3] = [__v_1, __v_12, __v_18]; let __mq = record.memory_queries.get_mut(&3).ok_or(ExecError::InvalidMemorySize(3))?; if let Some(result) = __mq.get_mut(&__values[..]) { if !unconstrained { *result.multiplicity += G::ONE; } result.output[0] } else { let __ptr = G::from_usize(__mq.len()); __mq.insert(&__values[..], &[__ptr], G::from_bool(!unconstrained)); __ptr } }; let __v_20: G = { let __values: [G; 3] = [__v_11, __v_19, __v_0]; let __mq = record.memory_queries.get_mut(&3).ok_or(ExecError::InvalidMemorySize(3))?; if let Some(result) = __mq.get_mut(&__values[..]) { if !unconstrained { *result.multiplicity += G::ONE; } result.output[0] } else { let __ptr = G::from_usize(__mq.len()); __mq.insert(&__values[..], &[__ptr], G::from_bool(!unconstrained)); __ptr } }; - let __ret: [G; OUT_309] = [__v_20]; - if let Some(result) = record.function_queries[309].get_mut(&inp[..]) { debug_assert_eq!(result.output, &__ret[..]); if !unconstrained { *result.multiplicity += G::ONE; } } else { record.function_queries[309].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained)); }; + let __ret: [G; OUT_305] = [__v_20]; + if let Some(result) = record.function_queries[305].get_mut(&inp[..]) { debug_assert_eq!(result.output, &__ret[..]); if !unconstrained { *result.multiplicity += G::ONE; } } else { record.function_queries[305].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained)); }; return Ok(__ret); }, _ => { let __v_11: G = G::from_u64(0); - let __r_arr: [G; OUT_309] = { let __args: [G; IN_309] = [__v_6, __v_1, __v_2, __v_3]; let __cu = unconstrained; if let Some(result) = record.function_queries[309].get_mut(&__args[..]) { if !__cu && *result.multiplicity == G::ZERO { aiur_fn_309(__args, record, io_buffer, false)? } else { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_309] = unsafe { *(result.output.as_ptr() as *const [G; OUT_309]) }; __ret } } else { aiur_fn_309(__args, record, io_buffer, __cu)? } }; + let __r_arr: [G; OUT_305] = { let __args: [G; IN_305] = [__v_6, __v_1, __v_2, __v_3]; let __cu = unconstrained; if let Some(result) = record.function_queries[305].get_mut(&__args[..]) { if !__cu && *result.multiplicity == G::ZERO { aiur_fn_305(__args, record, io_buffer, false)? } else { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_305] = unsafe { *(result.output.as_ptr() as *const [G; OUT_305]) }; __ret } } else { aiur_fn_305(__args, record, io_buffer, __cu)? } }; let __v_12: G = __r_arr[0]; let __v_13: G = { let __values: [G; 3] = [__v_11, __v_5, __v_12]; let __mq = record.memory_queries.get_mut(&3).ok_or(ExecError::InvalidMemorySize(3))?; if let Some(result) = __mq.get_mut(&__values[..]) { if !unconstrained { *result.multiplicity += G::ONE; } result.output[0] } else { let __ptr = G::from_usize(__mq.len()); __mq.insert(&__values[..], &[__ptr], G::from_bool(!unconstrained)); __ptr } }; - let __ret: [G; OUT_309] = [__v_13]; - if let Some(result) = record.function_queries[309].get_mut(&inp[..]) { debug_assert_eq!(result.output, &__ret[..]); if !unconstrained { *result.multiplicity += G::ONE; } } else { record.function_queries[309].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained)); }; + let __ret: [G; OUT_305] = [__v_13]; + if let Some(result) = record.function_queries[305].get_mut(&inp[..]) { debug_assert_eq!(result.output, &__ret[..]); if !unconstrained { *result.multiplicity += G::ONE; } } else { record.function_queries[305].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained)); }; return Ok(__ret); }, } @@ -29451,15 +29177,15 @@ fn aiur_fn_309( }) } -const INPUT_SIZE_310: usize = 4; -const IN_310: usize = 4; -const OUT_310: usize = 1; -fn aiur_fn_310( - inp: [G; IN_310], +const INPUT_SIZE_306: usize = 4; +const IN_306: usize = 4; +const OUT_306: usize = 1; +fn aiur_fn_306( + inp: [G; IN_306], record: &mut QueryRecord, io_buffer: &mut IOBuffer, unconstrained: bool, -) -> Result<[G; OUT_310], ExecError> { +) -> Result<[G; OUT_306], ExecError> { stacker::maybe_grow(64 * 1024, 4 * 1024 * 1024, || { let __v_0: G = inp[0]; let __v_1: G = inp[1]; @@ -29471,63 +29197,63 @@ fn aiur_fn_310( let __v_6: G = __loaded[2]; match __v_4.as_canonical_u64() { 0u64 => { - let __r_arr: [G; OUT_307] = { let __args: [G; IN_307] = [__v_3, __v_1, __v_2]; let __cu = unconstrained; if let Some(result) = record.function_queries[307].get_mut(&__args[..]) { if !__cu && *result.multiplicity == G::ZERO { aiur_fn_307(__args, record, io_buffer, false)? } else { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_307] = unsafe { *(result.output.as_ptr() as *const [G; OUT_307]) }; __ret } } else { aiur_fn_307(__args, record, io_buffer, __cu)? } }; + let __r_arr: [G; OUT_303] = { let __args: [G; IN_303] = [__v_3, __v_1, __v_2]; let __cu = unconstrained; if let Some(result) = record.function_queries[303].get_mut(&__args[..]) { if !__cu && *result.multiplicity == G::ZERO { aiur_fn_303(__args, record, io_buffer, false)? } else { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_303] = unsafe { *(result.output.as_ptr() as *const [G; OUT_303]) }; __ret } } else { aiur_fn_303(__args, record, io_buffer, __cu)? } }; let __v_7: G = __r_arr[0]; - let __ret: [G; OUT_310] = [__v_7]; - if let Some(result) = record.function_queries[310].get_mut(&inp[..]) { debug_assert_eq!(result.output, &__ret[..]); if !unconstrained { *result.multiplicity += G::ONE; } } else { record.function_queries[310].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained)); }; + let __ret: [G; OUT_306] = [__v_7]; + if let Some(result) = record.function_queries[306].get_mut(&inp[..]) { debug_assert_eq!(result.output, &__ret[..]); if !unconstrained { *result.multiplicity += G::ONE; } } else { record.function_queries[306].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained)); }; return Ok(__ret); }, 1u64 => { let __v_7: G = G::from_u64(1); let __v_8: G = (__v_2 + __v_7); - let __r_arr: [G; OUT_310] = { let __args: [G; IN_310] = [__v_5, __v_1, __v_8, __v_3]; let __cu = unconstrained; if let Some(result) = record.function_queries[310].get_mut(&__args[..]) { if !__cu && *result.multiplicity == G::ZERO { aiur_fn_310(__args, record, io_buffer, false)? } else { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_310] = unsafe { *(result.output.as_ptr() as *const [G; OUT_310]) }; __ret } } else { aiur_fn_310(__args, record, io_buffer, __cu)? } }; + let __r_arr: [G; OUT_306] = { let __args: [G; IN_306] = [__v_5, __v_1, __v_8, __v_3]; let __cu = unconstrained; if let Some(result) = record.function_queries[306].get_mut(&__args[..]) { if !__cu && *result.multiplicity == G::ZERO { aiur_fn_306(__args, record, io_buffer, false)? } else { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_306] = unsafe { *(result.output.as_ptr() as *const [G; OUT_306]) }; __ret } } else { aiur_fn_306(__args, record, io_buffer, __cu)? } }; let __v_9: G = __r_arr[0]; - let __ret: [G; OUT_310] = [__v_9]; - if let Some(result) = record.function_queries[310].get_mut(&inp[..]) { debug_assert_eq!(result.output, &__ret[..]); if !unconstrained { *result.multiplicity += G::ONE; } } else { record.function_queries[310].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained)); }; + let __ret: [G; OUT_306] = [__v_9]; + if let Some(result) = record.function_queries[306].get_mut(&inp[..]) { debug_assert_eq!(result.output, &__ret[..]); if !unconstrained { *result.multiplicity += G::ONE; } } else { record.function_queries[306].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained)); }; return Ok(__ret); }, 2u64 => { - let __r_arr: [G; OUT_310] = { let __args: [G; IN_310] = [__v_5, __v_1, __v_2, __v_3]; let __cu = unconstrained; if let Some(result) = record.function_queries[310].get_mut(&__args[..]) { if !__cu && *result.multiplicity == G::ZERO { aiur_fn_310(__args, record, io_buffer, false)? } else { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_310] = unsafe { *(result.output.as_ptr() as *const [G; OUT_310]) }; __ret } } else { aiur_fn_310(__args, record, io_buffer, __cu)? } }; + let __r_arr: [G; OUT_306] = { let __args: [G; IN_306] = [__v_5, __v_1, __v_2, __v_3]; let __cu = unconstrained; if let Some(result) = record.function_queries[306].get_mut(&__args[..]) { if !__cu && *result.multiplicity == G::ZERO { aiur_fn_306(__args, record, io_buffer, false)? } else { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_306] = unsafe { *(result.output.as_ptr() as *const [G; OUT_306]) }; __ret } } else { aiur_fn_306(__args, record, io_buffer, __cu)? } }; let __v_7: G = __r_arr[0]; - let __r_arr: [G; OUT_310] = { let __args: [G; IN_310] = [__v_6, __v_1, __v_2, __v_7]; let __cu = unconstrained; if let Some(result) = record.function_queries[310].get_mut(&__args[..]) { if !__cu && *result.multiplicity == G::ZERO { aiur_fn_310(__args, record, io_buffer, false)? } else { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_310] = unsafe { *(result.output.as_ptr() as *const [G; OUT_310]) }; __ret } } else { aiur_fn_310(__args, record, io_buffer, __cu)? } }; + let __r_arr: [G; OUT_306] = { let __args: [G; IN_306] = [__v_6, __v_1, __v_2, __v_7]; let __cu = unconstrained; if let Some(result) = record.function_queries[306].get_mut(&__args[..]) { if !__cu && *result.multiplicity == G::ZERO { aiur_fn_306(__args, record, io_buffer, false)? } else { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_306] = unsafe { *(result.output.as_ptr() as *const [G; OUT_306]) }; __ret } } else { aiur_fn_306(__args, record, io_buffer, __cu)? } }; let __v_8: G = __r_arr[0]; - let __ret: [G; OUT_310] = [__v_8]; - if let Some(result) = record.function_queries[310].get_mut(&inp[..]) { debug_assert_eq!(result.output, &__ret[..]); if !unconstrained { *result.multiplicity += G::ONE; } } else { record.function_queries[310].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained)); }; + let __ret: [G; OUT_306] = [__v_8]; + if let Some(result) = record.function_queries[306].get_mut(&inp[..]) { debug_assert_eq!(result.output, &__ret[..]); if !unconstrained { *result.multiplicity += G::ONE; } } else { record.function_queries[306].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained)); }; return Ok(__ret); }, 3u64 => { - let __r_arr: [G; OUT_311] = { let __args: [G; IN_311] = [__v_5, __v_6, __v_1, __v_2, __v_3]; let __cu = unconstrained; if let Some(result) = record.function_queries[311].get_mut(&__args[..]) { if !__cu && *result.multiplicity == G::ZERO { aiur_fn_311(__args, record, io_buffer, false)? } else { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_311] = unsafe { *(result.output.as_ptr() as *const [G; OUT_311]) }; __ret } } else { aiur_fn_311(__args, record, io_buffer, __cu)? } }; + let __r_arr: [G; OUT_307] = { let __args: [G; IN_307] = [__v_5, __v_6, __v_1, __v_2, __v_3]; let __cu = unconstrained; if let Some(result) = record.function_queries[307].get_mut(&__args[..]) { if !__cu && *result.multiplicity == G::ZERO { aiur_fn_307(__args, record, io_buffer, false)? } else { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_307] = unsafe { *(result.output.as_ptr() as *const [G; OUT_307]) }; __ret } } else { aiur_fn_307(__args, record, io_buffer, __cu)? } }; let __v_7: G = __r_arr[0]; - let __ret: [G; OUT_310] = [__v_7]; - if let Some(result) = record.function_queries[310].get_mut(&inp[..]) { debug_assert_eq!(result.output, &__ret[..]); if !unconstrained { *result.multiplicity += G::ONE; } } else { record.function_queries[310].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained)); }; + let __ret: [G; OUT_306] = [__v_7]; + if let Some(result) = record.function_queries[306].get_mut(&inp[..]) { debug_assert_eq!(result.output, &__ret[..]); if !unconstrained { *result.multiplicity += G::ONE; } } else { record.function_queries[306].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained)); }; return Ok(__ret); }, 4u64 => { - let __r_arr: [G; OUT_302] = { let __args: [G; IN_302] = [__v_5, __v_1]; let __cu = unconstrained; if let Some(result) = record.function_queries[302].get_mut(&__args[..]) { if !__cu && *result.multiplicity == G::ZERO { aiur_fn_302(__args, record, io_buffer, false)? } else { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_302] = unsafe { *(result.output.as_ptr() as *const [G; OUT_302]) }; __ret } } else { aiur_fn_302(__args, record, io_buffer, __cu)? } }; + let __r_arr: [G; OUT_298] = { let __args: [G; IN_298] = [__v_5, __v_1]; let __cu = unconstrained; if let Some(result) = record.function_queries[298].get_mut(&__args[..]) { if !__cu && *result.multiplicity == G::ZERO { aiur_fn_298(__args, record, io_buffer, false)? } else { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_298] = unsafe { *(result.output.as_ptr() as *const [G; OUT_298]) }; __ret } } else { aiur_fn_298(__args, record, io_buffer, __cu)? } }; let __v_7: G = __r_arr[0]; let __v_8: G = __r_arr[1]; match __v_7.as_canonical_u64() { 1u64 => { - let __r_arr: [G; OUT_307] = { let __args: [G; IN_307] = [__v_3, __v_1, __v_2]; let __cu = unconstrained; if let Some(result) = record.function_queries[307].get_mut(&__args[..]) { if !__cu && *result.multiplicity == G::ZERO { aiur_fn_307(__args, record, io_buffer, false)? } else { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_307] = unsafe { *(result.output.as_ptr() as *const [G; OUT_307]) }; __ret } } else { aiur_fn_307(__args, record, io_buffer, __cu)? } }; + let __r_arr: [G; OUT_303] = { let __args: [G; IN_303] = [__v_3, __v_1, __v_2]; let __cu = unconstrained; if let Some(result) = record.function_queries[303].get_mut(&__args[..]) { if !__cu && *result.multiplicity == G::ZERO { aiur_fn_303(__args, record, io_buffer, false)? } else { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_303] = unsafe { *(result.output.as_ptr() as *const [G; OUT_303]) }; __ret } } else { aiur_fn_303(__args, record, io_buffer, __cu)? } }; let __v_9: G = __r_arr[0]; - let __r_arr: [G; OUT_309] = { let __args: [G; IN_309] = [__v_9, __v_8, __v_5, __v_2]; let __cu = unconstrained; if let Some(result) = record.function_queries[309].get_mut(&__args[..]) { if !__cu && *result.multiplicity == G::ZERO { aiur_fn_309(__args, record, io_buffer, false)? } else { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_309] = unsafe { *(result.output.as_ptr() as *const [G; OUT_309]) }; __ret } } else { aiur_fn_309(__args, record, io_buffer, __cu)? } }; + let __r_arr: [G; OUT_305] = { let __args: [G; IN_305] = [__v_9, __v_8, __v_5, __v_2]; let __cu = unconstrained; if let Some(result) = record.function_queries[305].get_mut(&__args[..]) { if !__cu && *result.multiplicity == G::ZERO { aiur_fn_305(__args, record, io_buffer, false)? } else { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_305] = unsafe { *(result.output.as_ptr() as *const [G; OUT_305]) }; __ret } } else { aiur_fn_305(__args, record, io_buffer, __cu)? } }; let __v_10: G = __r_arr[0]; - let __ret: [G; OUT_310] = [__v_10]; - if let Some(result) = record.function_queries[310].get_mut(&inp[..]) { debug_assert_eq!(result.output, &__ret[..]); if !unconstrained { *result.multiplicity += G::ONE; } } else { record.function_queries[310].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained)); }; + let __ret: [G; OUT_306] = [__v_10]; + if let Some(result) = record.function_queries[306].get_mut(&inp[..]) { debug_assert_eq!(result.output, &__ret[..]); if !unconstrained { *result.multiplicity += G::ONE; } } else { record.function_queries[306].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained)); }; return Ok(__ret); }, 0u64 => { match __v_2.as_canonical_u64() { 0u64 => { - let __ret: [G; OUT_310] = [__v_3]; - if let Some(result) = record.function_queries[310].get_mut(&inp[..]) { debug_assert_eq!(result.output, &__ret[..]); if !unconstrained { *result.multiplicity += G::ONE; } } else { record.function_queries[310].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained)); }; + let __ret: [G; OUT_306] = [__v_3]; + if let Some(result) = record.function_queries[306].get_mut(&inp[..]) { debug_assert_eq!(result.output, &__ret[..]); if !unconstrained { *result.multiplicity += G::ONE; } } else { record.function_queries[306].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained)); }; return Ok(__ret); }, _ => { - let __r_arr: [G; OUT_309] = { let __args: [G; IN_309] = [__v_3, __v_1, __v_5, __v_2]; let __cu = unconstrained; if let Some(result) = record.function_queries[309].get_mut(&__args[..]) { if !__cu && *result.multiplicity == G::ZERO { aiur_fn_309(__args, record, io_buffer, false)? } else { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_309] = unsafe { *(result.output.as_ptr() as *const [G; OUT_309]) }; __ret } } else { aiur_fn_309(__args, record, io_buffer, __cu)? } }; + let __r_arr: [G; OUT_305] = { let __args: [G; IN_305] = [__v_3, __v_1, __v_5, __v_2]; let __cu = unconstrained; if let Some(result) = record.function_queries[305].get_mut(&__args[..]) { if !__cu && *result.multiplicity == G::ZERO { aiur_fn_305(__args, record, io_buffer, false)? } else { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_305] = unsafe { *(result.output.as_ptr() as *const [G; OUT_305]) }; __ret } } else { aiur_fn_305(__args, record, io_buffer, __cu)? } }; let __v_9: G = __r_arr[0]; - let __ret: [G; OUT_310] = [__v_9]; - if let Some(result) = record.function_queries[310].get_mut(&inp[..]) { debug_assert_eq!(result.output, &__ret[..]); if !unconstrained { *result.multiplicity += G::ONE; } } else { record.function_queries[310].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained)); }; + let __ret: [G; OUT_306] = [__v_9]; + if let Some(result) = record.function_queries[306].get_mut(&inp[..]) { debug_assert_eq!(result.output, &__ret[..]); if !unconstrained { *result.multiplicity += G::ONE; } } else { record.function_queries[306].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained)); }; return Ok(__ret); }, } @@ -29544,15 +29270,15 @@ fn aiur_fn_310( }) } -const INPUT_SIZE_311: usize = 5; -const IN_311: usize = 5; -const OUT_311: usize = 1; -fn aiur_fn_311( - inp: [G; IN_311], +const INPUT_SIZE_307: usize = 5; +const IN_307: usize = 5; +const OUT_307: usize = 1; +fn aiur_fn_307( + inp: [G; IN_307], record: &mut QueryRecord, io_buffer: &mut IOBuffer, unconstrained: bool, -) -> Result<[G; OUT_311], ExecError> { +) -> Result<[G; OUT_307], ExecError> { stacker::maybe_grow(64 * 1024, 4 * 1024 * 1024, || { let __v_0: G = inp[0]; let __v_1: G = inp[1]; @@ -29565,55 +29291,55 @@ fn aiur_fn_311( let __v_7: G = __loaded[2]; match __v_5.as_canonical_u64() { 0u64 => { - let __r_arr: [G; OUT_307] = { let __args: [G; IN_307] = [__v_4, __v_2, __v_3]; let __cu = unconstrained; if let Some(result) = record.function_queries[307].get_mut(&__args[..]) { if !__cu && *result.multiplicity == G::ZERO { aiur_fn_307(__args, record, io_buffer, false)? } else { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_307] = unsafe { *(result.output.as_ptr() as *const [G; OUT_307]) }; __ret } } else { aiur_fn_307(__args, record, io_buffer, __cu)? } }; + let __r_arr: [G; OUT_303] = { let __args: [G; IN_303] = [__v_4, __v_2, __v_3]; let __cu = unconstrained; if let Some(result) = record.function_queries[303].get_mut(&__args[..]) { if !__cu && *result.multiplicity == G::ZERO { aiur_fn_303(__args, record, io_buffer, false)? } else { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_303] = unsafe { *(result.output.as_ptr() as *const [G; OUT_303]) }; __ret } } else { aiur_fn_303(__args, record, io_buffer, __cu)? } }; let __v_8: G = __r_arr[0]; - let __ret: [G; OUT_311] = [__v_8]; - if let Some(result) = record.function_queries[311].get_mut(&inp[..]) { debug_assert_eq!(result.output, &__ret[..]); if !unconstrained { *result.multiplicity += G::ONE; } } else { record.function_queries[311].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained)); }; + let __ret: [G; OUT_307] = [__v_8]; + if let Some(result) = record.function_queries[307].get_mut(&inp[..]) { debug_assert_eq!(result.output, &__ret[..]); if !unconstrained { *result.multiplicity += G::ONE; } } else { record.function_queries[307].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained)); }; return Ok(__ret); }, 1u64 => { let __v_8: G = G::from_u64(1); let __v_9: G = (__v_3 + __v_8); - let __r_arr: [G; OUT_310] = { let __args: [G; IN_310] = [__v_0, __v_2, __v_3, __v_4]; let __cu = unconstrained; if let Some(result) = record.function_queries[310].get_mut(&__args[..]) { if !__cu && *result.multiplicity == G::ZERO { aiur_fn_310(__args, record, io_buffer, false)? } else { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_310] = unsafe { *(result.output.as_ptr() as *const [G; OUT_310]) }; __ret } } else { aiur_fn_310(__args, record, io_buffer, __cu)? } }; + let __r_arr: [G; OUT_306] = { let __args: [G; IN_306] = [__v_0, __v_2, __v_3, __v_4]; let __cu = unconstrained; if let Some(result) = record.function_queries[306].get_mut(&__args[..]) { if !__cu && *result.multiplicity == G::ZERO { aiur_fn_306(__args, record, io_buffer, false)? } else { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_306] = unsafe { *(result.output.as_ptr() as *const [G; OUT_306]) }; __ret } } else { aiur_fn_306(__args, record, io_buffer, __cu)? } }; let __v_10: G = __r_arr[0]; - let __r_arr: [G; OUT_310] = { let __args: [G; IN_310] = [__v_6, __v_2, __v_9, __v_10]; let __cu = unconstrained; if let Some(result) = record.function_queries[310].get_mut(&__args[..]) { if !__cu && *result.multiplicity == G::ZERO { aiur_fn_310(__args, record, io_buffer, false)? } else { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_310] = unsafe { *(result.output.as_ptr() as *const [G; OUT_310]) }; __ret } } else { aiur_fn_310(__args, record, io_buffer, __cu)? } }; + let __r_arr: [G; OUT_306] = { let __args: [G; IN_306] = [__v_6, __v_2, __v_9, __v_10]; let __cu = unconstrained; if let Some(result) = record.function_queries[306].get_mut(&__args[..]) { if !__cu && *result.multiplicity == G::ZERO { aiur_fn_306(__args, record, io_buffer, false)? } else { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_306] = unsafe { *(result.output.as_ptr() as *const [G; OUT_306]) }; __ret } } else { aiur_fn_306(__args, record, io_buffer, __cu)? } }; let __v_11: G = __r_arr[0]; - let __ret: [G; OUT_311] = [__v_11]; - if let Some(result) = record.function_queries[311].get_mut(&inp[..]) { debug_assert_eq!(result.output, &__ret[..]); if !unconstrained { *result.multiplicity += G::ONE; } } else { record.function_queries[311].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained)); }; + let __ret: [G; OUT_307] = [__v_11]; + if let Some(result) = record.function_queries[307].get_mut(&inp[..]) { debug_assert_eq!(result.output, &__ret[..]); if !unconstrained { *result.multiplicity += G::ONE; } } else { record.function_queries[307].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained)); }; return Ok(__ret); }, 2u64 => { - let __r_arr: [G; OUT_311] = { let __args: [G; IN_311] = [__v_0, __v_6, __v_2, __v_3, __v_4]; let __cu = unconstrained; if let Some(result) = record.function_queries[311].get_mut(&__args[..]) { if !__cu && *result.multiplicity == G::ZERO { aiur_fn_311(__args, record, io_buffer, false)? } else { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_311] = unsafe { *(result.output.as_ptr() as *const [G; OUT_311]) }; __ret } } else { aiur_fn_311(__args, record, io_buffer, __cu)? } }; + let __r_arr: [G; OUT_307] = { let __args: [G; IN_307] = [__v_0, __v_6, __v_2, __v_3, __v_4]; let __cu = unconstrained; if let Some(result) = record.function_queries[307].get_mut(&__args[..]) { if !__cu && *result.multiplicity == G::ZERO { aiur_fn_307(__args, record, io_buffer, false)? } else { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_307] = unsafe { *(result.output.as_ptr() as *const [G; OUT_307]) }; __ret } } else { aiur_fn_307(__args, record, io_buffer, __cu)? } }; let __v_8: G = __r_arr[0]; - let __r_arr: [G; OUT_311] = { let __args: [G; IN_311] = [__v_0, __v_7, __v_2, __v_3, __v_8]; let __cu = unconstrained; if let Some(result) = record.function_queries[311].get_mut(&__args[..]) { if !__cu && *result.multiplicity == G::ZERO { aiur_fn_311(__args, record, io_buffer, false)? } else { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_311] = unsafe { *(result.output.as_ptr() as *const [G; OUT_311]) }; __ret } } else { aiur_fn_311(__args, record, io_buffer, __cu)? } }; + let __r_arr: [G; OUT_307] = { let __args: [G; IN_307] = [__v_0, __v_7, __v_2, __v_3, __v_8]; let __cu = unconstrained; if let Some(result) = record.function_queries[307].get_mut(&__args[..]) { if !__cu && *result.multiplicity == G::ZERO { aiur_fn_307(__args, record, io_buffer, false)? } else { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_307] = unsafe { *(result.output.as_ptr() as *const [G; OUT_307]) }; __ret } } else { aiur_fn_307(__args, record, io_buffer, __cu)? } }; let __v_9: G = __r_arr[0]; - let __ret: [G; OUT_311] = [__v_9]; - if let Some(result) = record.function_queries[311].get_mut(&inp[..]) { debug_assert_eq!(result.output, &__ret[..]); if !unconstrained { *result.multiplicity += G::ONE; } } else { record.function_queries[311].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained)); }; + let __ret: [G; OUT_307] = [__v_9]; + if let Some(result) = record.function_queries[307].get_mut(&inp[..]) { debug_assert_eq!(result.output, &__ret[..]); if !unconstrained { *result.multiplicity += G::ONE; } } else { record.function_queries[307].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained)); }; return Ok(__ret); }, 3u64 => { - let __r_arr: [G; OUT_311] = { let __args: [G; IN_311] = [__v_0, __v_7, __v_2, __v_3, __v_4]; let __cu = unconstrained; if let Some(result) = record.function_queries[311].get_mut(&__args[..]) { if !__cu && *result.multiplicity == G::ZERO { aiur_fn_311(__args, record, io_buffer, false)? } else { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_311] = unsafe { *(result.output.as_ptr() as *const [G; OUT_311]) }; __ret } } else { aiur_fn_311(__args, record, io_buffer, __cu)? } }; + let __r_arr: [G; OUT_307] = { let __args: [G; IN_307] = [__v_0, __v_7, __v_2, __v_3, __v_4]; let __cu = unconstrained; if let Some(result) = record.function_queries[307].get_mut(&__args[..]) { if !__cu && *result.multiplicity == G::ZERO { aiur_fn_307(__args, record, io_buffer, false)? } else { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_307] = unsafe { *(result.output.as_ptr() as *const [G; OUT_307]) }; __ret } } else { aiur_fn_307(__args, record, io_buffer, __cu)? } }; let __v_8: G = __r_arr[0]; - let __r_arr: [G; OUT_311] = { let __args: [G; IN_311] = [__v_6, __v_7, __v_2, __v_3, __v_8]; let __cu = unconstrained; if let Some(result) = record.function_queries[311].get_mut(&__args[..]) { if !__cu && *result.multiplicity == G::ZERO { aiur_fn_311(__args, record, io_buffer, false)? } else { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_311] = unsafe { *(result.output.as_ptr() as *const [G; OUT_311]) }; __ret } } else { aiur_fn_311(__args, record, io_buffer, __cu)? } }; + let __r_arr: [G; OUT_307] = { let __args: [G; IN_307] = [__v_6, __v_7, __v_2, __v_3, __v_8]; let __cu = unconstrained; if let Some(result) = record.function_queries[307].get_mut(&__args[..]) { if !__cu && *result.multiplicity == G::ZERO { aiur_fn_307(__args, record, io_buffer, false)? } else { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_307] = unsafe { *(result.output.as_ptr() as *const [G; OUT_307]) }; __ret } } else { aiur_fn_307(__args, record, io_buffer, __cu)? } }; let __v_9: G = __r_arr[0]; - let __ret: [G; OUT_311] = [__v_9]; - if let Some(result) = record.function_queries[311].get_mut(&inp[..]) { debug_assert_eq!(result.output, &__ret[..]); if !unconstrained { *result.multiplicity += G::ONE; } } else { record.function_queries[311].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained)); }; + let __ret: [G; OUT_307] = [__v_9]; + if let Some(result) = record.function_queries[307].get_mut(&inp[..]) { debug_assert_eq!(result.output, &__ret[..]); if !unconstrained { *result.multiplicity += G::ONE; } } else { record.function_queries[307].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained)); }; return Ok(__ret); }, 4u64 => { - let __r_arr: [G; OUT_302] = { let __args: [G; IN_302] = [__v_6, __v_2]; let __cu = unconstrained; if let Some(result) = record.function_queries[302].get_mut(&__args[..]) { if !__cu && *result.multiplicity == G::ZERO { aiur_fn_302(__args, record, io_buffer, false)? } else { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_302] = unsafe { *(result.output.as_ptr() as *const [G; OUT_302]) }; __ret } } else { aiur_fn_302(__args, record, io_buffer, __cu)? } }; + let __r_arr: [G; OUT_298] = { let __args: [G; IN_298] = [__v_6, __v_2]; let __cu = unconstrained; if let Some(result) = record.function_queries[298].get_mut(&__args[..]) { if !__cu && *result.multiplicity == G::ZERO { aiur_fn_298(__args, record, io_buffer, false)? } else { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_298] = unsafe { *(result.output.as_ptr() as *const [G; OUT_298]) }; __ret } } else { aiur_fn_298(__args, record, io_buffer, __cu)? } }; let __v_8: G = __r_arr[0]; let __v_9: G = __r_arr[1]; match __v_8.as_canonical_u64() { 1u64 => { - let __r_arr: [G; OUT_307] = { let __args: [G; IN_307] = [__v_4, __v_2, __v_3]; let __cu = unconstrained; if let Some(result) = record.function_queries[307].get_mut(&__args[..]) { if !__cu && *result.multiplicity == G::ZERO { aiur_fn_307(__args, record, io_buffer, false)? } else { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_307] = unsafe { *(result.output.as_ptr() as *const [G; OUT_307]) }; __ret } } else { aiur_fn_307(__args, record, io_buffer, __cu)? } }; + let __r_arr: [G; OUT_303] = { let __args: [G; IN_303] = [__v_4, __v_2, __v_3]; let __cu = unconstrained; if let Some(result) = record.function_queries[303].get_mut(&__args[..]) { if !__cu && *result.multiplicity == G::ZERO { aiur_fn_303(__args, record, io_buffer, false)? } else { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_303] = unsafe { *(result.output.as_ptr() as *const [G; OUT_303]) }; __ret } } else { aiur_fn_303(__args, record, io_buffer, __cu)? } }; let __v_10: G = __r_arr[0]; - let __r_arr: [G; OUT_309] = { let __args: [G; IN_309] = [__v_10, __v_9, __v_6, __v_3]; let __cu = unconstrained; if let Some(result) = record.function_queries[309].get_mut(&__args[..]) { if !__cu && *result.multiplicity == G::ZERO { aiur_fn_309(__args, record, io_buffer, false)? } else { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_309] = unsafe { *(result.output.as_ptr() as *const [G; OUT_309]) }; __ret } } else { aiur_fn_309(__args, record, io_buffer, __cu)? } }; + let __r_arr: [G; OUT_305] = { let __args: [G; IN_305] = [__v_10, __v_9, __v_6, __v_3]; let __cu = unconstrained; if let Some(result) = record.function_queries[305].get_mut(&__args[..]) { if !__cu && *result.multiplicity == G::ZERO { aiur_fn_305(__args, record, io_buffer, false)? } else { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_305] = unsafe { *(result.output.as_ptr() as *const [G; OUT_305]) }; __ret } } else { aiur_fn_305(__args, record, io_buffer, __cu)? } }; let __v_11: G = __r_arr[0]; - let __r_arr: [G; OUT_310] = { let __args: [G; IN_310] = [__v_0, __v_9, __v_3, __v_11]; let __cu = unconstrained; if let Some(result) = record.function_queries[310].get_mut(&__args[..]) { if !__cu && *result.multiplicity == G::ZERO { aiur_fn_310(__args, record, io_buffer, false)? } else { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_310] = unsafe { *(result.output.as_ptr() as *const [G; OUT_310]) }; __ret } } else { aiur_fn_310(__args, record, io_buffer, __cu)? } }; + let __r_arr: [G; OUT_306] = { let __args: [G; IN_306] = [__v_0, __v_9, __v_3, __v_11]; let __cu = unconstrained; if let Some(result) = record.function_queries[306].get_mut(&__args[..]) { if !__cu && *result.multiplicity == G::ZERO { aiur_fn_306(__args, record, io_buffer, false)? } else { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_306] = unsafe { *(result.output.as_ptr() as *const [G; OUT_306]) }; __ret } } else { aiur_fn_306(__args, record, io_buffer, __cu)? } }; let __v_12: G = __r_arr[0]; - let __ret: [G; OUT_311] = [__v_12]; - if let Some(result) = record.function_queries[311].get_mut(&inp[..]) { debug_assert_eq!(result.output, &__ret[..]); if !unconstrained { *result.multiplicity += G::ONE; } } else { record.function_queries[311].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained)); }; + let __ret: [G; OUT_307] = [__v_12]; + if let Some(result) = record.function_queries[307].get_mut(&inp[..]) { debug_assert_eq!(result.output, &__ret[..]); if !unconstrained { *result.multiplicity += G::ONE; } } else { record.function_queries[307].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained)); }; return Ok(__ret); }, 0u64 => { @@ -29622,17 +29348,17 @@ fn aiur_fn_311( break '__mc_0 [__v_4]; }, _ => { - let __r_arr: [G; OUT_309] = { let __args: [G; IN_309] = [__v_4, __v_2, __v_6, __v_3]; let __cu = unconstrained; if let Some(result) = record.function_queries[309].get_mut(&__args[..]) { if !__cu && *result.multiplicity == G::ZERO { aiur_fn_309(__args, record, io_buffer, false)? } else { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_309] = unsafe { *(result.output.as_ptr() as *const [G; OUT_309]) }; __ret } } else { aiur_fn_309(__args, record, io_buffer, __cu)? } }; + let __r_arr: [G; OUT_305] = { let __args: [G; IN_305] = [__v_4, __v_2, __v_6, __v_3]; let __cu = unconstrained; if let Some(result) = record.function_queries[305].get_mut(&__args[..]) { if !__cu && *result.multiplicity == G::ZERO { aiur_fn_305(__args, record, io_buffer, false)? } else { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_305] = unsafe { *(result.output.as_ptr() as *const [G; OUT_305]) }; __ret } } else { aiur_fn_305(__args, record, io_buffer, __cu)? } }; let __v_10: G = __r_arr[0]; break '__mc_0 [__v_10]; }, } }; let __v_10: G = __mc_out___mc_0[0]; - let __r_arr: [G; OUT_310] = { let __args: [G; IN_310] = [__v_0, __v_2, __v_3, __v_10]; let __cu = unconstrained; if let Some(result) = record.function_queries[310].get_mut(&__args[..]) { if !__cu && *result.multiplicity == G::ZERO { aiur_fn_310(__args, record, io_buffer, false)? } else { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_310] = unsafe { *(result.output.as_ptr() as *const [G; OUT_310]) }; __ret } } else { aiur_fn_310(__args, record, io_buffer, __cu)? } }; + let __r_arr: [G; OUT_306] = { let __args: [G; IN_306] = [__v_0, __v_2, __v_3, __v_10]; let __cu = unconstrained; if let Some(result) = record.function_queries[306].get_mut(&__args[..]) { if !__cu && *result.multiplicity == G::ZERO { aiur_fn_306(__args, record, io_buffer, false)? } else { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_306] = unsafe { *(result.output.as_ptr() as *const [G; OUT_306]) }; __ret } } else { aiur_fn_306(__args, record, io_buffer, __cu)? } }; let __v_11: G = __r_arr[0]; - let __ret: [G; OUT_311] = [__v_11]; - if let Some(result) = record.function_queries[311].get_mut(&inp[..]) { debug_assert_eq!(result.output, &__ret[..]); if !unconstrained { *result.multiplicity += G::ONE; } } else { record.function_queries[311].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained)); }; + let __ret: [G; OUT_307] = [__v_11]; + if let Some(result) = record.function_queries[307].get_mut(&inp[..]) { debug_assert_eq!(result.output, &__ret[..]); if !unconstrained { *result.multiplicity += G::ONE; } } else { record.function_queries[307].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained)); }; return Ok(__ret); }, _ => { @@ -29647,15 +29373,15 @@ fn aiur_fn_311( }) } -const INPUT_SIZE_312: usize = 2; -const IN_312: usize = 2; -const OUT_312: usize = 1; -fn aiur_fn_312( - inp: [G; IN_312], +const INPUT_SIZE_308: usize = 2; +const IN_308: usize = 2; +const OUT_308: usize = 1; +fn aiur_fn_308( + inp: [G; IN_308], record: &mut QueryRecord, io_buffer: &mut IOBuffer, unconstrained: bool, -) -> Result<[G; OUT_312], ExecError> { +) -> Result<[G; OUT_308], ExecError> { stacker::maybe_grow(64 * 1024, 4 * 1024 * 1024, || { let __v_0: G = inp[0]; let __v_1: G = inp[1]; @@ -29665,19 +29391,19 @@ fn aiur_fn_312( let __v_4: G = __loaded[2]; match __v_2.as_canonical_u64() { 1u64 => { - let __ret: [G; OUT_312] = [__v_0]; - if let Some(result) = record.function_queries[312].get_mut(&inp[..]) { debug_assert_eq!(result.output, &__ret[..]); if !unconstrained { *result.multiplicity += G::ONE; } } else { record.function_queries[312].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained)); }; + let __ret: [G; OUT_308] = [__v_0]; + if let Some(result) = record.function_queries[308].get_mut(&inp[..]) { debug_assert_eq!(result.output, &__ret[..]); if !unconstrained { *result.multiplicity += G::ONE; } } else { record.function_queries[308].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained)); }; return Ok(__ret); }, 0u64 => { let __v_5: G = G::from_u64(0); - let __r_arr: [G; OUT_313] = { let __args: [G; IN_313] = [__v_3, __v_1]; let __cu = unconstrained; if let Some(result) = record.function_queries[313].get_mut(&__args[..]) { if !__cu && *result.multiplicity == G::ZERO { aiur_fn_313(__args, record, io_buffer, false)? } else { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_313] = unsafe { *(result.output.as_ptr() as *const [G; OUT_313]) }; __ret } } else { aiur_fn_313(__args, record, io_buffer, __cu)? } }; + let __r_arr: [G; OUT_309] = { let __args: [G; IN_309] = [__v_3, __v_1]; let __cu = unconstrained; if let Some(result) = record.function_queries[309].get_mut(&__args[..]) { if !__cu && *result.multiplicity == G::ZERO { aiur_fn_309(__args, record, io_buffer, false)? } else { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_309] = unsafe { *(result.output.as_ptr() as *const [G; OUT_309]) }; __ret } } else { aiur_fn_309(__args, record, io_buffer, __cu)? } }; let __v_6: G = __r_arr[0]; - let __r_arr: [G; OUT_312] = { let __args: [G; IN_312] = [__v_4, __v_1]; let __cu = unconstrained; if let Some(result) = record.function_queries[312].get_mut(&__args[..]) { if !__cu && *result.multiplicity == G::ZERO { aiur_fn_312(__args, record, io_buffer, false)? } else { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_312] = unsafe { *(result.output.as_ptr() as *const [G; OUT_312]) }; __ret } } else { aiur_fn_312(__args, record, io_buffer, __cu)? } }; + let __r_arr: [G; OUT_308] = { let __args: [G; IN_308] = [__v_4, __v_1]; let __cu = unconstrained; if let Some(result) = record.function_queries[308].get_mut(&__args[..]) { if !__cu && *result.multiplicity == G::ZERO { aiur_fn_308(__args, record, io_buffer, false)? } else { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_308] = unsafe { *(result.output.as_ptr() as *const [G; OUT_308]) }; __ret } } else { aiur_fn_308(__args, record, io_buffer, __cu)? } }; let __v_7: G = __r_arr[0]; let __v_8: G = { let __values: [G; 3] = [__v_5, __v_6, __v_7]; let __mq = record.memory_queries.get_mut(&3).ok_or(ExecError::InvalidMemorySize(3))?; if let Some(result) = __mq.get_mut(&__values[..]) { if !unconstrained { *result.multiplicity += G::ONE; } result.output[0] } else { let __ptr = G::from_usize(__mq.len()); __mq.insert(&__values[..], &[__ptr], G::from_bool(!unconstrained)); __ptr } }; - let __ret: [G; OUT_312] = [__v_8]; - if let Some(result) = record.function_queries[312].get_mut(&inp[..]) { debug_assert_eq!(result.output, &__ret[..]); if !unconstrained { *result.multiplicity += G::ONE; } } else { record.function_queries[312].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained)); }; + let __ret: [G; OUT_308] = [__v_8]; + if let Some(result) = record.function_queries[308].get_mut(&inp[..]) { debug_assert_eq!(result.output, &__ret[..]); if !unconstrained { *result.multiplicity += G::ONE; } } else { record.function_queries[308].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained)); }; return Ok(__ret); }, _ => { @@ -29687,15 +29413,15 @@ fn aiur_fn_312( }) } -const INPUT_SIZE_313: usize = 2; -const IN_313: usize = 2; -const OUT_313: usize = 1; -fn aiur_fn_313( - inp: [G; IN_313], +const INPUT_SIZE_309: usize = 2; +const IN_309: usize = 2; +const OUT_309: usize = 1; +fn aiur_fn_309( + inp: [G; IN_309], record: &mut QueryRecord, io_buffer: &mut IOBuffer, unconstrained: bool, -) -> Result<[G; OUT_313], ExecError> { +) -> Result<[G; OUT_309], ExecError> { stacker::maybe_grow(64 * 1024, 4 * 1024 * 1024, || { let __v_0: G = inp[0]; let __v_1: G = inp[1]; @@ -29705,8 +29431,8 @@ fn aiur_fn_313( let __v_4: G = __loaded[2]; match __v_2.as_canonical_u64() { 1u64 => { - let __ret: [G; OUT_313] = [__v_0]; - if let Some(result) = record.function_queries[313].get_mut(&inp[..]) { debug_assert_eq!(result.output, &__ret[..]); if !unconstrained { *result.multiplicity += G::ONE; } } else { record.function_queries[313].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained)); }; + let __ret: [G; OUT_309] = [__v_0]; + if let Some(result) = record.function_queries[309].get_mut(&inp[..]) { debug_assert_eq!(result.output, &__ret[..]); if !unconstrained { *result.multiplicity += G::ONE; } } else { record.function_queries[309].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained)); }; return Ok(__ret); }, 0u64 => { @@ -29722,18 +29448,18 @@ fn aiur_fn_313( let __v_10: G = __loaded[2]; match __v_8.as_canonical_u64() { _ => { - let __r_arr: [G; OUT_300] = { let __args: [G; IN_300] = [__v_8, __v_5]; let __cu = unconstrained; if let Some(result) = record.function_queries[300].get_mut(&__args[..]) { if !__cu && *result.multiplicity == G::ZERO { aiur_fn_300(__args, record, io_buffer, false)? } else { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_300] = unsafe { *(result.output.as_ptr() as *const [G; OUT_300]) }; __ret } } else { aiur_fn_300(__args, record, io_buffer, __cu)? } }; + let __r_arr: [G; OUT_296] = { let __args: [G; IN_296] = [__v_8, __v_5]; let __cu = unconstrained; if let Some(result) = record.function_queries[296].get_mut(&__args[..]) { if !__cu && *result.multiplicity == G::ZERO { aiur_fn_296(__args, record, io_buffer, false)? } else { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_296] = unsafe { *(result.output.as_ptr() as *const [G; OUT_296]) }; __ret } } else { aiur_fn_296(__args, record, io_buffer, __cu)? } }; let __v_11: G = __r_arr[0]; match __v_11.as_canonical_u64() { 0u64 => { - let __r_arr: [G; OUT_313] = { let __args: [G; IN_313] = [__v_0, __v_4]; let __cu = unconstrained; if let Some(result) = record.function_queries[313].get_mut(&__args[..]) { if !__cu && *result.multiplicity == G::ZERO { aiur_fn_313(__args, record, io_buffer, false)? } else { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_313] = unsafe { *(result.output.as_ptr() as *const [G; OUT_313]) }; __ret } } else { aiur_fn_313(__args, record, io_buffer, __cu)? } }; + let __r_arr: [G; OUT_309] = { let __args: [G; IN_309] = [__v_0, __v_4]; let __cu = unconstrained; if let Some(result) = record.function_queries[309].get_mut(&__args[..]) { if !__cu && *result.multiplicity == G::ZERO { aiur_fn_309(__args, record, io_buffer, false)? } else { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_309] = unsafe { *(result.output.as_ptr() as *const [G; OUT_309]) }; __ret } } else { aiur_fn_309(__args, record, io_buffer, __cu)? } }; let __v_12: G = __r_arr[0]; - let __ret: [G; OUT_313] = [__v_12]; - if let Some(result) = record.function_queries[313].get_mut(&inp[..]) { debug_assert_eq!(result.output, &__ret[..]); if !unconstrained { *result.multiplicity += G::ONE; } } else { record.function_queries[313].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained)); }; + let __ret: [G; OUT_309] = [__v_12]; + if let Some(result) = record.function_queries[309].get_mut(&inp[..]) { debug_assert_eq!(result.output, &__ret[..]); if !unconstrained { *result.multiplicity += G::ONE; } } else { record.function_queries[309].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained)); }; return Ok(__ret); }, _ => { - let __r_arr: [G; OUT_301] = { let __args: [G; IN_301] = [__v_5, __v_8]; let __cu = unconstrained; if let Some(result) = record.function_queries[301].get_mut(&__args[..]) { if !__cu && *result.multiplicity == G::ZERO { aiur_fn_301(__args, record, io_buffer, false)? } else { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_301] = unsafe { *(result.output.as_ptr() as *const [G; OUT_301]) }; __ret } } else { aiur_fn_301(__args, record, io_buffer, __cu)? } }; + let __r_arr: [G; OUT_297] = { let __args: [G; IN_297] = [__v_5, __v_8]; let __cu = unconstrained; if let Some(result) = record.function_queries[297].get_mut(&__args[..]) { if !__cu && *result.multiplicity == G::ZERO { aiur_fn_297(__args, record, io_buffer, false)? } else { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_297] = unsafe { *(result.output.as_ptr() as *const [G; OUT_297]) }; __ret } } else { aiur_fn_297(__args, record, io_buffer, __cu)? } }; let __v_12: G = __r_arr[0]; let __mc_out___mc_0: [G; 1] = '__mc_0: { match __v_6.as_canonical_u64() { 0u64 => { @@ -29766,7 +29492,7 @@ fn aiur_fn_313( break '__mc_2 [__v_17]; }, 0u64 => { - let __r_arr: [G; OUT_305] = { let __args: [G; IN_305] = [__v_7]; let __cu = unconstrained; if let Some(result) = record.function_queries[305].get_mut(&__args[..]) { if !__cu && *result.multiplicity == G::ZERO { aiur_fn_305(__args, record, io_buffer, false)? } else { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_305] = unsafe { *(result.output.as_ptr() as *const [G; OUT_305]) }; __ret } } else { aiur_fn_305(__args, record, io_buffer, __cu)? } }; + let __r_arr: [G; OUT_301] = { let __args: [G; IN_301] = [__v_7]; let __cu = unconstrained; if let Some(result) = record.function_queries[301].get_mut(&__args[..]) { if !__cu && *result.multiplicity == G::ZERO { aiur_fn_301(__args, record, io_buffer, false)? } else { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_301] = unsafe { *(result.output.as_ptr() as *const [G; OUT_301]) }; __ret } } else { aiur_fn_301(__args, record, io_buffer, __cu)? } }; let __v_17: G = __r_arr[0]; let __v_18: G = G::from_u64(1); let __v_19: G = (__v_17 + __v_18); @@ -29807,7 +29533,7 @@ fn aiur_fn_313( break '__mc_3 [__v_7]; }, 0u64 => { - let __r_arr: [G; OUT_306] = { let __args: [G; IN_306] = [__v_7, __v_10]; let __cu = unconstrained; if let Some(result) = record.function_queries[306].get_mut(&__args[..]) { if !__cu && *result.multiplicity == G::ZERO { aiur_fn_306(__args, record, io_buffer, false)? } else { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_306] = unsafe { *(result.output.as_ptr() as *const [G; OUT_306]) }; __ret } } else { aiur_fn_306(__args, record, io_buffer, __cu)? } }; + let __r_arr: [G; OUT_302] = { let __args: [G; IN_302] = [__v_7, __v_10]; let __cu = unconstrained; if let Some(result) = record.function_queries[302].get_mut(&__args[..]) { if !__cu && *result.multiplicity == G::ZERO { aiur_fn_302(__args, record, io_buffer, false)? } else { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_302] = unsafe { *(result.output.as_ptr() as *const [G; OUT_302]) }; __ret } } else { aiur_fn_302(__args, record, io_buffer, __cu)? } }; let __v_17: G = __r_arr[0]; break '__mc_3 [__v_17]; }, @@ -29823,10 +29549,10 @@ fn aiur_fn_313( }; let __v_14: G = __mc_out___mc_3[0]; let __v_15: G = { let __values: [G; 3] = [__v_5, __v_13, __v_14]; let __mq = record.memory_queries.get_mut(&3).ok_or(ExecError::InvalidMemorySize(3))?; if let Some(result) = __mq.get_mut(&__values[..]) { if !unconstrained { *result.multiplicity += G::ONE; } result.output[0] } else { let __ptr = G::from_usize(__mq.len()); __mq.insert(&__values[..], &[__ptr], G::from_bool(!unconstrained)); __ptr } }; - let __r_arr: [G; OUT_313] = { let __args: [G; IN_313] = [__v_15, __v_4]; let __cu = unconstrained; if let Some(result) = record.function_queries[313].get_mut(&__args[..]) { if !__cu && *result.multiplicity == G::ZERO { aiur_fn_313(__args, record, io_buffer, false)? } else { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_313] = unsafe { *(result.output.as_ptr() as *const [G; OUT_313]) }; __ret } } else { aiur_fn_313(__args, record, io_buffer, __cu)? } }; + let __r_arr: [G; OUT_309] = { let __args: [G; IN_309] = [__v_15, __v_4]; let __cu = unconstrained; if let Some(result) = record.function_queries[309].get_mut(&__args[..]) { if !__cu && *result.multiplicity == G::ZERO { aiur_fn_309(__args, record, io_buffer, false)? } else { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_309] = unsafe { *(result.output.as_ptr() as *const [G; OUT_309]) }; __ret } } else { aiur_fn_309(__args, record, io_buffer, __cu)? } }; let __v_16: G = __r_arr[0]; - let __ret: [G; OUT_313] = [__v_16]; - if let Some(result) = record.function_queries[313].get_mut(&inp[..]) { debug_assert_eq!(result.output, &__ret[..]); if !unconstrained { *result.multiplicity += G::ONE; } } else { record.function_queries[313].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained)); }; + let __ret: [G; OUT_309] = [__v_16]; + if let Some(result) = record.function_queries[309].get_mut(&inp[..]) { debug_assert_eq!(result.output, &__ret[..]); if !unconstrained { *result.multiplicity += G::ONE; } } else { record.function_queries[309].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained)); }; return Ok(__ret); }, } @@ -29842,15 +29568,15 @@ fn aiur_fn_313( }) } -const INPUT_SIZE_314: usize = 1; -const IN_314: usize = 1; -const OUT_314: usize = 1; -fn aiur_fn_314( - inp: [G; IN_314], +const INPUT_SIZE_310: usize = 1; +const IN_310: usize = 1; +const OUT_310: usize = 1; +fn aiur_fn_310( + inp: [G; IN_310], record: &mut QueryRecord, io_buffer: &mut IOBuffer, unconstrained: bool, -) -> Result<[G; OUT_314], ExecError> { +) -> Result<[G; OUT_310], ExecError> { stacker::maybe_grow(64 * 1024, 4 * 1024 * 1024, || { let __v_0: G = inp[0]; let __loaded: [G; 3] = { let __mq = record.memory_queries.get_mut(&3).ok_or(ExecError::InvalidMemorySize(3))?; let __ptr_u64 = __v_0.as_canonical_u64(); let __ptr_usize = usize::try_from(__ptr_u64).ok().ok_or(ExecError::PointerTooLarge(__ptr_u64))?; let (__args, __mult) = __mq.get_index_mut(__ptr_usize).ok_or(ExecError::UnboundPointer { ptr: __ptr_u64, size: 3 })?; if !unconstrained { *__mult += G::ONE; } let __arr: [G; 3] = __args[..3].try_into().unwrap(); __arr }; @@ -29859,8 +29585,8 @@ fn aiur_fn_314( let __v_3: G = __loaded[2]; match __v_1.as_canonical_u64() { 1u64 => { - let __ret: [G; OUT_314] = [__v_0]; - if let Some(result) = record.function_queries[314].get_mut(&inp[..]) { debug_assert_eq!(result.output, &__ret[..]); if !unconstrained { *result.multiplicity += G::ONE; } } else { record.function_queries[314].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained)); }; + let __ret: [G; OUT_310] = [__v_0]; + if let Some(result) = record.function_queries[310].get_mut(&inp[..]) { debug_assert_eq!(result.output, &__ret[..]); if !unconstrained { *result.multiplicity += G::ONE; } } else { record.function_queries[310].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained)); }; return Ok(__ret); }, 0u64 => { @@ -29878,15 +29604,15 @@ fn aiur_fn_314( let __v_9: G = __loaded[2]; match __v_7.as_canonical_u64() { 1u64 => { - let __r_arr: [G; OUT_314] = { let __args: [G; IN_314] = [__v_3]; let __cu = unconstrained; if let Some(result) = record.function_queries[314].get_mut(&__args[..]) { if !__cu && *result.multiplicity == G::ZERO { aiur_fn_314(__args, record, io_buffer, false)? } else { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_314] = unsafe { *(result.output.as_ptr() as *const [G; OUT_314]) }; __ret } } else { aiur_fn_314(__args, record, io_buffer, __cu)? } }; + let __r_arr: [G; OUT_310] = { let __args: [G; IN_310] = [__v_3]; let __cu = unconstrained; if let Some(result) = record.function_queries[310].get_mut(&__args[..]) { if !__cu && *result.multiplicity == G::ZERO { aiur_fn_310(__args, record, io_buffer, false)? } else { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_310] = unsafe { *(result.output.as_ptr() as *const [G; OUT_310]) }; __ret } } else { aiur_fn_310(__args, record, io_buffer, __cu)? } }; let __v_10: G = __r_arr[0]; - let __ret: [G; OUT_314] = [__v_10]; - if let Some(result) = record.function_queries[314].get_mut(&inp[..]) { debug_assert_eq!(result.output, &__ret[..]); if !unconstrained { *result.multiplicity += G::ONE; } } else { record.function_queries[314].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained)); }; + let __ret: [G; OUT_310] = [__v_10]; + if let Some(result) = record.function_queries[310].get_mut(&inp[..]) { debug_assert_eq!(result.output, &__ret[..]); if !unconstrained { *result.multiplicity += G::ONE; } } else { record.function_queries[310].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained)); }; return Ok(__ret); }, 0u64 => { - let __ret: [G; OUT_314] = [__v_0]; - if let Some(result) = record.function_queries[314].get_mut(&inp[..]) { debug_assert_eq!(result.output, &__ret[..]); if !unconstrained { *result.multiplicity += G::ONE; } } else { record.function_queries[314].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained)); }; + let __ret: [G; OUT_310] = [__v_0]; + if let Some(result) = record.function_queries[310].get_mut(&inp[..]) { debug_assert_eq!(result.output, &__ret[..]); if !unconstrained { *result.multiplicity += G::ONE; } } else { record.function_queries[310].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained)); }; return Ok(__ret); }, _ => { @@ -29895,8 +29621,8 @@ fn aiur_fn_314( } }, _ => { - let __ret: [G; OUT_314] = [__v_0]; - if let Some(result) = record.function_queries[314].get_mut(&inp[..]) { debug_assert_eq!(result.output, &__ret[..]); if !unconstrained { *result.multiplicity += G::ONE; } } else { record.function_queries[314].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained)); }; + let __ret: [G; OUT_310] = [__v_0]; + if let Some(result) = record.function_queries[310].get_mut(&inp[..]) { debug_assert_eq!(result.output, &__ret[..]); if !unconstrained { *result.multiplicity += G::ONE; } } else { record.function_queries[310].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained)); }; return Ok(__ret); }, } @@ -29910,21 +29636,21 @@ fn aiur_fn_314( }) } -const INPUT_SIZE_315: usize = 2; -const IN_315: usize = 2; -const OUT_315: usize = 1; -fn aiur_fn_315( - inp: [G; IN_315], +const INPUT_SIZE_311: usize = 2; +const IN_311: usize = 2; +const OUT_311: usize = 1; +fn aiur_fn_311( + inp: [G; IN_311], record: &mut QueryRecord, io_buffer: &mut IOBuffer, unconstrained: bool, -) -> Result<[G; OUT_315], ExecError> { +) -> Result<[G; OUT_311], ExecError> { stacker::maybe_grow(64 * 1024, 4 * 1024 * 1024, || { let __v_0: G = inp[0]; let __v_1: G = inp[1]; - let __r_arr: [G; OUT_314] = { let __args: [G; IN_314] = [__v_0]; let __cu = unconstrained; if let Some(result) = record.function_queries[314].get_mut(&__args[..]) { if !__cu && *result.multiplicity == G::ZERO { aiur_fn_314(__args, record, io_buffer, false)? } else { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_314] = unsafe { *(result.output.as_ptr() as *const [G; OUT_314]) }; __ret } } else { aiur_fn_314(__args, record, io_buffer, __cu)? } }; + let __r_arr: [G; OUT_310] = { let __args: [G; IN_310] = [__v_0]; let __cu = unconstrained; if let Some(result) = record.function_queries[310].get_mut(&__args[..]) { if !__cu && *result.multiplicity == G::ZERO { aiur_fn_310(__args, record, io_buffer, false)? } else { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_310] = unsafe { *(result.output.as_ptr() as *const [G; OUT_310]) }; __ret } } else { aiur_fn_310(__args, record, io_buffer, __cu)? } }; let __v_2: G = __r_arr[0]; - let __r_arr: [G; OUT_314] = { let __args: [G; IN_314] = [__v_1]; let __cu = unconstrained; if let Some(result) = record.function_queries[314].get_mut(&__args[..]) { if !__cu && *result.multiplicity == G::ZERO { aiur_fn_314(__args, record, io_buffer, false)? } else { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_314] = unsafe { *(result.output.as_ptr() as *const [G; OUT_314]) }; __ret } } else { aiur_fn_314(__args, record, io_buffer, __cu)? } }; + let __r_arr: [G; OUT_310] = { let __args: [G; IN_310] = [__v_1]; let __cu = unconstrained; if let Some(result) = record.function_queries[310].get_mut(&__args[..]) { if !__cu && *result.multiplicity == G::ZERO { aiur_fn_310(__args, record, io_buffer, false)? } else { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_310] = unsafe { *(result.output.as_ptr() as *const [G; OUT_310]) }; __ret } } else { aiur_fn_310(__args, record, io_buffer, __cu)? } }; let __v_3: G = __r_arr[0]; let __loaded: [G; 3] = { let __mq = record.memory_queries.get_mut(&3).ok_or(ExecError::InvalidMemorySize(3))?; let __ptr_u64 = __v_2.as_canonical_u64(); let __ptr_usize = usize::try_from(__ptr_u64).ok().ok_or(ExecError::PointerTooLarge(__ptr_u64))?; let (__args, __mult) = __mq.get_index_mut(__ptr_usize).ok_or(ExecError::UnboundPointer { ptr: __ptr_u64, size: 3 })?; if !unconstrained { *__mult += G::ONE; } let __arr: [G; 3] = __args[..3].try_into().unwrap(); __arr }; let __v_4: G = __loaded[0]; @@ -29939,14 +29665,14 @@ fn aiur_fn_315( match __v_7.as_canonical_u64() { 1u64 => { let __v_10: G = G::from_u64(1); - let __ret: [G; OUT_315] = [__v_10]; - if let Some(result) = record.function_queries[315].get_mut(&inp[..]) { debug_assert_eq!(result.output, &__ret[..]); if !unconstrained { *result.multiplicity += G::ONE; } } else { record.function_queries[315].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained)); }; + let __ret: [G; OUT_311] = [__v_10]; + if let Some(result) = record.function_queries[311].get_mut(&inp[..]) { debug_assert_eq!(result.output, &__ret[..]); if !unconstrained { *result.multiplicity += G::ONE; } } else { record.function_queries[311].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained)); }; return Ok(__ret); }, 0u64 => { let __v_10: G = G::from_u64(0); - let __ret: [G; OUT_315] = [__v_10]; - if let Some(result) = record.function_queries[315].get_mut(&inp[..]) { debug_assert_eq!(result.output, &__ret[..]); if !unconstrained { *result.multiplicity += G::ONE; } } else { record.function_queries[315].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained)); }; + let __ret: [G; OUT_311] = [__v_10]; + if let Some(result) = record.function_queries[311].get_mut(&inp[..]) { debug_assert_eq!(result.output, &__ret[..]); if !unconstrained { *result.multiplicity += G::ONE; } } else { record.function_queries[311].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained)); }; return Ok(__ret); }, _ => { @@ -29962,8 +29688,8 @@ fn aiur_fn_315( match __v_7.as_canonical_u64() { 1u64 => { let __v_10: G = G::from_u64(0); - let __ret: [G; OUT_315] = [__v_10]; - if let Some(result) = record.function_queries[315].get_mut(&inp[..]) { debug_assert_eq!(result.output, &__ret[..]); if !unconstrained { *result.multiplicity += G::ONE; } } else { record.function_queries[315].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained)); }; + let __ret: [G; OUT_311] = [__v_10]; + if let Some(result) = record.function_queries[311].get_mut(&inp[..]) { debug_assert_eq!(result.output, &__ret[..]); if !unconstrained { *result.multiplicity += G::ONE; } } else { record.function_queries[311].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained)); }; return Ok(__ret); }, 0u64 => { @@ -29979,27 +29705,27 @@ fn aiur_fn_315( let __v_15: G = __loaded[2]; match __v_13.as_canonical_u64() { _ => { - let __r_arr: [G; OUT_299] = { let __args: [G; IN_299] = [__v_10, __v_13]; let __cu = unconstrained; if let Some(result) = record.function_queries[299].get_mut(&__args[..]) { if !__cu && *result.multiplicity == G::ZERO { aiur_fn_299(__args, record, io_buffer, false)? } else { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_299] = unsafe { *(result.output.as_ptr() as *const [G; OUT_299]) }; __ret } } else { aiur_fn_299(__args, record, io_buffer, __cu)? } }; + let __r_arr: [G; OUT_295] = { let __args: [G; IN_295] = [__v_10, __v_13]; let __cu = unconstrained; if let Some(result) = record.function_queries[295].get_mut(&__args[..]) { if !__cu && *result.multiplicity == G::ZERO { aiur_fn_295(__args, record, io_buffer, false)? } else { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_295] = unsafe { *(result.output.as_ptr() as *const [G; OUT_295]) }; __ret } } else { aiur_fn_295(__args, record, io_buffer, __cu)? } }; let __v_16: G = __r_arr[0]; match __v_16.as_canonical_u64() { 0u64 => { let __v_17: G = (__v_11 - __v_14); match __v_17.as_canonical_u64() { 0u64 => { - let __r_arr: [G; OUT_304] = { let __args: [G; IN_304] = [__v_12, __v_15]; let __cu = unconstrained; if let Some(result) = record.function_queries[304].get_mut(&__args[..]) { if !__cu && *result.multiplicity == G::ZERO { aiur_fn_304(__args, record, io_buffer, false)? } else { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_304] = unsafe { *(result.output.as_ptr() as *const [G; OUT_304]) }; __ret } } else { aiur_fn_304(__args, record, io_buffer, __cu)? } }; + let __r_arr: [G; OUT_300] = { let __args: [G; IN_300] = [__v_12, __v_15]; let __cu = unconstrained; if let Some(result) = record.function_queries[300].get_mut(&__args[..]) { if !__cu && *result.multiplicity == G::ZERO { aiur_fn_300(__args, record, io_buffer, false)? } else { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_300] = unsafe { *(result.output.as_ptr() as *const [G; OUT_300]) }; __ret } } else { aiur_fn_300(__args, record, io_buffer, __cu)? } }; let __v_18: G = __r_arr[0]; match __v_18.as_canonical_u64() { 1u64 => { - let __r_arr: [G; OUT_315] = { let __args: [G; IN_315] = [__v_6, __v_9]; let __cu = unconstrained; if let Some(result) = record.function_queries[315].get_mut(&__args[..]) { if !__cu && *result.multiplicity == G::ZERO { aiur_fn_315(__args, record, io_buffer, false)? } else { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_315] = unsafe { *(result.output.as_ptr() as *const [G; OUT_315]) }; __ret } } else { aiur_fn_315(__args, record, io_buffer, __cu)? } }; + let __r_arr: [G; OUT_311] = { let __args: [G; IN_311] = [__v_6, __v_9]; let __cu = unconstrained; if let Some(result) = record.function_queries[311].get_mut(&__args[..]) { if !__cu && *result.multiplicity == G::ZERO { aiur_fn_311(__args, record, io_buffer, false)? } else { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_311] = unsafe { *(result.output.as_ptr() as *const [G; OUT_311]) }; __ret } } else { aiur_fn_311(__args, record, io_buffer, __cu)? } }; let __v_19: G = __r_arr[0]; - let __ret: [G; OUT_315] = [__v_19]; - if let Some(result) = record.function_queries[315].get_mut(&inp[..]) { debug_assert_eq!(result.output, &__ret[..]); if !unconstrained { *result.multiplicity += G::ONE; } } else { record.function_queries[315].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained)); }; + let __ret: [G; OUT_311] = [__v_19]; + if let Some(result) = record.function_queries[311].get_mut(&inp[..]) { debug_assert_eq!(result.output, &__ret[..]); if !unconstrained { *result.multiplicity += G::ONE; } } else { record.function_queries[311].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained)); }; return Ok(__ret); }, 0u64 => { let __v_19: G = G::from_u64(0); - let __ret: [G; OUT_315] = [__v_19]; - if let Some(result) = record.function_queries[315].get_mut(&inp[..]) { debug_assert_eq!(result.output, &__ret[..]); if !unconstrained { *result.multiplicity += G::ONE; } } else { record.function_queries[315].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained)); }; + let __ret: [G; OUT_311] = [__v_19]; + if let Some(result) = record.function_queries[311].get_mut(&inp[..]) { debug_assert_eq!(result.output, &__ret[..]); if !unconstrained { *result.multiplicity += G::ONE; } } else { record.function_queries[311].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained)); }; return Ok(__ret); }, _ => { @@ -30009,16 +29735,16 @@ fn aiur_fn_315( }, _ => { let __v_18: G = G::from_u64(0); - let __ret: [G; OUT_315] = [__v_18]; - if let Some(result) = record.function_queries[315].get_mut(&inp[..]) { debug_assert_eq!(result.output, &__ret[..]); if !unconstrained { *result.multiplicity += G::ONE; } } else { record.function_queries[315].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained)); }; + let __ret: [G; OUT_311] = [__v_18]; + if let Some(result) = record.function_queries[311].get_mut(&inp[..]) { debug_assert_eq!(result.output, &__ret[..]); if !unconstrained { *result.multiplicity += G::ONE; } } else { record.function_queries[311].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained)); }; return Ok(__ret); }, } }, _ => { let __v_17: G = G::from_u64(0); - let __ret: [G; OUT_315] = [__v_17]; - if let Some(result) = record.function_queries[315].get_mut(&inp[..]) { debug_assert_eq!(result.output, &__ret[..]); if !unconstrained { *result.multiplicity += G::ONE; } } else { record.function_queries[315].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained)); }; + let __ret: [G; OUT_311] = [__v_17]; + if let Some(result) = record.function_queries[311].get_mut(&inp[..]) { debug_assert_eq!(result.output, &__ret[..]); if !unconstrained { *result.multiplicity += G::ONE; } } else { record.function_queries[311].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained)); }; return Ok(__ret); }, } @@ -30039,15 +29765,15 @@ fn aiur_fn_315( }) } -const INPUT_SIZE_316: usize = 3; -const IN_316: usize = 3; -const OUT_316: usize = 1; -fn aiur_fn_316( - inp: [G; IN_316], +const INPUT_SIZE_312: usize = 3; +const IN_312: usize = 3; +const OUT_312: usize = 1; +fn aiur_fn_312( + inp: [G; IN_312], record: &mut QueryRecord, io_buffer: &mut IOBuffer, unconstrained: bool, -) -> Result<[G; OUT_316], ExecError> { +) -> Result<[G; OUT_312], ExecError> { stacker::maybe_grow(64 * 1024, 4 * 1024 * 1024, || { let __v_0: G = inp[0]; let __v_1: G = inp[1]; @@ -30059,8 +29785,8 @@ fn aiur_fn_316( match __v_3.as_canonical_u64() { 1u64 => { let __v_6: G = G::from_u64(0); - let __ret: [G; OUT_316] = [__v_6]; - if let Some(result) = record.function_queries[316].get_mut(&inp[..]) { debug_assert_eq!(result.output, &__ret[..]); if !unconstrained { *result.multiplicity += G::ONE; } } else { record.function_queries[316].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained)); }; + let __ret: [G; OUT_312] = [__v_6]; + if let Some(result) = record.function_queries[312].get_mut(&inp[..]) { debug_assert_eq!(result.output, &__ret[..]); if !unconstrained { *result.multiplicity += G::ONE; } } else { record.function_queries[312].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained)); }; return Ok(__ret); }, 0u64 => { @@ -30070,14 +29796,14 @@ fn aiur_fn_316( let __v_8: G = __loaded[2]; match __v_6.as_canonical_u64() { _ => { - let __r_arr: [G; OUT_300] = { let __args: [G; IN_300] = [__v_6, __v_1]; let __cu = unconstrained; if let Some(result) = record.function_queries[300].get_mut(&__args[..]) { if !__cu && *result.multiplicity == G::ZERO { aiur_fn_300(__args, record, io_buffer, false)? } else { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_300] = unsafe { *(result.output.as_ptr() as *const [G; OUT_300]) }; __ret } } else { aiur_fn_300(__args, record, io_buffer, __cu)? } }; + let __r_arr: [G; OUT_296] = { let __args: [G; IN_296] = [__v_6, __v_1]; let __cu = unconstrained; if let Some(result) = record.function_queries[296].get_mut(&__args[..]) { if !__cu && *result.multiplicity == G::ZERO { aiur_fn_296(__args, record, io_buffer, false)? } else { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_296] = unsafe { *(result.output.as_ptr() as *const [G; OUT_296]) }; __ret } } else { aiur_fn_296(__args, record, io_buffer, __cu)? } }; let __v_9: G = __r_arr[0]; match __v_9.as_canonical_u64() { 0u64 => { - let __r_arr: [G; OUT_316] = { let __args: [G; IN_316] = [__v_5, __v_1, __v_2]; let __cu = unconstrained; if let Some(result) = record.function_queries[316].get_mut(&__args[..]) { if !__cu && *result.multiplicity == G::ZERO { aiur_fn_316(__args, record, io_buffer, false)? } else { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_316] = unsafe { *(result.output.as_ptr() as *const [G; OUT_316]) }; __ret } } else { aiur_fn_316(__args, record, io_buffer, __cu)? } }; + let __r_arr: [G; OUT_312] = { let __args: [G; IN_312] = [__v_5, __v_1, __v_2]; let __cu = unconstrained; if let Some(result) = record.function_queries[312].get_mut(&__args[..]) { if !__cu && *result.multiplicity == G::ZERO { aiur_fn_312(__args, record, io_buffer, false)? } else { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_312] = unsafe { *(result.output.as_ptr() as *const [G; OUT_312]) }; __ret } } else { aiur_fn_312(__args, record, io_buffer, __cu)? } }; let __v_10: G = __r_arr[0]; - let __ret: [G; OUT_316] = [__v_10]; - if let Some(result) = record.function_queries[316].get_mut(&inp[..]) { debug_assert_eq!(result.output, &__ret[..]); if !unconstrained { *result.multiplicity += G::ONE; } } else { record.function_queries[316].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained)); }; + let __ret: [G; OUT_312] = [__v_10]; + if let Some(result) = record.function_queries[312].get_mut(&inp[..]) { debug_assert_eq!(result.output, &__ret[..]); if !unconstrained { *result.multiplicity += G::ONE; } } else { record.function_queries[312].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained)); }; return Ok(__ret); }, _ => { @@ -30088,7 +29814,7 @@ fn aiur_fn_316( break '__mc_0 [__v_11]; }, 1u64 => { - let __r_arr: [G; OUT_317] = { let __args: [G; IN_317] = [__v_8, __v_2]; let __cu = unconstrained; if let Some(result) = record.function_queries[317].get_mut(&__args[..]) { if !__cu && *result.multiplicity == G::ZERO { aiur_fn_317(__args, record, io_buffer, false)? } else { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_317] = unsafe { *(result.output.as_ptr() as *const [G; OUT_317]) }; __ret } } else { aiur_fn_317(__args, record, io_buffer, __cu)? } }; + let __r_arr: [G; OUT_313] = { let __args: [G; IN_313] = [__v_8, __v_2]; let __cu = unconstrained; if let Some(result) = record.function_queries[313].get_mut(&__args[..]) { if !__cu && *result.multiplicity == G::ZERO { aiur_fn_313(__args, record, io_buffer, false)? } else { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_313] = unsafe { *(result.output.as_ptr() as *const [G; OUT_313]) }; __ret } } else { aiur_fn_313(__args, record, io_buffer, __cu)? } }; let __v_11: G = __r_arr[0]; break '__mc_0 [__v_11]; }, @@ -30101,15 +29827,15 @@ fn aiur_fn_316( match __v_11.as_canonical_u64() { 1u64 => { let __v_12: G = G::from_u64(1); - let __ret: [G; OUT_316] = [__v_12]; - if let Some(result) = record.function_queries[316].get_mut(&inp[..]) { debug_assert_eq!(result.output, &__ret[..]); if !unconstrained { *result.multiplicity += G::ONE; } } else { record.function_queries[316].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained)); }; + let __ret: [G; OUT_312] = [__v_12]; + if let Some(result) = record.function_queries[312].get_mut(&inp[..]) { debug_assert_eq!(result.output, &__ret[..]); if !unconstrained { *result.multiplicity += G::ONE; } } else { record.function_queries[312].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained)); }; return Ok(__ret); }, 0u64 => { - let __r_arr: [G; OUT_316] = { let __args: [G; IN_316] = [__v_5, __v_1, __v_2]; let __cu = unconstrained; if let Some(result) = record.function_queries[316].get_mut(&__args[..]) { if !__cu && *result.multiplicity == G::ZERO { aiur_fn_316(__args, record, io_buffer, false)? } else { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_316] = unsafe { *(result.output.as_ptr() as *const [G; OUT_316]) }; __ret } } else { aiur_fn_316(__args, record, io_buffer, __cu)? } }; + let __r_arr: [G; OUT_312] = { let __args: [G; IN_312] = [__v_5, __v_1, __v_2]; let __cu = unconstrained; if let Some(result) = record.function_queries[312].get_mut(&__args[..]) { if !__cu && *result.multiplicity == G::ZERO { aiur_fn_312(__args, record, io_buffer, false)? } else { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_312] = unsafe { *(result.output.as_ptr() as *const [G; OUT_312]) }; __ret } } else { aiur_fn_312(__args, record, io_buffer, __cu)? } }; let __v_12: G = __r_arr[0]; - let __ret: [G; OUT_316] = [__v_12]; - if let Some(result) = record.function_queries[316].get_mut(&inp[..]) { debug_assert_eq!(result.output, &__ret[..]); if !unconstrained { *result.multiplicity += G::ONE; } } else { record.function_queries[316].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained)); }; + let __ret: [G; OUT_312] = [__v_12]; + if let Some(result) = record.function_queries[312].get_mut(&inp[..]) { debug_assert_eq!(result.output, &__ret[..]); if !unconstrained { *result.multiplicity += G::ONE; } } else { record.function_queries[312].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained)); }; return Ok(__ret); }, _ => { @@ -30128,15 +29854,15 @@ fn aiur_fn_316( }) } -const INPUT_SIZE_317: usize = 2; -const IN_317: usize = 2; -const OUT_317: usize = 1; -fn aiur_fn_317( - inp: [G; IN_317], +const INPUT_SIZE_313: usize = 2; +const IN_313: usize = 2; +const OUT_313: usize = 1; +fn aiur_fn_313( + inp: [G; IN_313], record: &mut QueryRecord, io_buffer: &mut IOBuffer, unconstrained: bool, -) -> Result<[G; OUT_317], ExecError> { +) -> Result<[G; OUT_313], ExecError> { stacker::maybe_grow(64 * 1024, 4 * 1024 * 1024, || { let __v_0: G = inp[0]; let __v_1: G = inp[1]; @@ -30147,8 +29873,8 @@ fn aiur_fn_317( match __v_2.as_canonical_u64() { 1u64 => { let __v_5: G = G::from_u64(0); - let __ret: [G; OUT_317] = [__v_5]; - if let Some(result) = record.function_queries[317].get_mut(&inp[..]) { debug_assert_eq!(result.output, &__ret[..]); if !unconstrained { *result.multiplicity += G::ONE; } } else { record.function_queries[317].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained)); }; + let __ret: [G; OUT_313] = [__v_5]; + if let Some(result) = record.function_queries[313].get_mut(&inp[..]) { debug_assert_eq!(result.output, &__ret[..]); if !unconstrained { *result.multiplicity += G::ONE; } } else { record.function_queries[313].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained)); }; return Ok(__ret); }, 0u64 => { @@ -30163,15 +29889,15 @@ fn aiur_fn_317( match __v_9.as_canonical_u64() { 0u64 => { let __v_10: G = G::from_u64(1); - let __ret: [G; OUT_317] = [__v_10]; - if let Some(result) = record.function_queries[317].get_mut(&inp[..]) { debug_assert_eq!(result.output, &__ret[..]); if !unconstrained { *result.multiplicity += G::ONE; } } else { record.function_queries[317].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained)); }; + let __ret: [G; OUT_313] = [__v_10]; + if let Some(result) = record.function_queries[313].get_mut(&inp[..]) { debug_assert_eq!(result.output, &__ret[..]); if !unconstrained { *result.multiplicity += G::ONE; } } else { record.function_queries[313].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained)); }; return Ok(__ret); }, 1u64 => { - let __r_arr: [G; OUT_317] = { let __args: [G; IN_317] = [__v_4, __v_1]; let __cu = unconstrained; if let Some(result) = record.function_queries[317].get_mut(&__args[..]) { if !__cu && *result.multiplicity == G::ZERO { aiur_fn_317(__args, record, io_buffer, false)? } else { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_317] = unsafe { *(result.output.as_ptr() as *const [G; OUT_317]) }; __ret } } else { aiur_fn_317(__args, record, io_buffer, __cu)? } }; + let __r_arr: [G; OUT_313] = { let __args: [G; IN_313] = [__v_4, __v_1]; let __cu = unconstrained; if let Some(result) = record.function_queries[313].get_mut(&__args[..]) { if !__cu && *result.multiplicity == G::ZERO { aiur_fn_313(__args, record, io_buffer, false)? } else { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_313] = unsafe { *(result.output.as_ptr() as *const [G; OUT_313]) }; __ret } } else { aiur_fn_313(__args, record, io_buffer, __cu)? } }; let __v_10: G = __r_arr[0]; - let __ret: [G; OUT_317] = [__v_10]; - if let Some(result) = record.function_queries[317].get_mut(&inp[..]) { debug_assert_eq!(result.output, &__ret[..]); if !unconstrained { *result.multiplicity += G::ONE; } } else { record.function_queries[317].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained)); }; + let __ret: [G; OUT_313] = [__v_10]; + if let Some(result) = record.function_queries[313].get_mut(&inp[..]) { debug_assert_eq!(result.output, &__ret[..]); if !unconstrained { *result.multiplicity += G::ONE; } } else { record.function_queries[313].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained)); }; return Ok(__ret); }, _ => { @@ -30188,15 +29914,15 @@ fn aiur_fn_317( }) } -const INPUT_SIZE_318: usize = 4; -const IN_318: usize = 4; -const OUT_318: usize = 1; -fn aiur_fn_318( - inp: [G; IN_318], +const INPUT_SIZE_314: usize = 4; +const IN_314: usize = 4; +const OUT_314: usize = 1; +fn aiur_fn_314( + inp: [G; IN_314], record: &mut QueryRecord, io_buffer: &mut IOBuffer, unconstrained: bool, -) -> Result<[G; OUT_318], ExecError> { +) -> Result<[G; OUT_314], ExecError> { stacker::maybe_grow(64 * 1024, 4 * 1024 * 1024, || { let __v_0: G = inp[0]; let __v_1: G = inp[1]; @@ -30209,8 +29935,8 @@ fn aiur_fn_318( match __v_4.as_canonical_u64() { 1u64 => { let __v_7: G = G::from_u64(0); - let __ret: [G; OUT_318] = [__v_7]; - if let Some(result) = record.function_queries[318].get_mut(&inp[..]) { debug_assert_eq!(result.output, &__ret[..]); if !unconstrained { *result.multiplicity += G::ONE; } } else { record.function_queries[318].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained)); }; + let __ret: [G; OUT_314] = [__v_7]; + if let Some(result) = record.function_queries[314].get_mut(&inp[..]) { debug_assert_eq!(result.output, &__ret[..]); if !unconstrained { *result.multiplicity += G::ONE; } } else { record.function_queries[314].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained)); }; return Ok(__ret); }, 0u64 => { @@ -30220,31 +29946,31 @@ fn aiur_fn_318( let __v_9: G = __loaded[2]; match __v_7.as_canonical_u64() { _ => { - let __r_arr: [G; OUT_300] = { let __args: [G; IN_300] = [__v_7, __v_1]; let __cu = unconstrained; if let Some(result) = record.function_queries[300].get_mut(&__args[..]) { if !__cu && *result.multiplicity == G::ZERO { aiur_fn_300(__args, record, io_buffer, false)? } else { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_300] = unsafe { *(result.output.as_ptr() as *const [G; OUT_300]) }; __ret } } else { aiur_fn_300(__args, record, io_buffer, __cu)? } }; + let __r_arr: [G; OUT_296] = { let __args: [G; IN_296] = [__v_7, __v_1]; let __cu = unconstrained; if let Some(result) = record.function_queries[296].get_mut(&__args[..]) { if !__cu && *result.multiplicity == G::ZERO { aiur_fn_296(__args, record, io_buffer, false)? } else { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_296] = unsafe { *(result.output.as_ptr() as *const [G; OUT_296]) }; __ret } } else { aiur_fn_296(__args, record, io_buffer, __cu)? } }; let __v_10: G = __r_arr[0]; match __v_10.as_canonical_u64() { 0u64 => { - let __r_arr: [G; OUT_318] = { let __args: [G; IN_318] = [__v_6, __v_1, __v_2, __v_3]; let __cu = unconstrained; if let Some(result) = record.function_queries[318].get_mut(&__args[..]) { if !__cu && *result.multiplicity == G::ZERO { aiur_fn_318(__args, record, io_buffer, false)? } else { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_318] = unsafe { *(result.output.as_ptr() as *const [G; OUT_318]) }; __ret } } else { aiur_fn_318(__args, record, io_buffer, __cu)? } }; + let __r_arr: [G; OUT_314] = { let __args: [G; IN_314] = [__v_6, __v_1, __v_2, __v_3]; let __cu = unconstrained; if let Some(result) = record.function_queries[314].get_mut(&__args[..]) { if !__cu && *result.multiplicity == G::ZERO { aiur_fn_314(__args, record, io_buffer, false)? } else { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_314] = unsafe { *(result.output.as_ptr() as *const [G; OUT_314]) }; __ret } } else { aiur_fn_314(__args, record, io_buffer, __cu)? } }; let __v_11: G = __r_arr[0]; - let __ret: [G; OUT_318] = [__v_11]; - if let Some(result) = record.function_queries[318].get_mut(&inp[..]) { debug_assert_eq!(result.output, &__ret[..]); if !unconstrained { *result.multiplicity += G::ONE; } } else { record.function_queries[318].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained)); }; + let __ret: [G; OUT_314] = [__v_11]; + if let Some(result) = record.function_queries[314].get_mut(&inp[..]) { debug_assert_eq!(result.output, &__ret[..]); if !unconstrained { *result.multiplicity += G::ONE; } } else { record.function_queries[314].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained)); }; return Ok(__ret); }, _ => { - let __r_arr: [G; OUT_319] = { let __args: [G; IN_319] = [__v_9, __v_2, __v_3]; let __cu = unconstrained; if let Some(result) = record.function_queries[319].get_mut(&__args[..]) { if !__cu && *result.multiplicity == G::ZERO { aiur_fn_319(__args, record, io_buffer, false)? } else { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_319] = unsafe { *(result.output.as_ptr() as *const [G; OUT_319]) }; __ret } } else { aiur_fn_319(__args, record, io_buffer, __cu)? } }; + let __r_arr: [G; OUT_315] = { let __args: [G; IN_315] = [__v_9, __v_2, __v_3]; let __cu = unconstrained; if let Some(result) = record.function_queries[315].get_mut(&__args[..]) { if !__cu && *result.multiplicity == G::ZERO { aiur_fn_315(__args, record, io_buffer, false)? } else { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_315] = unsafe { *(result.output.as_ptr() as *const [G; OUT_315]) }; __ret } } else { aiur_fn_315(__args, record, io_buffer, __cu)? } }; let __v_11: G = __r_arr[0]; match __v_11.as_canonical_u64() { 1u64 => { let __v_12: G = G::from_u64(1); - let __ret: [G; OUT_318] = [__v_12]; - if let Some(result) = record.function_queries[318].get_mut(&inp[..]) { debug_assert_eq!(result.output, &__ret[..]); if !unconstrained { *result.multiplicity += G::ONE; } } else { record.function_queries[318].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained)); }; + let __ret: [G; OUT_314] = [__v_12]; + if let Some(result) = record.function_queries[314].get_mut(&inp[..]) { debug_assert_eq!(result.output, &__ret[..]); if !unconstrained { *result.multiplicity += G::ONE; } } else { record.function_queries[314].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained)); }; return Ok(__ret); }, 0u64 => { - let __r_arr: [G; OUT_318] = { let __args: [G; IN_318] = [__v_6, __v_1, __v_2, __v_3]; let __cu = unconstrained; if let Some(result) = record.function_queries[318].get_mut(&__args[..]) { if !__cu && *result.multiplicity == G::ZERO { aiur_fn_318(__args, record, io_buffer, false)? } else { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_318] = unsafe { *(result.output.as_ptr() as *const [G; OUT_318]) }; __ret } } else { aiur_fn_318(__args, record, io_buffer, __cu)? } }; + let __r_arr: [G; OUT_314] = { let __args: [G; IN_314] = [__v_6, __v_1, __v_2, __v_3]; let __cu = unconstrained; if let Some(result) = record.function_queries[314].get_mut(&__args[..]) { if !__cu && *result.multiplicity == G::ZERO { aiur_fn_314(__args, record, io_buffer, false)? } else { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_314] = unsafe { *(result.output.as_ptr() as *const [G; OUT_314]) }; __ret } } else { aiur_fn_314(__args, record, io_buffer, __cu)? } }; let __v_12: G = __r_arr[0]; - let __ret: [G; OUT_318] = [__v_12]; - if let Some(result) = record.function_queries[318].get_mut(&inp[..]) { debug_assert_eq!(result.output, &__ret[..]); if !unconstrained { *result.multiplicity += G::ONE; } } else { record.function_queries[318].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained)); }; + let __ret: [G; OUT_314] = [__v_12]; + if let Some(result) = record.function_queries[314].get_mut(&inp[..]) { debug_assert_eq!(result.output, &__ret[..]); if !unconstrained { *result.multiplicity += G::ONE; } } else { record.function_queries[314].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained)); }; return Ok(__ret); }, _ => { @@ -30263,15 +29989,15 @@ fn aiur_fn_318( }) } -const INPUT_SIZE_319: usize = 3; -const IN_319: usize = 3; -const OUT_319: usize = 1; -fn aiur_fn_319( - inp: [G; IN_319], +const INPUT_SIZE_315: usize = 3; +const IN_315: usize = 3; +const OUT_315: usize = 1; +fn aiur_fn_315( + inp: [G; IN_315], record: &mut QueryRecord, io_buffer: &mut IOBuffer, unconstrained: bool, -) -> Result<[G; OUT_319], ExecError> { +) -> Result<[G; OUT_315], ExecError> { stacker::maybe_grow(64 * 1024, 4 * 1024 * 1024, || { let __v_0: G = inp[0]; let __v_1: G = inp[1]; @@ -30283,8 +30009,8 @@ fn aiur_fn_319( match __v_3.as_canonical_u64() { 1u64 => { let __v_6: G = G::from_u64(0); - let __ret: [G; OUT_319] = [__v_6]; - if let Some(result) = record.function_queries[319].get_mut(&inp[..]) { debug_assert_eq!(result.output, &__ret[..]); if !unconstrained { *result.multiplicity += G::ONE; } } else { record.function_queries[319].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained)); }; + let __ret: [G; OUT_315] = [__v_6]; + if let Some(result) = record.function_queries[315].get_mut(&inp[..]) { debug_assert_eq!(result.output, &__ret[..]); if !unconstrained { *result.multiplicity += G::ONE; } } else { record.function_queries[315].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained)); }; return Ok(__ret); }, 0u64 => { @@ -30300,15 +30026,15 @@ fn aiur_fn_319( match __v_9.as_canonical_u64() { 0u64 => { let __v_10: G = G::from_u64(1); - let __ret: [G; OUT_319] = [__v_10]; - if let Some(result) = record.function_queries[319].get_mut(&inp[..]) { debug_assert_eq!(result.output, &__ret[..]); if !unconstrained { *result.multiplicity += G::ONE; } } else { record.function_queries[319].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained)); }; + let __ret: [G; OUT_315] = [__v_10]; + if let Some(result) = record.function_queries[315].get_mut(&inp[..]) { debug_assert_eq!(result.output, &__ret[..]); if !unconstrained { *result.multiplicity += G::ONE; } } else { record.function_queries[315].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained)); }; return Ok(__ret); }, 1u64 => { - let __r_arr: [G; OUT_319] = { let __args: [G; IN_319] = [__v_5, __v_1, __v_2]; let __cu = unconstrained; if let Some(result) = record.function_queries[319].get_mut(&__args[..]) { if !__cu && *result.multiplicity == G::ZERO { aiur_fn_319(__args, record, io_buffer, false)? } else { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_319] = unsafe { *(result.output.as_ptr() as *const [G; OUT_319]) }; __ret } } else { aiur_fn_319(__args, record, io_buffer, __cu)? } }; + let __r_arr: [G; OUT_315] = { let __args: [G; IN_315] = [__v_5, __v_1, __v_2]; let __cu = unconstrained; if let Some(result) = record.function_queries[315].get_mut(&__args[..]) { if !__cu && *result.multiplicity == G::ZERO { aiur_fn_315(__args, record, io_buffer, false)? } else { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_315] = unsafe { *(result.output.as_ptr() as *const [G; OUT_315]) }; __ret } } else { aiur_fn_315(__args, record, io_buffer, __cu)? } }; let __v_10: G = __r_arr[0]; - let __ret: [G; OUT_319] = [__v_10]; - if let Some(result) = record.function_queries[319].get_mut(&inp[..]) { debug_assert_eq!(result.output, &__ret[..]); if !unconstrained { *result.multiplicity += G::ONE; } } else { record.function_queries[319].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained)); }; + let __ret: [G; OUT_315] = [__v_10]; + if let Some(result) = record.function_queries[315].get_mut(&inp[..]) { debug_assert_eq!(result.output, &__ret[..]); if !unconstrained { *result.multiplicity += G::ONE; } } else { record.function_queries[315].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained)); }; return Ok(__ret); }, _ => { @@ -30317,10 +30043,10 @@ fn aiur_fn_319( } }, _ => { - let __r_arr: [G; OUT_319] = { let __args: [G; IN_319] = [__v_5, __v_1, __v_2]; let __cu = unconstrained; if let Some(result) = record.function_queries[319].get_mut(&__args[..]) { if !__cu && *result.multiplicity == G::ZERO { aiur_fn_319(__args, record, io_buffer, false)? } else { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_319] = unsafe { *(result.output.as_ptr() as *const [G; OUT_319]) }; __ret } } else { aiur_fn_319(__args, record, io_buffer, __cu)? } }; + let __r_arr: [G; OUT_315] = { let __args: [G; IN_315] = [__v_5, __v_1, __v_2]; let __cu = unconstrained; if let Some(result) = record.function_queries[315].get_mut(&__args[..]) { if !__cu && *result.multiplicity == G::ZERO { aiur_fn_315(__args, record, io_buffer, false)? } else { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_315] = unsafe { *(result.output.as_ptr() as *const [G; OUT_315]) }; __ret } } else { aiur_fn_315(__args, record, io_buffer, __cu)? } }; let __v_9: G = __r_arr[0]; - let __ret: [G; OUT_319] = [__v_9]; - if let Some(result) = record.function_queries[319].get_mut(&inp[..]) { debug_assert_eq!(result.output, &__ret[..]); if !unconstrained { *result.multiplicity += G::ONE; } } else { record.function_queries[319].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained)); }; + let __ret: [G; OUT_315] = [__v_9]; + if let Some(result) = record.function_queries[315].get_mut(&inp[..]) { debug_assert_eq!(result.output, &__ret[..]); if !unconstrained { *result.multiplicity += G::ONE; } } else { record.function_queries[315].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained)); }; return Ok(__ret); }, } @@ -30334,15 +30060,15 @@ fn aiur_fn_319( }) } -const INPUT_SIZE_320: usize = 2; -const IN_320: usize = 2; -const OUT_320: usize = 1; -fn aiur_fn_320( - inp: [G; IN_320], +const INPUT_SIZE_316: usize = 2; +const IN_316: usize = 2; +const OUT_316: usize = 1; +fn aiur_fn_316( + inp: [G; IN_316], record: &mut QueryRecord, io_buffer: &mut IOBuffer, unconstrained: bool, -) -> Result<[G; OUT_320], ExecError> { +) -> Result<[G; OUT_316], ExecError> { stacker::maybe_grow(64 * 1024, 4 * 1024 * 1024, || { let __v_0: G = inp[0]; let __v_1: G = inp[1]; @@ -30353,8 +30079,8 @@ fn aiur_fn_320( match __v_2.as_canonical_u64() { 1u64 => { let __v_5: G = G::from_u64(1); - let __ret: [G; OUT_320] = [__v_5]; - if let Some(result) = record.function_queries[320].get_mut(&inp[..]) { debug_assert_eq!(result.output, &__ret[..]); if !unconstrained { *result.multiplicity += G::ONE; } } else { record.function_queries[320].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained)); }; + let __ret: [G; OUT_316] = [__v_5]; + if let Some(result) = record.function_queries[316].get_mut(&inp[..]) { debug_assert_eq!(result.output, &__ret[..]); if !unconstrained { *result.multiplicity += G::ONE; } } else { record.function_queries[316].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained)); }; return Ok(__ret); }, 0u64 => { @@ -30370,7 +30096,7 @@ fn aiur_fn_320( break '__mc_0 [__v_8]; }, _ => { - let __r_arr: [G; OUT_316] = { let __args: [G; IN_316] = [__v_1, __v_5, __v_6]; let __cu = unconstrained; if let Some(result) = record.function_queries[316].get_mut(&__args[..]) { if !__cu && *result.multiplicity == G::ZERO { aiur_fn_316(__args, record, io_buffer, false)? } else { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_316] = unsafe { *(result.output.as_ptr() as *const [G; OUT_316]) }; __ret } } else { aiur_fn_316(__args, record, io_buffer, __cu)? } }; + let __r_arr: [G; OUT_312] = { let __args: [G; IN_312] = [__v_1, __v_5, __v_6]; let __cu = unconstrained; if let Some(result) = record.function_queries[312].get_mut(&__args[..]) { if !__cu && *result.multiplicity == G::ZERO { aiur_fn_312(__args, record, io_buffer, false)? } else { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_312] = unsafe { *(result.output.as_ptr() as *const [G; OUT_312]) }; __ret } } else { aiur_fn_312(__args, record, io_buffer, __cu)? } }; let __v_8: G = __r_arr[0]; break '__mc_0 [__v_8]; }, @@ -30380,25 +30106,25 @@ fn aiur_fn_320( match __v_8.as_canonical_u64() { 0u64 => { let __v_9: G = G::from_u64(0); - let __ret: [G; OUT_320] = [__v_9]; - if let Some(result) = record.function_queries[320].get_mut(&inp[..]) { debug_assert_eq!(result.output, &__ret[..]); if !unconstrained { *result.multiplicity += G::ONE; } } else { record.function_queries[320].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained)); }; + let __ret: [G; OUT_316] = [__v_9]; + if let Some(result) = record.function_queries[316].get_mut(&inp[..]) { debug_assert_eq!(result.output, &__ret[..]); if !unconstrained { *result.multiplicity += G::ONE; } } else { record.function_queries[316].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained)); }; return Ok(__ret); }, 1u64 => { - let __r_arr: [G; OUT_321] = { let __args: [G; IN_321] = [__v_7, __v_1, __v_5]; let __cu = unconstrained; if let Some(result) = record.function_queries[321].get_mut(&__args[..]) { if !__cu && *result.multiplicity == G::ZERO { aiur_fn_321(__args, record, io_buffer, false)? } else { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_321] = unsafe { *(result.output.as_ptr() as *const [G; OUT_321]) }; __ret } } else { aiur_fn_321(__args, record, io_buffer, __cu)? } }; + let __r_arr: [G; OUT_317] = { let __args: [G; IN_317] = [__v_7, __v_1, __v_5]; let __cu = unconstrained; if let Some(result) = record.function_queries[317].get_mut(&__args[..]) { if !__cu && *result.multiplicity == G::ZERO { aiur_fn_317(__args, record, io_buffer, false)? } else { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_317] = unsafe { *(result.output.as_ptr() as *const [G; OUT_317]) }; __ret } } else { aiur_fn_317(__args, record, io_buffer, __cu)? } }; let __v_9: G = __r_arr[0]; match __v_9.as_canonical_u64() { 0u64 => { let __v_10: G = G::from_u64(0); - let __ret: [G; OUT_320] = [__v_10]; - if let Some(result) = record.function_queries[320].get_mut(&inp[..]) { debug_assert_eq!(result.output, &__ret[..]); if !unconstrained { *result.multiplicity += G::ONE; } } else { record.function_queries[320].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained)); }; + let __ret: [G; OUT_316] = [__v_10]; + if let Some(result) = record.function_queries[316].get_mut(&inp[..]) { debug_assert_eq!(result.output, &__ret[..]); if !unconstrained { *result.multiplicity += G::ONE; } } else { record.function_queries[316].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained)); }; return Ok(__ret); }, 1u64 => { - let __r_arr: [G; OUT_320] = { let __args: [G; IN_320] = [__v_4, __v_1]; let __cu = unconstrained; if let Some(result) = record.function_queries[320].get_mut(&__args[..]) { if !__cu && *result.multiplicity == G::ZERO { aiur_fn_320(__args, record, io_buffer, false)? } else { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_320] = unsafe { *(result.output.as_ptr() as *const [G; OUT_320]) }; __ret } } else { aiur_fn_320(__args, record, io_buffer, __cu)? } }; + let __r_arr: [G; OUT_316] = { let __args: [G; IN_316] = [__v_4, __v_1]; let __cu = unconstrained; if let Some(result) = record.function_queries[316].get_mut(&__args[..]) { if !__cu && *result.multiplicity == G::ZERO { aiur_fn_316(__args, record, io_buffer, false)? } else { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_316] = unsafe { *(result.output.as_ptr() as *const [G; OUT_316]) }; __ret } } else { aiur_fn_316(__args, record, io_buffer, __cu)? } }; let __v_10: G = __r_arr[0]; - let __ret: [G; OUT_320] = [__v_10]; - if let Some(result) = record.function_queries[320].get_mut(&inp[..]) { debug_assert_eq!(result.output, &__ret[..]); if !unconstrained { *result.multiplicity += G::ONE; } } else { record.function_queries[320].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained)); }; + let __ret: [G; OUT_316] = [__v_10]; + if let Some(result) = record.function_queries[316].get_mut(&inp[..]) { debug_assert_eq!(result.output, &__ret[..]); if !unconstrained { *result.multiplicity += G::ONE; } } else { record.function_queries[316].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained)); }; return Ok(__ret); }, _ => { @@ -30420,15 +30146,15 @@ fn aiur_fn_320( }) } -const INPUT_SIZE_321: usize = 3; -const IN_321: usize = 3; -const OUT_321: usize = 1; -fn aiur_fn_321( - inp: [G; IN_321], +const INPUT_SIZE_317: usize = 3; +const IN_317: usize = 3; +const OUT_317: usize = 1; +fn aiur_fn_317( + inp: [G; IN_317], record: &mut QueryRecord, io_buffer: &mut IOBuffer, unconstrained: bool, -) -> Result<[G; OUT_321], ExecError> { +) -> Result<[G; OUT_317], ExecError> { stacker::maybe_grow(64 * 1024, 4 * 1024 * 1024, || { let __v_0: G = inp[0]; let __v_1: G = inp[1]; @@ -30440,8 +30166,8 @@ fn aiur_fn_321( match __v_3.as_canonical_u64() { 1u64 => { let __v_6: G = G::from_u64(1); - let __ret: [G; OUT_321] = [__v_6]; - if let Some(result) = record.function_queries[321].get_mut(&inp[..]) { debug_assert_eq!(result.output, &__ret[..]); if !unconstrained { *result.multiplicity += G::ONE; } } else { record.function_queries[321].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained)); }; + let __ret: [G; OUT_317] = [__v_6]; + if let Some(result) = record.function_queries[317].get_mut(&inp[..]) { debug_assert_eq!(result.output, &__ret[..]); if !unconstrained { *result.multiplicity += G::ONE; } } else { record.function_queries[317].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained)); }; return Ok(__ret); }, 0u64 => { @@ -30450,20 +30176,20 @@ fn aiur_fn_321( let __v_7: G = __loaded[1]; match __v_6.as_canonical_u64() { _ => { - let __r_arr: [G; OUT_318] = { let __args: [G; IN_318] = [__v_1, __v_2, __v_6, __v_7]; let __cu = unconstrained; if let Some(result) = record.function_queries[318].get_mut(&__args[..]) { if !__cu && *result.multiplicity == G::ZERO { aiur_fn_318(__args, record, io_buffer, false)? } else { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_318] = unsafe { *(result.output.as_ptr() as *const [G; OUT_318]) }; __ret } } else { aiur_fn_318(__args, record, io_buffer, __cu)? } }; + let __r_arr: [G; OUT_314] = { let __args: [G; IN_314] = [__v_1, __v_2, __v_6, __v_7]; let __cu = unconstrained; if let Some(result) = record.function_queries[314].get_mut(&__args[..]) { if !__cu && *result.multiplicity == G::ZERO { aiur_fn_314(__args, record, io_buffer, false)? } else { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_314] = unsafe { *(result.output.as_ptr() as *const [G; OUT_314]) }; __ret } } else { aiur_fn_314(__args, record, io_buffer, __cu)? } }; let __v_8: G = __r_arr[0]; match __v_8.as_canonical_u64() { 0u64 => { let __v_9: G = G::from_u64(0); - let __ret: [G; OUT_321] = [__v_9]; - if let Some(result) = record.function_queries[321].get_mut(&inp[..]) { debug_assert_eq!(result.output, &__ret[..]); if !unconstrained { *result.multiplicity += G::ONE; } } else { record.function_queries[321].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained)); }; + let __ret: [G; OUT_317] = [__v_9]; + if let Some(result) = record.function_queries[317].get_mut(&inp[..]) { debug_assert_eq!(result.output, &__ret[..]); if !unconstrained { *result.multiplicity += G::ONE; } } else { record.function_queries[317].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained)); }; return Ok(__ret); }, 1u64 => { - let __r_arr: [G; OUT_321] = { let __args: [G; IN_321] = [__v_5, __v_1, __v_2]; let __cu = unconstrained; if let Some(result) = record.function_queries[321].get_mut(&__args[..]) { if !__cu && *result.multiplicity == G::ZERO { aiur_fn_321(__args, record, io_buffer, false)? } else { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_321] = unsafe { *(result.output.as_ptr() as *const [G; OUT_321]) }; __ret } } else { aiur_fn_321(__args, record, io_buffer, __cu)? } }; + let __r_arr: [G; OUT_317] = { let __args: [G; IN_317] = [__v_5, __v_1, __v_2]; let __cu = unconstrained; if let Some(result) = record.function_queries[317].get_mut(&__args[..]) { if !__cu && *result.multiplicity == G::ZERO { aiur_fn_317(__args, record, io_buffer, false)? } else { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_317] = unsafe { *(result.output.as_ptr() as *const [G; OUT_317]) }; __ret } } else { aiur_fn_317(__args, record, io_buffer, __cu)? } }; let __v_9: G = __r_arr[0]; - let __ret: [G; OUT_321] = [__v_9]; - if let Some(result) = record.function_queries[321].get_mut(&inp[..]) { debug_assert_eq!(result.output, &__ret[..]); if !unconstrained { *result.multiplicity += G::ONE; } } else { record.function_queries[321].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained)); }; + let __ret: [G; OUT_317] = [__v_9]; + if let Some(result) = record.function_queries[317].get_mut(&inp[..]) { debug_assert_eq!(result.output, &__ret[..]); if !unconstrained { *result.multiplicity += G::ONE; } } else { record.function_queries[317].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained)); }; return Ok(__ret); }, _ => { @@ -30480,15 +30206,15 @@ fn aiur_fn_321( }) } -const INPUT_SIZE_322: usize = 1; -const IN_322: usize = 1; -const OUT_322: usize = 1; -fn aiur_fn_322( - inp: [G; IN_322], +const INPUT_SIZE_318: usize = 1; +const IN_318: usize = 1; +const OUT_318: usize = 1; +fn aiur_fn_318( + inp: [G; IN_318], record: &mut QueryRecord, io_buffer: &mut IOBuffer, unconstrained: bool, -) -> Result<[G; OUT_322], ExecError> { +) -> Result<[G; OUT_318], ExecError> { stacker::maybe_grow(64 * 1024, 4 * 1024 * 1024, || { let __v_0: G = inp[0]; let __v_1: G = G::from_u64(0); @@ -30508,35 +30234,35 @@ fn aiur_fn_322( let __v_15: G = G::from_u64(1); let __v_16: G = { let __values: [G; 3] = [__v_14, __v_15, __v_15]; let __mq = record.memory_queries.get_mut(&3).ok_or(ExecError::InvalidMemorySize(3))?; if let Some(result) = __mq.get_mut(&__values[..]) { if !unconstrained { *result.multiplicity += G::ONE; } result.output[0] } else { let __ptr = G::from_usize(__mq.len()); __mq.insert(&__values[..], &[__ptr], G::from_bool(!unconstrained)); __ptr } }; let __v_17: G = G::from_u64(0); - let __r_arr: [G; OUT_310] = { let __args: [G; IN_310] = [__v_0, __v_16, __v_17, __v_13]; let __cu = unconstrained; if let Some(result) = record.function_queries[310].get_mut(&__args[..]) { if !__cu && *result.multiplicity == G::ZERO { aiur_fn_310(__args, record, io_buffer, false)? } else { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_310] = unsafe { *(result.output.as_ptr() as *const [G; OUT_310]) }; __ret } } else { aiur_fn_310(__args, record, io_buffer, __cu)? } }; + let __r_arr: [G; OUT_306] = { let __args: [G; IN_306] = [__v_0, __v_16, __v_17, __v_13]; let __cu = unconstrained; if let Some(result) = record.function_queries[306].get_mut(&__args[..]) { if !__cu && *result.multiplicity == G::ZERO { aiur_fn_306(__args, record, io_buffer, false)? } else { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_306] = unsafe { *(result.output.as_ptr() as *const [G; OUT_306]) }; __ret } } else { aiur_fn_306(__args, record, io_buffer, __cu)? } }; let __v_18: G = __r_arr[0]; - let __r_arr: [G; OUT_312] = { let __args: [G; IN_312] = [__v_18, __v_18]; let __cu = unconstrained; if let Some(result) = record.function_queries[312].get_mut(&__args[..]) { if !__cu && *result.multiplicity == G::ZERO { aiur_fn_312(__args, record, io_buffer, false)? } else { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_312] = unsafe { *(result.output.as_ptr() as *const [G; OUT_312]) }; __ret } } else { aiur_fn_312(__args, record, io_buffer, __cu)? } }; + let __r_arr: [G; OUT_308] = { let __args: [G; IN_308] = [__v_18, __v_18]; let __cu = unconstrained; if let Some(result) = record.function_queries[308].get_mut(&__args[..]) { if !__cu && *result.multiplicity == G::ZERO { aiur_fn_308(__args, record, io_buffer, false)? } else { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_308] = unsafe { *(result.output.as_ptr() as *const [G; OUT_308]) }; __ret } } else { aiur_fn_308(__args, record, io_buffer, __cu)? } }; let __v_19: G = __r_arr[0]; - let __ret: [G; OUT_322] = [__v_19]; - if let Some(result) = record.function_queries[322].get_mut(&inp[..]) { debug_assert_eq!(result.output, &__ret[..]); if !unconstrained { *result.multiplicity += G::ONE; } } else { record.function_queries[322].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained)); }; + let __ret: [G; OUT_318] = [__v_19]; + if let Some(result) = record.function_queries[318].get_mut(&inp[..]) { debug_assert_eq!(result.output, &__ret[..]); if !unconstrained { *result.multiplicity += G::ONE; } } else { record.function_queries[318].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained)); }; return Ok(__ret); }) } -const INPUT_SIZE_323: usize = 2; -const IN_323: usize = 2; -const OUT_323: usize = 1; -fn aiur_fn_323( - inp: [G; IN_323], +const INPUT_SIZE_319: usize = 2; +const IN_319: usize = 2; +const OUT_319: usize = 1; +fn aiur_fn_319( + inp: [G; IN_319], record: &mut QueryRecord, io_buffer: &mut IOBuffer, unconstrained: bool, -) -> Result<[G; OUT_323], ExecError> { +) -> Result<[G; OUT_319], ExecError> { stacker::maybe_grow(64 * 1024, 4 * 1024 * 1024, || { let __v_0: G = inp[0]; let __v_1: G = inp[1]; - let __r_arr: [G; OUT_298] = { let __args: [G; IN_298] = [__v_0, __v_1]; let __cu = unconstrained; if let Some(result) = record.function_queries[298].get_mut(&__args[..]) { if !__cu && *result.multiplicity == G::ZERO { aiur_fn_298(__args, record, io_buffer, false)? } else { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_298] = unsafe { *(result.output.as_ptr() as *const [G; OUT_298]) }; __ret } } else { aiur_fn_298(__args, record, io_buffer, __cu)? } }; + let __r_arr: [G; OUT_294] = { let __args: [G; IN_294] = [__v_0, __v_1]; let __cu = unconstrained; if let Some(result) = record.function_queries[294].get_mut(&__args[..]) { if !__cu && *result.multiplicity == G::ZERO { aiur_fn_294(__args, record, io_buffer, false)? } else { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_294] = unsafe { *(result.output.as_ptr() as *const [G; OUT_294]) }; __ret } } else { aiur_fn_294(__args, record, io_buffer, __cu)? } }; let __v_2: G = __r_arr[0]; match __v_2.as_canonical_u64() { 1u64 => { let __v_3: G = G::from_u64(1); - let __ret: [G; OUT_323] = [__v_3]; - if let Some(result) = record.function_queries[323].get_mut(&inp[..]) { debug_assert_eq!(result.output, &__ret[..]); if !unconstrained { *result.multiplicity += G::ONE; } } else { record.function_queries[323].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained)); }; + let __ret: [G; OUT_319] = [__v_3]; + if let Some(result) = record.function_queries[319].get_mut(&inp[..]) { debug_assert_eq!(result.output, &__ret[..]); if !unconstrained { *result.multiplicity += G::ONE; } } else { record.function_queries[319].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained)); }; return Ok(__ret); }, 0u64 => { @@ -30547,19 +30273,19 @@ fn aiur_fn_323( match __v_3.as_canonical_u64() { 0u64 => { let __v_6: G = G::from_u64(1); - let __ret: [G; OUT_323] = [__v_6]; - if let Some(result) = record.function_queries[323].get_mut(&inp[..]) { debug_assert_eq!(result.output, &__ret[..]); if !unconstrained { *result.multiplicity += G::ONE; } } else { record.function_queries[323].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained)); }; + let __ret: [G; OUT_319] = [__v_6]; + if let Some(result) = record.function_queries[319].get_mut(&inp[..]) { debug_assert_eq!(result.output, &__ret[..]); if !unconstrained { *result.multiplicity += G::ONE; } } else { record.function_queries[319].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained)); }; return Ok(__ret); }, _ => { - let __r_arr: [G; OUT_322] = { let __args: [G; IN_322] = [__v_0]; let __cu = unconstrained; if let Some(result) = record.function_queries[322].get_mut(&__args[..]) { if !__cu && *result.multiplicity == G::ZERO { aiur_fn_322(__args, record, io_buffer, false)? } else { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_322] = unsafe { *(result.output.as_ptr() as *const [G; OUT_322]) }; __ret } } else { aiur_fn_322(__args, record, io_buffer, __cu)? } }; + let __r_arr: [G; OUT_318] = { let __args: [G; IN_318] = [__v_0]; let __cu = unconstrained; if let Some(result) = record.function_queries[318].get_mut(&__args[..]) { if !__cu && *result.multiplicity == G::ZERO { aiur_fn_318(__args, record, io_buffer, false)? } else { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_318] = unsafe { *(result.output.as_ptr() as *const [G; OUT_318]) }; __ret } } else { aiur_fn_318(__args, record, io_buffer, __cu)? } }; let __v_6: G = __r_arr[0]; - let __r_arr: [G; OUT_322] = { let __args: [G; IN_322] = [__v_1]; let __cu = unconstrained; if let Some(result) = record.function_queries[322].get_mut(&__args[..]) { if !__cu && *result.multiplicity == G::ZERO { aiur_fn_322(__args, record, io_buffer, false)? } else { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_322] = unsafe { *(result.output.as_ptr() as *const [G; OUT_322]) }; __ret } } else { aiur_fn_322(__args, record, io_buffer, __cu)? } }; + let __r_arr: [G; OUT_318] = { let __args: [G; IN_318] = [__v_1]; let __cu = unconstrained; if let Some(result) = record.function_queries[318].get_mut(&__args[..]) { if !__cu && *result.multiplicity == G::ZERO { aiur_fn_318(__args, record, io_buffer, false)? } else { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_318] = unsafe { *(result.output.as_ptr() as *const [G; OUT_318]) }; __ret } } else { aiur_fn_318(__args, record, io_buffer, __cu)? } }; let __v_7: G = __r_arr[0]; - let __r_arr: [G; OUT_320] = { let __args: [G; IN_320] = [__v_6, __v_7]; let __cu = unconstrained; if let Some(result) = record.function_queries[320].get_mut(&__args[..]) { if !__cu && *result.multiplicity == G::ZERO { aiur_fn_320(__args, record, io_buffer, false)? } else { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_320] = unsafe { *(result.output.as_ptr() as *const [G; OUT_320]) }; __ret } } else { aiur_fn_320(__args, record, io_buffer, __cu)? } }; + let __r_arr: [G; OUT_316] = { let __args: [G; IN_316] = [__v_6, __v_7]; let __cu = unconstrained; if let Some(result) = record.function_queries[316].get_mut(&__args[..]) { if !__cu && *result.multiplicity == G::ZERO { aiur_fn_316(__args, record, io_buffer, false)? } else { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_316] = unsafe { *(result.output.as_ptr() as *const [G; OUT_316]) }; __ret } } else { aiur_fn_316(__args, record, io_buffer, __cu)? } }; let __v_8: G = __r_arr[0]; - let __ret: [G; OUT_323] = [__v_8]; - if let Some(result) = record.function_queries[323].get_mut(&inp[..]) { debug_assert_eq!(result.output, &__ret[..]); if !unconstrained { *result.multiplicity += G::ONE; } } else { record.function_queries[323].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained)); }; + let __ret: [G; OUT_319] = [__v_8]; + if let Some(result) = record.function_queries[319].get_mut(&inp[..]) { debug_assert_eq!(result.output, &__ret[..]); if !unconstrained { *result.multiplicity += G::ONE; } } else { record.function_queries[319].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained)); }; return Ok(__ret); }, } @@ -30571,36 +30297,36 @@ fn aiur_fn_323( }) } -const INPUT_SIZE_324: usize = 2; -const IN_324: usize = 2; -const OUT_324: usize = 1; -fn aiur_fn_324( - inp: [G; IN_324], +const INPUT_SIZE_320: usize = 2; +const IN_320: usize = 2; +const OUT_320: usize = 1; +fn aiur_fn_320( + inp: [G; IN_320], record: &mut QueryRecord, io_buffer: &mut IOBuffer, unconstrained: bool, -) -> Result<[G; OUT_324], ExecError> { +) -> Result<[G; OUT_320], ExecError> { stacker::maybe_grow(64 * 1024, 4 * 1024 * 1024, || { let __v_0: G = inp[0]; let __v_1: G = inp[1]; - let __r_arr: [G; OUT_298] = { let __args: [G; IN_298] = [__v_0, __v_1]; let __cu = unconstrained; if let Some(result) = record.function_queries[298].get_mut(&__args[..]) { if !__cu && *result.multiplicity == G::ZERO { aiur_fn_298(__args, record, io_buffer, false)? } else { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_298] = unsafe { *(result.output.as_ptr() as *const [G; OUT_298]) }; __ret } } else { aiur_fn_298(__args, record, io_buffer, __cu)? } }; + let __r_arr: [G; OUT_294] = { let __args: [G; IN_294] = [__v_0, __v_1]; let __cu = unconstrained; if let Some(result) = record.function_queries[294].get_mut(&__args[..]) { if !__cu && *result.multiplicity == G::ZERO { aiur_fn_294(__args, record, io_buffer, false)? } else { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_294] = unsafe { *(result.output.as_ptr() as *const [G; OUT_294]) }; __ret } } else { aiur_fn_294(__args, record, io_buffer, __cu)? } }; let __v_2: G = __r_arr[0]; match __v_2.as_canonical_u64() { 1u64 => { let __v_3: G = G::from_u64(1); - let __ret: [G; OUT_324] = [__v_3]; - if let Some(result) = record.function_queries[324].get_mut(&inp[..]) { debug_assert_eq!(result.output, &__ret[..]); if !unconstrained { *result.multiplicity += G::ONE; } } else { record.function_queries[324].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained)); }; + let __ret: [G; OUT_320] = [__v_3]; + if let Some(result) = record.function_queries[320].get_mut(&inp[..]) { debug_assert_eq!(result.output, &__ret[..]); if !unconstrained { *result.multiplicity += G::ONE; } } else { record.function_queries[320].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained)); }; return Ok(__ret); }, 0u64 => { - let __r_arr: [G; OUT_322] = { let __args: [G; IN_322] = [__v_0]; let __cu = unconstrained; if let Some(result) = record.function_queries[322].get_mut(&__args[..]) { if !__cu && *result.multiplicity == G::ZERO { aiur_fn_322(__args, record, io_buffer, false)? } else { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_322] = unsafe { *(result.output.as_ptr() as *const [G; OUT_322]) }; __ret } } else { aiur_fn_322(__args, record, io_buffer, __cu)? } }; + let __r_arr: [G; OUT_318] = { let __args: [G; IN_318] = [__v_0]; let __cu = unconstrained; if let Some(result) = record.function_queries[318].get_mut(&__args[..]) { if !__cu && *result.multiplicity == G::ZERO { aiur_fn_318(__args, record, io_buffer, false)? } else { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_318] = unsafe { *(result.output.as_ptr() as *const [G; OUT_318]) }; __ret } } else { aiur_fn_318(__args, record, io_buffer, __cu)? } }; let __v_3: G = __r_arr[0]; - let __r_arr: [G; OUT_322] = { let __args: [G; IN_322] = [__v_1]; let __cu = unconstrained; if let Some(result) = record.function_queries[322].get_mut(&__args[..]) { if !__cu && *result.multiplicity == G::ZERO { aiur_fn_322(__args, record, io_buffer, false)? } else { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_322] = unsafe { *(result.output.as_ptr() as *const [G; OUT_322]) }; __ret } } else { aiur_fn_322(__args, record, io_buffer, __cu)? } }; + let __r_arr: [G; OUT_318] = { let __args: [G; IN_318] = [__v_1]; let __cu = unconstrained; if let Some(result) = record.function_queries[318].get_mut(&__args[..]) { if !__cu && *result.multiplicity == G::ZERO { aiur_fn_318(__args, record, io_buffer, false)? } else { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_318] = unsafe { *(result.output.as_ptr() as *const [G; OUT_318]) }; __ret } } else { aiur_fn_318(__args, record, io_buffer, __cu)? } }; let __v_4: G = __r_arr[0]; - let __r_arr: [G; OUT_315] = { let __args: [G; IN_315] = [__v_3, __v_4]; let __cu = unconstrained; if let Some(result) = record.function_queries[315].get_mut(&__args[..]) { if !__cu && *result.multiplicity == G::ZERO { aiur_fn_315(__args, record, io_buffer, false)? } else { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_315] = unsafe { *(result.output.as_ptr() as *const [G; OUT_315]) }; __ret } } else { aiur_fn_315(__args, record, io_buffer, __cu)? } }; + let __r_arr: [G; OUT_311] = { let __args: [G; IN_311] = [__v_3, __v_4]; let __cu = unconstrained; if let Some(result) = record.function_queries[311].get_mut(&__args[..]) { if !__cu && *result.multiplicity == G::ZERO { aiur_fn_311(__args, record, io_buffer, false)? } else { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_311] = unsafe { *(result.output.as_ptr() as *const [G; OUT_311]) }; __ret } } else { aiur_fn_311(__args, record, io_buffer, __cu)? } }; let __v_5: G = __r_arr[0]; - let __ret: [G; OUT_324] = [__v_5]; - if let Some(result) = record.function_queries[324].get_mut(&inp[..]) { debug_assert_eq!(result.output, &__ret[..]); if !unconstrained { *result.multiplicity += G::ONE; } } else { record.function_queries[324].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained)); }; + let __ret: [G; OUT_320] = [__v_5]; + if let Some(result) = record.function_queries[320].get_mut(&inp[..]) { debug_assert_eq!(result.output, &__ret[..]); if !unconstrained { *result.multiplicity += G::ONE; } } else { record.function_queries[320].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained)); }; return Ok(__ret); }, _ => { @@ -30610,24 +30336,24 @@ fn aiur_fn_324( }) } -const INPUT_SIZE_325: usize = 2; -const IN_325: usize = 2; -const OUT_325: usize = 1; -fn aiur_fn_325( - inp: [G; IN_325], +const INPUT_SIZE_321: usize = 2; +const IN_321: usize = 2; +const OUT_321: usize = 1; +fn aiur_fn_321( + inp: [G; IN_321], record: &mut QueryRecord, io_buffer: &mut IOBuffer, unconstrained: bool, -) -> Result<[G; OUT_325], ExecError> { +) -> Result<[G; OUT_321], ExecError> { stacker::maybe_grow(64 * 1024, 4 * 1024 * 1024, || { let __v_0: G = inp[0]; let __v_1: G = inp[1]; - let __r_arr: [G; OUT_330] = { let __args: [G; IN_330] = [__v_0]; let __cu = unconstrained; if let Some(result) = record.function_queries[330].get_mut(&__args[..]) { if !__cu && *result.multiplicity == G::ZERO { aiur_fn_330(__args, record, io_buffer, false)? } else { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_330] = unsafe { *(result.output.as_ptr() as *const [G; OUT_330]) }; __ret } } else { aiur_fn_330(__args, record, io_buffer, __cu)? } }; + let __r_arr: [G; OUT_326] = { let __args: [G; IN_326] = [__v_0]; let __cu = unconstrained; if let Some(result) = record.function_queries[326].get_mut(&__args[..]) { if !__cu && *result.multiplicity == G::ZERO { aiur_fn_326(__args, record, io_buffer, false)? } else { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_326] = unsafe { *(result.output.as_ptr() as *const [G; OUT_326]) }; __ret } } else { aiur_fn_326(__args, record, io_buffer, __cu)? } }; let __v_2: G = __r_arr[0]; let __v_3: G = __r_arr[1]; match __v_2.as_canonical_u64() { 1u64 => { - let __r_arr: [G; OUT_330] = { let __args: [G; IN_330] = [__v_1]; let __cu = unconstrained; if let Some(result) = record.function_queries[330].get_mut(&__args[..]) { if !__cu && *result.multiplicity == G::ZERO { aiur_fn_330(__args, record, io_buffer, false)? } else { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_330] = unsafe { *(result.output.as_ptr() as *const [G; OUT_330]) }; __ret } } else { aiur_fn_330(__args, record, io_buffer, __cu)? } }; + let __r_arr: [G; OUT_326] = { let __args: [G; IN_326] = [__v_1]; let __cu = unconstrained; if let Some(result) = record.function_queries[326].get_mut(&__args[..]) { if !__cu && *result.multiplicity == G::ZERO { aiur_fn_326(__args, record, io_buffer, false)? } else { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_326] = unsafe { *(result.output.as_ptr() as *const [G; OUT_326]) }; __ret } } else { aiur_fn_326(__args, record, io_buffer, __cu)? } }; let __v_4: G = __r_arr[0]; let __v_5: G = __r_arr[1]; match __v_4.as_canonical_u64() { @@ -30635,13 +30361,13 @@ fn aiur_fn_325( let __v_6: G = { let __a_val = __v_3.as_canonical_u64(); let __b_val = __v_5.as_canonical_u64(); let __a_u32 = u32::try_from(__a_val).ok().ok_or(ExecError::U32OutOfRange(__a_val))?; let __b_u32 = u32::try_from(__b_val).ok().ok_or(ExecError::U32OutOfRange(__b_val))?; let __result = G::from_bool(__a_u32 < __b_u32); if !unconstrained { let __x_bytes = __a_u32.to_le_bytes(); let __z_bytes = __b_u32.to_le_bytes(); let __c_u32 = __b_u32.wrapping_sub(__a_u32).wrapping_sub(1); let __y_bytes = __c_u32.to_le_bytes(); record.bytes2_queries.bump_range_check(&G::from_u8(__x_bytes[0]), &G::from_u8(__x_bytes[1])); record.bytes2_queries.bump_range_check(&G::from_u8(__x_bytes[2]), &G::from_u8(__x_bytes[3])); record.bytes2_queries.bump_range_check(&G::from_u8(__y_bytes[0]), &G::from_u8(__y_bytes[1])); record.bytes2_queries.bump_range_check(&G::from_u8(__y_bytes[2]), &G::from_u8(__y_bytes[3])); record.bytes2_queries.bump_range_check(&G::from_u8(__z_bytes[0]), &G::from_u8(__z_bytes[1])); record.bytes2_queries.bump_range_check(&G::from_u8(__z_bytes[2]), &G::from_u8(__z_bytes[3])); } __result }; match __v_6.as_canonical_u64() { 1u64 => { - let __ret: [G; OUT_325] = [__v_1]; - if let Some(result) = record.function_queries[325].get_mut(&inp[..]) { debug_assert_eq!(result.output, &__ret[..]); if !unconstrained { *result.multiplicity += G::ONE; } } else { record.function_queries[325].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained)); }; + let __ret: [G; OUT_321] = [__v_1]; + if let Some(result) = record.function_queries[321].get_mut(&inp[..]) { debug_assert_eq!(result.output, &__ret[..]); if !unconstrained { *result.multiplicity += G::ONE; } } else { record.function_queries[321].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained)); }; return Ok(__ret); }, 0u64 => { - let __ret: [G; OUT_325] = [__v_0]; - if let Some(result) = record.function_queries[325].get_mut(&inp[..]) { debug_assert_eq!(result.output, &__ret[..]); if !unconstrained { *result.multiplicity += G::ONE; } } else { record.function_queries[325].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained)); }; + let __ret: [G; OUT_321] = [__v_0]; + if let Some(result) = record.function_queries[321].get_mut(&inp[..]) { debug_assert_eq!(result.output, &__ret[..]); if !unconstrained { *result.multiplicity += G::ONE; } } else { record.function_queries[321].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained)); }; return Ok(__ret); }, _ => { @@ -30650,43 +30376,43 @@ fn aiur_fn_325( } }, _ => { - let __r_arr: [G; OUT_326] = { let __args: [G; IN_326] = [__v_0, __v_1]; let __cu = unconstrained; if let Some(result) = record.function_queries[326].get_mut(&__args[..]) { if !__cu && *result.multiplicity == G::ZERO { aiur_fn_326(__args, record, io_buffer, false)? } else { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_326] = unsafe { *(result.output.as_ptr() as *const [G; OUT_326]) }; __ret } } else { aiur_fn_326(__args, record, io_buffer, __cu)? } }; + let __r_arr: [G; OUT_322] = { let __args: [G; IN_322] = [__v_0, __v_1]; let __cu = unconstrained; if let Some(result) = record.function_queries[322].get_mut(&__args[..]) { if !__cu && *result.multiplicity == G::ZERO { aiur_fn_322(__args, record, io_buffer, false)? } else { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_322] = unsafe { *(result.output.as_ptr() as *const [G; OUT_322]) }; __ret } } else { aiur_fn_322(__args, record, io_buffer, __cu)? } }; let __v_6: G = __r_arr[0]; - let __ret: [G; OUT_325] = [__v_6]; - if let Some(result) = record.function_queries[325].get_mut(&inp[..]) { debug_assert_eq!(result.output, &__ret[..]); if !unconstrained { *result.multiplicity += G::ONE; } } else { record.function_queries[325].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained)); }; + let __ret: [G; OUT_321] = [__v_6]; + if let Some(result) = record.function_queries[321].get_mut(&inp[..]) { debug_assert_eq!(result.output, &__ret[..]); if !unconstrained { *result.multiplicity += G::ONE; } } else { record.function_queries[321].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained)); }; return Ok(__ret); }, } }, _ => { - let __r_arr: [G; OUT_326] = { let __args: [G; IN_326] = [__v_0, __v_1]; let __cu = unconstrained; if let Some(result) = record.function_queries[326].get_mut(&__args[..]) { if !__cu && *result.multiplicity == G::ZERO { aiur_fn_326(__args, record, io_buffer, false)? } else { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_326] = unsafe { *(result.output.as_ptr() as *const [G; OUT_326]) }; __ret } } else { aiur_fn_326(__args, record, io_buffer, __cu)? } }; + let __r_arr: [G; OUT_322] = { let __args: [G; IN_322] = [__v_0, __v_1]; let __cu = unconstrained; if let Some(result) = record.function_queries[322].get_mut(&__args[..]) { if !__cu && *result.multiplicity == G::ZERO { aiur_fn_322(__args, record, io_buffer, false)? } else { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_322] = unsafe { *(result.output.as_ptr() as *const [G; OUT_322]) }; __ret } } else { aiur_fn_322(__args, record, io_buffer, __cu)? } }; let __v_4: G = __r_arr[0]; - let __ret: [G; OUT_325] = [__v_4]; - if let Some(result) = record.function_queries[325].get_mut(&inp[..]) { debug_assert_eq!(result.output, &__ret[..]); if !unconstrained { *result.multiplicity += G::ONE; } } else { record.function_queries[325].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained)); }; + let __ret: [G; OUT_321] = [__v_4]; + if let Some(result) = record.function_queries[321].get_mut(&inp[..]) { debug_assert_eq!(result.output, &__ret[..]); if !unconstrained { *result.multiplicity += G::ONE; } } else { record.function_queries[321].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained)); }; return Ok(__ret); }, } }) } -const INPUT_SIZE_326: usize = 2; -const IN_326: usize = 2; -const OUT_326: usize = 1; -fn aiur_fn_326( - inp: [G; IN_326], +const INPUT_SIZE_322: usize = 2; +const IN_322: usize = 2; +const OUT_322: usize = 1; +fn aiur_fn_322( + inp: [G; IN_322], record: &mut QueryRecord, io_buffer: &mut IOBuffer, unconstrained: bool, -) -> Result<[G; OUT_326], ExecError> { +) -> Result<[G; OUT_322], ExecError> { stacker::maybe_grow(64 * 1024, 4 * 1024 * 1024, || { let __v_0: G = inp[0]; let __v_1: G = inp[1]; - let __r_arr: [G; OUT_327] = { let __args: [G; IN_327] = [__v_0, __v_1]; let __cu = unconstrained; if let Some(result) = record.function_queries[327].get_mut(&__args[..]) { if !__cu && *result.multiplicity == G::ZERO { aiur_fn_327(__args, record, io_buffer, false)? } else { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_327] = unsafe { *(result.output.as_ptr() as *const [G; OUT_327]) }; __ret } } else { aiur_fn_327(__args, record, io_buffer, __cu)? } }; + let __r_arr: [G; OUT_323] = { let __args: [G; IN_323] = [__v_0, __v_1]; let __cu = unconstrained; if let Some(result) = record.function_queries[323].get_mut(&__args[..]) { if !__cu && *result.multiplicity == G::ZERO { aiur_fn_323(__args, record, io_buffer, false)? } else { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_323] = unsafe { *(result.output.as_ptr() as *const [G; OUT_323]) }; __ret } } else { aiur_fn_323(__args, record, io_buffer, __cu)? } }; let __v_2: G = __r_arr[0]; match __v_2.as_canonical_u64() { 1u64 => { - let __ret: [G; OUT_326] = [__v_0]; - if let Some(result) = record.function_queries[326].get_mut(&inp[..]) { debug_assert_eq!(result.output, &__ret[..]); if !unconstrained { *result.multiplicity += G::ONE; } } else { record.function_queries[326].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained)); }; + let __ret: [G; OUT_322] = [__v_0]; + if let Some(result) = record.function_queries[322].get_mut(&inp[..]) { debug_assert_eq!(result.output, &__ret[..]); if !unconstrained { *result.multiplicity += G::ONE; } } else { record.function_queries[322].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained)); }; return Ok(__ret); }, 0u64 => { @@ -30696,8 +30422,8 @@ fn aiur_fn_326( let __v_5: G = __loaded[2]; match __v_3.as_canonical_u64() { 0u64 => { - let __ret: [G; OUT_326] = [__v_1]; - if let Some(result) = record.function_queries[326].get_mut(&inp[..]) { debug_assert_eq!(result.output, &__ret[..]); if !unconstrained { *result.multiplicity += G::ONE; } } else { record.function_queries[326].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained)); }; + let __ret: [G; OUT_322] = [__v_1]; + if let Some(result) = record.function_queries[322].get_mut(&inp[..]) { debug_assert_eq!(result.output, &__ret[..]); if !unconstrained { *result.multiplicity += G::ONE; } } else { record.function_queries[322].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained)); }; return Ok(__ret); }, _ => { @@ -30707,33 +30433,33 @@ fn aiur_fn_326( let __v_8: G = __loaded[2]; match __v_6.as_canonical_u64() { 0u64 => { - let __ret: [G; OUT_326] = [__v_0]; - if let Some(result) = record.function_queries[326].get_mut(&inp[..]) { debug_assert_eq!(result.output, &__ret[..]); if !unconstrained { *result.multiplicity += G::ONE; } } else { record.function_queries[326].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained)); }; + let __ret: [G; OUT_322] = [__v_0]; + if let Some(result) = record.function_queries[322].get_mut(&inp[..]) { debug_assert_eq!(result.output, &__ret[..]); if !unconstrained { *result.multiplicity += G::ONE; } } else { record.function_queries[322].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained)); }; return Ok(__ret); }, _ => { - let __r_arr: [G; OUT_328] = { let __args: [G; IN_328] = [__v_1, __v_0]; let __cu = unconstrained; if let Some(result) = record.function_queries[328].get_mut(&__args[..]) { if !__cu && *result.multiplicity == G::ZERO { aiur_fn_328(__args, record, io_buffer, false)? } else { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_328] = unsafe { *(result.output.as_ptr() as *const [G; OUT_328]) }; __ret } } else { aiur_fn_328(__args, record, io_buffer, __cu)? } }; + let __r_arr: [G; OUT_324] = { let __args: [G; IN_324] = [__v_1, __v_0]; let __cu = unconstrained; if let Some(result) = record.function_queries[324].get_mut(&__args[..]) { if !__cu && *result.multiplicity == G::ZERO { aiur_fn_324(__args, record, io_buffer, false)? } else { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_324] = unsafe { *(result.output.as_ptr() as *const [G; OUT_324]) }; __ret } } else { aiur_fn_324(__args, record, io_buffer, __cu)? } }; let __v_9: G = __r_arr[0]; match __v_9.as_canonical_u64() { 1u64 => { - let __ret: [G; OUT_326] = [__v_1]; - if let Some(result) = record.function_queries[326].get_mut(&inp[..]) { debug_assert_eq!(result.output, &__ret[..]); if !unconstrained { *result.multiplicity += G::ONE; } } else { record.function_queries[326].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained)); }; + let __ret: [G; OUT_322] = [__v_1]; + if let Some(result) = record.function_queries[322].get_mut(&inp[..]) { debug_assert_eq!(result.output, &__ret[..]); if !unconstrained { *result.multiplicity += G::ONE; } } else { record.function_queries[322].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained)); }; return Ok(__ret); }, 0u64 => { - let __r_arr: [G; OUT_328] = { let __args: [G; IN_328] = [__v_0, __v_1]; let __cu = unconstrained; if let Some(result) = record.function_queries[328].get_mut(&__args[..]) { if !__cu && *result.multiplicity == G::ZERO { aiur_fn_328(__args, record, io_buffer, false)? } else { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_328] = unsafe { *(result.output.as_ptr() as *const [G; OUT_328]) }; __ret } } else { aiur_fn_328(__args, record, io_buffer, __cu)? } }; + let __r_arr: [G; OUT_324] = { let __args: [G; IN_324] = [__v_0, __v_1]; let __cu = unconstrained; if let Some(result) = record.function_queries[324].get_mut(&__args[..]) { if !__cu && *result.multiplicity == G::ZERO { aiur_fn_324(__args, record, io_buffer, false)? } else { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_324] = unsafe { *(result.output.as_ptr() as *const [G; OUT_324]) }; __ret } } else { aiur_fn_324(__args, record, io_buffer, __cu)? } }; let __v_10: G = __r_arr[0]; match __v_10.as_canonical_u64() { 1u64 => { - let __ret: [G; OUT_326] = [__v_0]; - if let Some(result) = record.function_queries[326].get_mut(&inp[..]) { debug_assert_eq!(result.output, &__ret[..]); if !unconstrained { *result.multiplicity += G::ONE; } } else { record.function_queries[326].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained)); }; + let __ret: [G; OUT_322] = [__v_0]; + if let Some(result) = record.function_queries[322].get_mut(&inp[..]) { debug_assert_eq!(result.output, &__ret[..]); if !unconstrained { *result.multiplicity += G::ONE; } } else { record.function_queries[322].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained)); }; return Ok(__ret); }, 0u64 => { - let __r_arr: [G; OUT_329] = { let __args: [G; IN_329] = [__v_0, __v_1]; let __cu = unconstrained; if let Some(result) = record.function_queries[329].get_mut(&__args[..]) { if !__cu && *result.multiplicity == G::ZERO { aiur_fn_329(__args, record, io_buffer, false)? } else { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_329] = unsafe { *(result.output.as_ptr() as *const [G; OUT_329]) }; __ret } } else { aiur_fn_329(__args, record, io_buffer, __cu)? } }; + let __r_arr: [G; OUT_325] = { let __args: [G; IN_325] = [__v_0, __v_1]; let __cu = unconstrained; if let Some(result) = record.function_queries[325].get_mut(&__args[..]) { if !__cu && *result.multiplicity == G::ZERO { aiur_fn_325(__args, record, io_buffer, false)? } else { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_325] = unsafe { *(result.output.as_ptr() as *const [G; OUT_325]) }; __ret } } else { aiur_fn_325(__args, record, io_buffer, __cu)? } }; let __v_11: G = __r_arr[0]; - let __ret: [G; OUT_326] = [__v_11]; - if let Some(result) = record.function_queries[326].get_mut(&inp[..]) { debug_assert_eq!(result.output, &__ret[..]); if !unconstrained { *result.multiplicity += G::ONE; } } else { record.function_queries[326].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained)); }; + let __ret: [G; OUT_322] = [__v_11]; + if let Some(result) = record.function_queries[322].get_mut(&inp[..]) { debug_assert_eq!(result.output, &__ret[..]); if !unconstrained { *result.multiplicity += G::ONE; } } else { record.function_queries[322].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained)); }; return Ok(__ret); }, _ => { @@ -30757,15 +30483,15 @@ fn aiur_fn_326( }) } -const INPUT_SIZE_327: usize = 2; -const IN_327: usize = 2; -const OUT_327: usize = 1; -fn aiur_fn_327( - inp: [G; IN_327], +const INPUT_SIZE_323: usize = 2; +const IN_323: usize = 2; +const OUT_323: usize = 1; +fn aiur_fn_323( + inp: [G; IN_323], record: &mut QueryRecord, io_buffer: &mut IOBuffer, unconstrained: bool, -) -> Result<[G; OUT_327], ExecError> { +) -> Result<[G; OUT_323], ExecError> { stacker::maybe_grow(64 * 1024, 4 * 1024 * 1024, || { let __v_0: G = inp[0]; let __v_1: G = inp[1]; @@ -30773,8 +30499,8 @@ fn aiur_fn_327( match __v_2.as_canonical_u64() { 0u64 => { let __v_3: G = G::from_u64(1); - let __ret: [G; OUT_327] = [__v_3]; - if let Some(result) = record.function_queries[327].get_mut(&inp[..]) { debug_assert_eq!(result.output, &__ret[..]); if !unconstrained { *result.multiplicity += G::ONE; } } else { record.function_queries[327].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained)); }; + let __ret: [G; OUT_323] = [__v_3]; + if let Some(result) = record.function_queries[323].get_mut(&inp[..]) { debug_assert_eq!(result.output, &__ret[..]); if !unconstrained { *result.multiplicity += G::ONE; } } else { record.function_queries[323].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained)); }; return Ok(__ret); }, _ => { @@ -30791,14 +30517,14 @@ fn aiur_fn_327( match __v_6.as_canonical_u64() { 0u64 => { let __v_9: G = G::from_u64(1); - let __ret: [G; OUT_327] = [__v_9]; - if let Some(result) = record.function_queries[327].get_mut(&inp[..]) { debug_assert_eq!(result.output, &__ret[..]); if !unconstrained { *result.multiplicity += G::ONE; } } else { record.function_queries[327].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained)); }; + let __ret: [G; OUT_323] = [__v_9]; + if let Some(result) = record.function_queries[323].get_mut(&inp[..]) { debug_assert_eq!(result.output, &__ret[..]); if !unconstrained { *result.multiplicity += G::ONE; } } else { record.function_queries[323].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained)); }; return Ok(__ret); }, _ => { let __v_9: G = G::from_u64(0); - let __ret: [G; OUT_327] = [__v_9]; - if let Some(result) = record.function_queries[327].get_mut(&inp[..]) { debug_assert_eq!(result.output, &__ret[..]); if !unconstrained { *result.multiplicity += G::ONE; } } else { record.function_queries[327].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained)); }; + let __ret: [G; OUT_323] = [__v_9]; + if let Some(result) = record.function_queries[323].get_mut(&inp[..]) { debug_assert_eq!(result.output, &__ret[..]); if !unconstrained { *result.multiplicity += G::ONE; } } else { record.function_queries[323].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained)); }; return Ok(__ret); }, } @@ -30810,16 +30536,16 @@ fn aiur_fn_327( let __v_8: G = __loaded[2]; match __v_6.as_canonical_u64() { 1u64 => { - let __r_arr: [G; OUT_327] = { let __args: [G; IN_327] = [__v_4, __v_7]; let __cu = unconstrained; if let Some(result) = record.function_queries[327].get_mut(&__args[..]) { if !__cu && *result.multiplicity == G::ZERO { aiur_fn_327(__args, record, io_buffer, false)? } else { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_327] = unsafe { *(result.output.as_ptr() as *const [G; OUT_327]) }; __ret } } else { aiur_fn_327(__args, record, io_buffer, __cu)? } }; + let __r_arr: [G; OUT_323] = { let __args: [G; IN_323] = [__v_4, __v_7]; let __cu = unconstrained; if let Some(result) = record.function_queries[323].get_mut(&__args[..]) { if !__cu && *result.multiplicity == G::ZERO { aiur_fn_323(__args, record, io_buffer, false)? } else { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_323] = unsafe { *(result.output.as_ptr() as *const [G; OUT_323]) }; __ret } } else { aiur_fn_323(__args, record, io_buffer, __cu)? } }; let __v_9: G = __r_arr[0]; - let __ret: [G; OUT_327] = [__v_9]; - if let Some(result) = record.function_queries[327].get_mut(&inp[..]) { debug_assert_eq!(result.output, &__ret[..]); if !unconstrained { *result.multiplicity += G::ONE; } } else { record.function_queries[327].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained)); }; + let __ret: [G; OUT_323] = [__v_9]; + if let Some(result) = record.function_queries[323].get_mut(&inp[..]) { debug_assert_eq!(result.output, &__ret[..]); if !unconstrained { *result.multiplicity += G::ONE; } } else { record.function_queries[323].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained)); }; return Ok(__ret); }, _ => { let __v_9: G = G::from_u64(0); - let __ret: [G; OUT_327] = [__v_9]; - if let Some(result) = record.function_queries[327].get_mut(&inp[..]) { debug_assert_eq!(result.output, &__ret[..]); if !unconstrained { *result.multiplicity += G::ONE; } } else { record.function_queries[327].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained)); }; + let __ret: [G; OUT_323] = [__v_9]; + if let Some(result) = record.function_queries[323].get_mut(&inp[..]) { debug_assert_eq!(result.output, &__ret[..]); if !unconstrained { *result.multiplicity += G::ONE; } } else { record.function_queries[323].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained)); }; return Ok(__ret); }, } @@ -30831,19 +30557,19 @@ fn aiur_fn_327( let __v_8: G = __loaded[2]; match __v_6.as_canonical_u64() { 2u64 => { - let __r_arr: [G; OUT_327] = { let __args: [G; IN_327] = [__v_4, __v_7]; let __cu = unconstrained; if let Some(result) = record.function_queries[327].get_mut(&__args[..]) { if !__cu && *result.multiplicity == G::ZERO { aiur_fn_327(__args, record, io_buffer, false)? } else { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_327] = unsafe { *(result.output.as_ptr() as *const [G; OUT_327]) }; __ret } } else { aiur_fn_327(__args, record, io_buffer, __cu)? } }; + let __r_arr: [G; OUT_323] = { let __args: [G; IN_323] = [__v_4, __v_7]; let __cu = unconstrained; if let Some(result) = record.function_queries[323].get_mut(&__args[..]) { if !__cu && *result.multiplicity == G::ZERO { aiur_fn_323(__args, record, io_buffer, false)? } else { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_323] = unsafe { *(result.output.as_ptr() as *const [G; OUT_323]) }; __ret } } else { aiur_fn_323(__args, record, io_buffer, __cu)? } }; let __v_9: G = __r_arr[0]; - let __r_arr: [G; OUT_327] = { let __args: [G; IN_327] = [__v_5, __v_8]; let __cu = unconstrained; if let Some(result) = record.function_queries[327].get_mut(&__args[..]) { if !__cu && *result.multiplicity == G::ZERO { aiur_fn_327(__args, record, io_buffer, false)? } else { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_327] = unsafe { *(result.output.as_ptr() as *const [G; OUT_327]) }; __ret } } else { aiur_fn_327(__args, record, io_buffer, __cu)? } }; + let __r_arr: [G; OUT_323] = { let __args: [G; IN_323] = [__v_5, __v_8]; let __cu = unconstrained; if let Some(result) = record.function_queries[323].get_mut(&__args[..]) { if !__cu && *result.multiplicity == G::ZERO { aiur_fn_323(__args, record, io_buffer, false)? } else { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_323] = unsafe { *(result.output.as_ptr() as *const [G; OUT_323]) }; __ret } } else { aiur_fn_323(__args, record, io_buffer, __cu)? } }; let __v_10: G = __r_arr[0]; let __v_11: G = (__v_9 * __v_10); - let __ret: [G; OUT_327] = [__v_11]; - if let Some(result) = record.function_queries[327].get_mut(&inp[..]) { debug_assert_eq!(result.output, &__ret[..]); if !unconstrained { *result.multiplicity += G::ONE; } } else { record.function_queries[327].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained)); }; + let __ret: [G; OUT_323] = [__v_11]; + if let Some(result) = record.function_queries[323].get_mut(&inp[..]) { debug_assert_eq!(result.output, &__ret[..]); if !unconstrained { *result.multiplicity += G::ONE; } } else { record.function_queries[323].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained)); }; return Ok(__ret); }, _ => { let __v_9: G = G::from_u64(0); - let __ret: [G; OUT_327] = [__v_9]; - if let Some(result) = record.function_queries[327].get_mut(&inp[..]) { debug_assert_eq!(result.output, &__ret[..]); if !unconstrained { *result.multiplicity += G::ONE; } } else { record.function_queries[327].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained)); }; + let __ret: [G; OUT_323] = [__v_9]; + if let Some(result) = record.function_queries[323].get_mut(&inp[..]) { debug_assert_eq!(result.output, &__ret[..]); if !unconstrained { *result.multiplicity += G::ONE; } } else { record.function_queries[323].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained)); }; return Ok(__ret); }, } @@ -30855,19 +30581,19 @@ fn aiur_fn_327( let __v_8: G = __loaded[2]; match __v_6.as_canonical_u64() { 3u64 => { - let __r_arr: [G; OUT_327] = { let __args: [G; IN_327] = [__v_4, __v_7]; let __cu = unconstrained; if let Some(result) = record.function_queries[327].get_mut(&__args[..]) { if !__cu && *result.multiplicity == G::ZERO { aiur_fn_327(__args, record, io_buffer, false)? } else { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_327] = unsafe { *(result.output.as_ptr() as *const [G; OUT_327]) }; __ret } } else { aiur_fn_327(__args, record, io_buffer, __cu)? } }; + let __r_arr: [G; OUT_323] = { let __args: [G; IN_323] = [__v_4, __v_7]; let __cu = unconstrained; if let Some(result) = record.function_queries[323].get_mut(&__args[..]) { if !__cu && *result.multiplicity == G::ZERO { aiur_fn_323(__args, record, io_buffer, false)? } else { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_323] = unsafe { *(result.output.as_ptr() as *const [G; OUT_323]) }; __ret } } else { aiur_fn_323(__args, record, io_buffer, __cu)? } }; let __v_9: G = __r_arr[0]; - let __r_arr: [G; OUT_327] = { let __args: [G; IN_327] = [__v_5, __v_8]; let __cu = unconstrained; if let Some(result) = record.function_queries[327].get_mut(&__args[..]) { if !__cu && *result.multiplicity == G::ZERO { aiur_fn_327(__args, record, io_buffer, false)? } else { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_327] = unsafe { *(result.output.as_ptr() as *const [G; OUT_327]) }; __ret } } else { aiur_fn_327(__args, record, io_buffer, __cu)? } }; + let __r_arr: [G; OUT_323] = { let __args: [G; IN_323] = [__v_5, __v_8]; let __cu = unconstrained; if let Some(result) = record.function_queries[323].get_mut(&__args[..]) { if !__cu && *result.multiplicity == G::ZERO { aiur_fn_323(__args, record, io_buffer, false)? } else { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_323] = unsafe { *(result.output.as_ptr() as *const [G; OUT_323]) }; __ret } } else { aiur_fn_323(__args, record, io_buffer, __cu)? } }; let __v_10: G = __r_arr[0]; let __v_11: G = (__v_9 * __v_10); - let __ret: [G; OUT_327] = [__v_11]; - if let Some(result) = record.function_queries[327].get_mut(&inp[..]) { debug_assert_eq!(result.output, &__ret[..]); if !unconstrained { *result.multiplicity += G::ONE; } } else { record.function_queries[327].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained)); }; + let __ret: [G; OUT_323] = [__v_11]; + if let Some(result) = record.function_queries[323].get_mut(&inp[..]) { debug_assert_eq!(result.output, &__ret[..]); if !unconstrained { *result.multiplicity += G::ONE; } } else { record.function_queries[323].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained)); }; return Ok(__ret); }, _ => { let __v_9: G = G::from_u64(0); - let __ret: [G; OUT_327] = [__v_9]; - if let Some(result) = record.function_queries[327].get_mut(&inp[..]) { debug_assert_eq!(result.output, &__ret[..]); if !unconstrained { *result.multiplicity += G::ONE; } } else { record.function_queries[327].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained)); }; + let __ret: [G; OUT_323] = [__v_9]; + if let Some(result) = record.function_queries[323].get_mut(&inp[..]) { debug_assert_eq!(result.output, &__ret[..]); if !unconstrained { *result.multiplicity += G::ONE; } } else { record.function_queries[323].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained)); }; return Ok(__ret); }, } @@ -30883,22 +30609,22 @@ fn aiur_fn_327( match __v_9.as_canonical_u64() { 0u64 => { let __v_10: G = G::from_u64(1); - let __ret: [G; OUT_327] = [__v_10]; - if let Some(result) = record.function_queries[327].get_mut(&inp[..]) { debug_assert_eq!(result.output, &__ret[..]); if !unconstrained { *result.multiplicity += G::ONE; } } else { record.function_queries[327].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained)); }; + let __ret: [G; OUT_323] = [__v_10]; + if let Some(result) = record.function_queries[323].get_mut(&inp[..]) { debug_assert_eq!(result.output, &__ret[..]); if !unconstrained { *result.multiplicity += G::ONE; } } else { record.function_queries[323].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained)); }; return Ok(__ret); }, _ => { let __v_10: G = G::from_u64(0); - let __ret: [G; OUT_327] = [__v_10]; - if let Some(result) = record.function_queries[327].get_mut(&inp[..]) { debug_assert_eq!(result.output, &__ret[..]); if !unconstrained { *result.multiplicity += G::ONE; } } else { record.function_queries[327].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained)); }; + let __ret: [G; OUT_323] = [__v_10]; + if let Some(result) = record.function_queries[323].get_mut(&inp[..]) { debug_assert_eq!(result.output, &__ret[..]); if !unconstrained { *result.multiplicity += G::ONE; } } else { record.function_queries[323].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained)); }; return Ok(__ret); }, } }, _ => { let __v_9: G = G::from_u64(0); - let __ret: [G; OUT_327] = [__v_9]; - if let Some(result) = record.function_queries[327].get_mut(&inp[..]) { debug_assert_eq!(result.output, &__ret[..]); if !unconstrained { *result.multiplicity += G::ONE; } } else { record.function_queries[327].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained)); }; + let __ret: [G; OUT_323] = [__v_9]; + if let Some(result) = record.function_queries[323].get_mut(&inp[..]) { debug_assert_eq!(result.output, &__ret[..]); if !unconstrained { *result.multiplicity += G::ONE; } } else { record.function_queries[323].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained)); }; return Ok(__ret); }, } @@ -30912,15 +30638,15 @@ fn aiur_fn_327( }) } -const INPUT_SIZE_328: usize = 2; -const IN_328: usize = 2; -const OUT_328: usize = 1; -fn aiur_fn_328( - inp: [G; IN_328], +const INPUT_SIZE_324: usize = 2; +const IN_324: usize = 2; +const OUT_324: usize = 1; +fn aiur_fn_324( + inp: [G; IN_324], record: &mut QueryRecord, io_buffer: &mut IOBuffer, unconstrained: bool, -) -> Result<[G; OUT_328], ExecError> { +) -> Result<[G; OUT_324], ExecError> { stacker::maybe_grow(64 * 1024, 4 * 1024 * 1024, || { let __v_0: G = inp[0]; let __v_1: G = inp[1]; @@ -30930,20 +30656,20 @@ fn aiur_fn_328( let __v_4: G = __loaded[2]; match __v_2.as_canonical_u64() { 2u64 => { - let __r_arr: [G; OUT_327] = { let __args: [G; IN_327] = [__v_3, __v_1]; let __cu = unconstrained; if let Some(result) = record.function_queries[327].get_mut(&__args[..]) { if !__cu && *result.multiplicity == G::ZERO { aiur_fn_327(__args, record, io_buffer, false)? } else { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_327] = unsafe { *(result.output.as_ptr() as *const [G; OUT_327]) }; __ret } } else { aiur_fn_327(__args, record, io_buffer, __cu)? } }; + let __r_arr: [G; OUT_323] = { let __args: [G; IN_323] = [__v_3, __v_1]; let __cu = unconstrained; if let Some(result) = record.function_queries[323].get_mut(&__args[..]) { if !__cu && *result.multiplicity == G::ZERO { aiur_fn_323(__args, record, io_buffer, false)? } else { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_323] = unsafe { *(result.output.as_ptr() as *const [G; OUT_323]) }; __ret } } else { aiur_fn_323(__args, record, io_buffer, __cu)? } }; let __v_5: G = __r_arr[0]; match __v_5.as_canonical_u64() { 1u64 => { let __v_6: G = G::from_u64(1); - let __ret: [G; OUT_328] = [__v_6]; - if let Some(result) = record.function_queries[328].get_mut(&inp[..]) { debug_assert_eq!(result.output, &__ret[..]); if !unconstrained { *result.multiplicity += G::ONE; } } else { record.function_queries[328].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained)); }; + let __ret: [G; OUT_324] = [__v_6]; + if let Some(result) = record.function_queries[324].get_mut(&inp[..]) { debug_assert_eq!(result.output, &__ret[..]); if !unconstrained { *result.multiplicity += G::ONE; } } else { record.function_queries[324].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained)); }; return Ok(__ret); }, 0u64 => { - let __r_arr: [G; OUT_327] = { let __args: [G; IN_327] = [__v_4, __v_1]; let __cu = unconstrained; if let Some(result) = record.function_queries[327].get_mut(&__args[..]) { if !__cu && *result.multiplicity == G::ZERO { aiur_fn_327(__args, record, io_buffer, false)? } else { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_327] = unsafe { *(result.output.as_ptr() as *const [G; OUT_327]) }; __ret } } else { aiur_fn_327(__args, record, io_buffer, __cu)? } }; + let __r_arr: [G; OUT_323] = { let __args: [G; IN_323] = [__v_4, __v_1]; let __cu = unconstrained; if let Some(result) = record.function_queries[323].get_mut(&__args[..]) { if !__cu && *result.multiplicity == G::ZERO { aiur_fn_323(__args, record, io_buffer, false)? } else { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_323] = unsafe { *(result.output.as_ptr() as *const [G; OUT_323]) }; __ret } } else { aiur_fn_323(__args, record, io_buffer, __cu)? } }; let __v_6: G = __r_arr[0]; - let __ret: [G; OUT_328] = [__v_6]; - if let Some(result) = record.function_queries[328].get_mut(&inp[..]) { debug_assert_eq!(result.output, &__ret[..]); if !unconstrained { *result.multiplicity += G::ONE; } } else { record.function_queries[328].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained)); }; + let __ret: [G; OUT_324] = [__v_6]; + if let Some(result) = record.function_queries[324].get_mut(&inp[..]) { debug_assert_eq!(result.output, &__ret[..]); if !unconstrained { *result.multiplicity += G::ONE; } } else { record.function_queries[324].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained)); }; return Ok(__ret); }, _ => { @@ -30953,48 +30679,48 @@ fn aiur_fn_328( }, _ => { let __v_5: G = G::from_u64(0); - let __ret: [G; OUT_328] = [__v_5]; - if let Some(result) = record.function_queries[328].get_mut(&inp[..]) { debug_assert_eq!(result.output, &__ret[..]); if !unconstrained { *result.multiplicity += G::ONE; } } else { record.function_queries[328].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained)); }; + let __ret: [G; OUT_324] = [__v_5]; + if let Some(result) = record.function_queries[324].get_mut(&inp[..]) { debug_assert_eq!(result.output, &__ret[..]); if !unconstrained { *result.multiplicity += G::ONE; } } else { record.function_queries[324].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained)); }; return Ok(__ret); }, } }) } -const INPUT_SIZE_329: usize = 2; -const IN_329: usize = 2; -const OUT_329: usize = 1; -fn aiur_fn_329( - inp: [G; IN_329], +const INPUT_SIZE_325: usize = 2; +const IN_325: usize = 2; +const OUT_325: usize = 1; +fn aiur_fn_325( + inp: [G; IN_325], record: &mut QueryRecord, io_buffer: &mut IOBuffer, unconstrained: bool, -) -> Result<[G; OUT_329], ExecError> { +) -> Result<[G; OUT_325], ExecError> { stacker::maybe_grow(64 * 1024, 4 * 1024 * 1024, || { let __v_0: G = inp[0]; let __v_1: G = inp[1]; let __v_2: G = G::from_u64(0); - let __r_arr: [G; OUT_331] = { let __args: [G; IN_331] = [__v_0, __v_2]; let __cu = unconstrained; if let Some(result) = record.function_queries[331].get_mut(&__args[..]) { if !__cu && *result.multiplicity == G::ZERO { aiur_fn_331(__args, record, io_buffer, false)? } else { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_331] = unsafe { *(result.output.as_ptr() as *const [G; OUT_331]) }; __ret } } else { aiur_fn_331(__args, record, io_buffer, __cu)? } }; + let __r_arr: [G; OUT_327] = { let __args: [G; IN_327] = [__v_0, __v_2]; let __cu = unconstrained; if let Some(result) = record.function_queries[327].get_mut(&__args[..]) { if !__cu && *result.multiplicity == G::ZERO { aiur_fn_327(__args, record, io_buffer, false)? } else { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_327] = unsafe { *(result.output.as_ptr() as *const [G; OUT_327]) }; __ret } } else { aiur_fn_327(__args, record, io_buffer, __cu)? } }; let __v_3: G = __r_arr[0]; let __v_4: G = __r_arr[1]; let __v_5: G = G::from_u64(0); - let __r_arr: [G; OUT_331] = { let __args: [G; IN_331] = [__v_1, __v_5]; let __cu = unconstrained; if let Some(result) = record.function_queries[331].get_mut(&__args[..]) { if !__cu && *result.multiplicity == G::ZERO { aiur_fn_331(__args, record, io_buffer, false)? } else { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_331] = unsafe { *(result.output.as_ptr() as *const [G; OUT_331]) }; __ret } } else { aiur_fn_331(__args, record, io_buffer, __cu)? } }; + let __r_arr: [G; OUT_327] = { let __args: [G; IN_327] = [__v_1, __v_5]; let __cu = unconstrained; if let Some(result) = record.function_queries[327].get_mut(&__args[..]) { if !__cu && *result.multiplicity == G::ZERO { aiur_fn_327(__args, record, io_buffer, false)? } else { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_327] = unsafe { *(result.output.as_ptr() as *const [G; OUT_327]) }; __ret } } else { aiur_fn_327(__args, record, io_buffer, __cu)? } }; let __v_6: G = __r_arr[0]; let __v_7: G = __r_arr[1]; - let __r_arr: [G; OUT_327] = { let __args: [G; IN_327] = [__v_3, __v_6]; let __cu = unconstrained; if let Some(result) = record.function_queries[327].get_mut(&__args[..]) { if !__cu && *result.multiplicity == G::ZERO { aiur_fn_327(__args, record, io_buffer, false)? } else { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_327] = unsafe { *(result.output.as_ptr() as *const [G; OUT_327]) }; __ret } } else { aiur_fn_327(__args, record, io_buffer, __cu)? } }; + let __r_arr: [G; OUT_323] = { let __args: [G; IN_323] = [__v_3, __v_6]; let __cu = unconstrained; if let Some(result) = record.function_queries[323].get_mut(&__args[..]) { if !__cu && *result.multiplicity == G::ZERO { aiur_fn_323(__args, record, io_buffer, false)? } else { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_323] = unsafe { *(result.output.as_ptr() as *const [G; OUT_323]) }; __ret } } else { aiur_fn_323(__args, record, io_buffer, __cu)? } }; let __v_8: G = __r_arr[0]; match __v_8.as_canonical_u64() { 1u64 => { let __v_9: G = { let __a_val = __v_4.as_canonical_u64(); let __b_val = __v_7.as_canonical_u64(); let __a_u32 = u32::try_from(__a_val).ok().ok_or(ExecError::U32OutOfRange(__a_val))?; let __b_u32 = u32::try_from(__b_val).ok().ok_or(ExecError::U32OutOfRange(__b_val))?; let __result = G::from_bool(__a_u32 < __b_u32); if !unconstrained { let __x_bytes = __a_u32.to_le_bytes(); let __z_bytes = __b_u32.to_le_bytes(); let __c_u32 = __b_u32.wrapping_sub(__a_u32).wrapping_sub(1); let __y_bytes = __c_u32.to_le_bytes(); record.bytes2_queries.bump_range_check(&G::from_u8(__x_bytes[0]), &G::from_u8(__x_bytes[1])); record.bytes2_queries.bump_range_check(&G::from_u8(__x_bytes[2]), &G::from_u8(__x_bytes[3])); record.bytes2_queries.bump_range_check(&G::from_u8(__y_bytes[0]), &G::from_u8(__y_bytes[1])); record.bytes2_queries.bump_range_check(&G::from_u8(__y_bytes[2]), &G::from_u8(__y_bytes[3])); record.bytes2_queries.bump_range_check(&G::from_u8(__z_bytes[0]), &G::from_u8(__z_bytes[1])); record.bytes2_queries.bump_range_check(&G::from_u8(__z_bytes[2]), &G::from_u8(__z_bytes[3])); } __result }; match __v_9.as_canonical_u64() { 1u64 => { - let __ret: [G; OUT_329] = [__v_1]; - if let Some(result) = record.function_queries[329].get_mut(&inp[..]) { debug_assert_eq!(result.output, &__ret[..]); if !unconstrained { *result.multiplicity += G::ONE; } } else { record.function_queries[329].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained)); }; + let __ret: [G; OUT_325] = [__v_1]; + if let Some(result) = record.function_queries[325].get_mut(&inp[..]) { debug_assert_eq!(result.output, &__ret[..]); if !unconstrained { *result.multiplicity += G::ONE; } } else { record.function_queries[325].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained)); }; return Ok(__ret); }, 0u64 => { - let __ret: [G; OUT_329] = [__v_0]; - if let Some(result) = record.function_queries[329].get_mut(&inp[..]) { debug_assert_eq!(result.output, &__ret[..]); if !unconstrained { *result.multiplicity += G::ONE; } } else { record.function_queries[329].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained)); }; + let __ret: [G; OUT_325] = [__v_0]; + if let Some(result) = record.function_queries[325].get_mut(&inp[..]) { debug_assert_eq!(result.output, &__ret[..]); if !unconstrained { *result.multiplicity += G::ONE; } } else { record.function_queries[325].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained)); }; return Ok(__ret); }, _ => { @@ -31005,8 +30731,8 @@ fn aiur_fn_329( 0u64 => { let __v_9: G = G::from_u64(2); let __v_10: G = { let __values: [G; 3] = [__v_9, __v_0, __v_1]; let __mq = record.memory_queries.get_mut(&3).ok_or(ExecError::InvalidMemorySize(3))?; if let Some(result) = __mq.get_mut(&__values[..]) { if !unconstrained { *result.multiplicity += G::ONE; } result.output[0] } else { let __ptr = G::from_usize(__mq.len()); __mq.insert(&__values[..], &[__ptr], G::from_bool(!unconstrained)); __ptr } }; - let __ret: [G; OUT_329] = [__v_10]; - if let Some(result) = record.function_queries[329].get_mut(&inp[..]) { debug_assert_eq!(result.output, &__ret[..]); if !unconstrained { *result.multiplicity += G::ONE; } } else { record.function_queries[329].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained)); }; + let __ret: [G; OUT_325] = [__v_10]; + if let Some(result) = record.function_queries[325].get_mut(&inp[..]) { debug_assert_eq!(result.output, &__ret[..]); if !unconstrained { *result.multiplicity += G::ONE; } } else { record.function_queries[325].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained)); }; return Ok(__ret); }, _ => { @@ -31016,15 +30742,15 @@ fn aiur_fn_329( }) } -const INPUT_SIZE_330: usize = 1; -const IN_330: usize = 1; -const OUT_330: usize = 2; -fn aiur_fn_330( - inp: [G; IN_330], +const INPUT_SIZE_326: usize = 1; +const IN_326: usize = 1; +const OUT_326: usize = 2; +fn aiur_fn_326( + inp: [G; IN_326], record: &mut QueryRecord, io_buffer: &mut IOBuffer, unconstrained: bool, -) -> Result<[G; OUT_330], ExecError> { +) -> Result<[G; OUT_326], ExecError> { stacker::maybe_grow(64 * 1024, 4 * 1024 * 1024, || { let __v_0: G = inp[0]; let __loaded: [G; 3] = { let __mq = record.memory_queries.get_mut(&3).ok_or(ExecError::InvalidMemorySize(3))?; let __ptr_u64 = __v_0.as_canonical_u64(); let __ptr_usize = usize::try_from(__ptr_u64).ok().ok_or(ExecError::PointerTooLarge(__ptr_u64))?; let (__args, __mult) = __mq.get_index_mut(__ptr_usize).ok_or(ExecError::UnboundPointer { ptr: __ptr_u64, size: 3 })?; if !unconstrained { *__mult += G::ONE; } let __arr: [G; 3] = __args[..3].try_into().unwrap(); __arr }; @@ -31035,12 +30761,12 @@ fn aiur_fn_330( 0u64 => { let __v_4: G = G::from_u64(1); let __v_5: G = G::from_u64(0); - let __ret: [G; OUT_330] = [__v_4, __v_5]; - if let Some(result) = record.function_queries[330].get_mut(&inp[..]) { debug_assert_eq!(result.output, &__ret[..]); if !unconstrained { *result.multiplicity += G::ONE; } } else { record.function_queries[330].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained)); }; + let __ret: [G; OUT_326] = [__v_4, __v_5]; + if let Some(result) = record.function_queries[326].get_mut(&inp[..]) { debug_assert_eq!(result.output, &__ret[..]); if !unconstrained { *result.multiplicity += G::ONE; } } else { record.function_queries[326].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained)); }; return Ok(__ret); }, 1u64 => { - let __r_arr: [G; OUT_330] = { let __args: [G; IN_330] = [__v_2]; let __cu = unconstrained; if let Some(result) = record.function_queries[330].get_mut(&__args[..]) { if !__cu && *result.multiplicity == G::ZERO { aiur_fn_330(__args, record, io_buffer, false)? } else { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_330] = unsafe { *(result.output.as_ptr() as *const [G; OUT_330]) }; __ret } } else { aiur_fn_330(__args, record, io_buffer, __cu)? } }; + let __r_arr: [G; OUT_326] = { let __args: [G; IN_326] = [__v_2]; let __cu = unconstrained; if let Some(result) = record.function_queries[326].get_mut(&__args[..]) { if !__cu && *result.multiplicity == G::ZERO { aiur_fn_326(__args, record, io_buffer, false)? } else { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_326] = unsafe { *(result.output.as_ptr() as *const [G; OUT_326]) }; __ret } } else { aiur_fn_326(__args, record, io_buffer, __cu)? } }; let __v_4: G = __r_arr[0]; let __v_5: G = __r_arr[1]; match __v_4.as_canonical_u64() { @@ -31048,15 +30774,15 @@ fn aiur_fn_330( let __v_6: G = G::from_u64(1); let __v_7: G = G::from_u64(1); let __v_8: G = (__v_5 + __v_7); - let __ret: [G; OUT_330] = [__v_6, __v_8]; - if let Some(result) = record.function_queries[330].get_mut(&inp[..]) { debug_assert_eq!(result.output, &__ret[..]); if !unconstrained { *result.multiplicity += G::ONE; } } else { record.function_queries[330].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained)); }; + let __ret: [G; OUT_326] = [__v_6, __v_8]; + if let Some(result) = record.function_queries[326].get_mut(&inp[..]) { debug_assert_eq!(result.output, &__ret[..]); if !unconstrained { *result.multiplicity += G::ONE; } } else { record.function_queries[326].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained)); }; return Ok(__ret); }, _ => { let __v_6: G = G::from_u64(0); let __v_7: G = G::from_u64(0); - let __ret: [G; OUT_330] = [__v_6, __v_7]; - if let Some(result) = record.function_queries[330].get_mut(&inp[..]) { debug_assert_eq!(result.output, &__ret[..]); if !unconstrained { *result.multiplicity += G::ONE; } } else { record.function_queries[330].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained)); }; + let __ret: [G; OUT_326] = [__v_6, __v_7]; + if let Some(result) = record.function_queries[326].get_mut(&inp[..]) { debug_assert_eq!(result.output, &__ret[..]); if !unconstrained { *result.multiplicity += G::ONE; } } else { record.function_queries[326].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained)); }; return Ok(__ret); }, } @@ -31064,23 +30790,23 @@ fn aiur_fn_330( _ => { let __v_4: G = G::from_u64(0); let __v_5: G = G::from_u64(0); - let __ret: [G; OUT_330] = [__v_4, __v_5]; - if let Some(result) = record.function_queries[330].get_mut(&inp[..]) { debug_assert_eq!(result.output, &__ret[..]); if !unconstrained { *result.multiplicity += G::ONE; } } else { record.function_queries[330].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained)); }; + let __ret: [G; OUT_326] = [__v_4, __v_5]; + if let Some(result) = record.function_queries[326].get_mut(&inp[..]) { debug_assert_eq!(result.output, &__ret[..]); if !unconstrained { *result.multiplicity += G::ONE; } } else { record.function_queries[326].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained)); }; return Ok(__ret); }, } }) } -const INPUT_SIZE_331: usize = 2; -const IN_331: usize = 2; -const OUT_331: usize = 2; -fn aiur_fn_331( - inp: [G; IN_331], +const INPUT_SIZE_327: usize = 2; +const IN_327: usize = 2; +const OUT_327: usize = 2; +fn aiur_fn_327( + inp: [G; IN_327], record: &mut QueryRecord, io_buffer: &mut IOBuffer, unconstrained: bool, -) -> Result<[G; OUT_331], ExecError> { +) -> Result<[G; OUT_327], ExecError> { stacker::maybe_grow(64 * 1024, 4 * 1024 * 1024, || { let __v_0: G = inp[0]; let __v_1: G = inp[1]; @@ -31092,31 +30818,31 @@ fn aiur_fn_331( 1u64 => { let __v_5: G = G::from_u64(1); let __v_6: G = (__v_1 + __v_5); - let __r_arr: [G; OUT_331] = { let __args: [G; IN_331] = [__v_3, __v_6]; let __cu = unconstrained; if let Some(result) = record.function_queries[331].get_mut(&__args[..]) { if !__cu && *result.multiplicity == G::ZERO { aiur_fn_331(__args, record, io_buffer, false)? } else { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_331] = unsafe { *(result.output.as_ptr() as *const [G; OUT_331]) }; __ret } } else { aiur_fn_331(__args, record, io_buffer, __cu)? } }; + let __r_arr: [G; OUT_327] = { let __args: [G; IN_327] = [__v_3, __v_6]; let __cu = unconstrained; if let Some(result) = record.function_queries[327].get_mut(&__args[..]) { if !__cu && *result.multiplicity == G::ZERO { aiur_fn_327(__args, record, io_buffer, false)? } else { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_327] = unsafe { *(result.output.as_ptr() as *const [G; OUT_327]) }; __ret } } else { aiur_fn_327(__args, record, io_buffer, __cu)? } }; let __v_7: G = __r_arr[0]; let __v_8: G = __r_arr[1]; - let __ret: [G; OUT_331] = [__v_7, __v_8]; - if let Some(result) = record.function_queries[331].get_mut(&inp[..]) { debug_assert_eq!(result.output, &__ret[..]); if !unconstrained { *result.multiplicity += G::ONE; } } else { record.function_queries[331].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained)); }; + let __ret: [G; OUT_327] = [__v_7, __v_8]; + if let Some(result) = record.function_queries[327].get_mut(&inp[..]) { debug_assert_eq!(result.output, &__ret[..]); if !unconstrained { *result.multiplicity += G::ONE; } } else { record.function_queries[327].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained)); }; return Ok(__ret); }, _ => { - let __ret: [G; OUT_331] = [__v_0, __v_1]; - if let Some(result) = record.function_queries[331].get_mut(&inp[..]) { debug_assert_eq!(result.output, &__ret[..]); if !unconstrained { *result.multiplicity += G::ONE; } } else { record.function_queries[331].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained)); }; + let __ret: [G; OUT_327] = [__v_0, __v_1]; + if let Some(result) = record.function_queries[327].get_mut(&inp[..]) { debug_assert_eq!(result.output, &__ret[..]); if !unconstrained { *result.multiplicity += G::ONE; } } else { record.function_queries[327].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained)); }; return Ok(__ret); }, } }) } -const INPUT_SIZE_332: usize = 2; -const IN_332: usize = 2; -const OUT_332: usize = 1; -fn aiur_fn_332( - inp: [G; IN_332], +const INPUT_SIZE_328: usize = 2; +const IN_328: usize = 2; +const OUT_328: usize = 1; +fn aiur_fn_328( + inp: [G; IN_328], record: &mut QueryRecord, io_buffer: &mut IOBuffer, unconstrained: bool, -) -> Result<[G; OUT_332], ExecError> { +) -> Result<[G; OUT_328], ExecError> { stacker::maybe_grow(64 * 1024, 4 * 1024 * 1024, || { let __v_0: G = inp[0]; let __v_1: G = inp[1]; @@ -31129,26 +30855,26 @@ fn aiur_fn_332( let __v_5: G = G::from_u64(0); let __v_6: G = G::from_u64(0); let __v_7: G = { let __values: [G; 3] = [__v_5, __v_6, __v_6]; let __mq = record.memory_queries.get_mut(&3).ok_or(ExecError::InvalidMemorySize(3))?; if let Some(result) = __mq.get_mut(&__values[..]) { if !unconstrained { *result.multiplicity += G::ONE; } result.output[0] } else { let __ptr = G::from_usize(__mq.len()); __mq.insert(&__values[..], &[__ptr], G::from_bool(!unconstrained)); __ptr } }; - let __ret: [G; OUT_332] = [__v_7]; - if let Some(result) = record.function_queries[332].get_mut(&inp[..]) { debug_assert_eq!(result.output, &__ret[..]); if !unconstrained { *result.multiplicity += G::ONE; } } else { record.function_queries[332].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained)); }; + let __ret: [G; OUT_328] = [__v_7]; + if let Some(result) = record.function_queries[328].get_mut(&inp[..]) { debug_assert_eq!(result.output, &__ret[..]); if !unconstrained { *result.multiplicity += G::ONE; } } else { record.function_queries[328].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained)); }; return Ok(__ret); }, 1u64 => { - let __r_arr: [G; OUT_325] = { let __args: [G; IN_325] = [__v_0, __v_1]; let __cu = unconstrained; if let Some(result) = record.function_queries[325].get_mut(&__args[..]) { if !__cu && *result.multiplicity == G::ZERO { aiur_fn_325(__args, record, io_buffer, false)? } else { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_325] = unsafe { *(result.output.as_ptr() as *const [G; OUT_325]) }; __ret } } else { aiur_fn_325(__args, record, io_buffer, __cu)? } }; + let __r_arr: [G; OUT_321] = { let __args: [G; IN_321] = [__v_0, __v_1]; let __cu = unconstrained; if let Some(result) = record.function_queries[321].get_mut(&__args[..]) { if !__cu && *result.multiplicity == G::ZERO { aiur_fn_321(__args, record, io_buffer, false)? } else { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_321] = unsafe { *(result.output.as_ptr() as *const [G; OUT_321]) }; __ret } } else { aiur_fn_321(__args, record, io_buffer, __cu)? } }; let __v_5: G = __r_arr[0]; - let __ret: [G; OUT_332] = [__v_5]; - if let Some(result) = record.function_queries[332].get_mut(&inp[..]) { debug_assert_eq!(result.output, &__ret[..]); if !unconstrained { *result.multiplicity += G::ONE; } } else { record.function_queries[332].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained)); }; + let __ret: [G; OUT_328] = [__v_5]; + if let Some(result) = record.function_queries[328].get_mut(&inp[..]) { debug_assert_eq!(result.output, &__ret[..]); if !unconstrained { *result.multiplicity += G::ONE; } } else { record.function_queries[328].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained)); }; return Ok(__ret); }, _ => { - let __r_arr: [G; OUT_297] = { let __args: [G; IN_297] = [__v_1]; let __cu = unconstrained; if let Some(result) = record.function_queries[297].get_mut(&__args[..]) { if !__cu && *result.multiplicity == G::ZERO { aiur_fn_297(__args, record, io_buffer, false)? } else { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_297] = unsafe { *(result.output.as_ptr() as *const [G; OUT_297]) }; __ret } } else { aiur_fn_297(__args, record, io_buffer, __cu)? } }; + let __r_arr: [G; OUT_293] = { let __args: [G; IN_293] = [__v_1]; let __cu = unconstrained; if let Some(result) = record.function_queries[293].get_mut(&__args[..]) { if !__cu && *result.multiplicity == G::ZERO { aiur_fn_293(__args, record, io_buffer, false)? } else { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_293] = unsafe { *(result.output.as_ptr() as *const [G; OUT_293]) }; __ret } } else { aiur_fn_293(__args, record, io_buffer, __cu)? } }; let __v_5: G = __r_arr[0]; match __v_5.as_canonical_u64() { 1u64 => { - let __r_arr: [G; OUT_325] = { let __args: [G; IN_325] = [__v_0, __v_1]; let __cu = unconstrained; if let Some(result) = record.function_queries[325].get_mut(&__args[..]) { if !__cu && *result.multiplicity == G::ZERO { aiur_fn_325(__args, record, io_buffer, false)? } else { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_325] = unsafe { *(result.output.as_ptr() as *const [G; OUT_325]) }; __ret } } else { aiur_fn_325(__args, record, io_buffer, __cu)? } }; + let __r_arr: [G; OUT_321] = { let __args: [G; IN_321] = [__v_0, __v_1]; let __cu = unconstrained; if let Some(result) = record.function_queries[321].get_mut(&__args[..]) { if !__cu && *result.multiplicity == G::ZERO { aiur_fn_321(__args, record, io_buffer, false)? } else { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_321] = unsafe { *(result.output.as_ptr() as *const [G; OUT_321]) }; __ret } } else { aiur_fn_321(__args, record, io_buffer, __cu)? } }; let __v_6: G = __r_arr[0]; - let __ret: [G; OUT_332] = [__v_6]; - if let Some(result) = record.function_queries[332].get_mut(&inp[..]) { debug_assert_eq!(result.output, &__ret[..]); if !unconstrained { *result.multiplicity += G::ONE; } } else { record.function_queries[332].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained)); }; + let __ret: [G; OUT_328] = [__v_6]; + if let Some(result) = record.function_queries[328].get_mut(&inp[..]) { debug_assert_eq!(result.output, &__ret[..]); if !unconstrained { *result.multiplicity += G::ONE; } } else { record.function_queries[328].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained)); }; return Ok(__ret); }, 0u64 => { @@ -31158,24 +30884,24 @@ fn aiur_fn_332( let __v_8: G = __loaded[2]; match __v_6.as_canonical_u64() { 0u64 => { - let __ret: [G; OUT_332] = [__v_1]; - if let Some(result) = record.function_queries[332].get_mut(&inp[..]) { debug_assert_eq!(result.output, &__ret[..]); if !unconstrained { *result.multiplicity += G::ONE; } } else { record.function_queries[332].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained)); }; + let __ret: [G; OUT_328] = [__v_1]; + if let Some(result) = record.function_queries[328].get_mut(&inp[..]) { debug_assert_eq!(result.output, &__ret[..]); if !unconstrained { *result.multiplicity += G::ONE; } } else { record.function_queries[328].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained)); }; return Ok(__ret); }, _ => { - let __r_arr: [G; OUT_298] = { let __args: [G; IN_298] = [__v_0, __v_1]; let __cu = unconstrained; if let Some(result) = record.function_queries[298].get_mut(&__args[..]) { if !__cu && *result.multiplicity == G::ZERO { aiur_fn_298(__args, record, io_buffer, false)? } else { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_298] = unsafe { *(result.output.as_ptr() as *const [G; OUT_298]) }; __ret } } else { aiur_fn_298(__args, record, io_buffer, __cu)? } }; + let __r_arr: [G; OUT_294] = { let __args: [G; IN_294] = [__v_0, __v_1]; let __cu = unconstrained; if let Some(result) = record.function_queries[294].get_mut(&__args[..]) { if !__cu && *result.multiplicity == G::ZERO { aiur_fn_294(__args, record, io_buffer, false)? } else { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_294] = unsafe { *(result.output.as_ptr() as *const [G; OUT_294]) }; __ret } } else { aiur_fn_294(__args, record, io_buffer, __cu)? } }; let __v_9: G = __r_arr[0]; match __v_9.as_canonical_u64() { 1u64 => { - let __ret: [G; OUT_332] = [__v_0]; - if let Some(result) = record.function_queries[332].get_mut(&inp[..]) { debug_assert_eq!(result.output, &__ret[..]); if !unconstrained { *result.multiplicity += G::ONE; } } else { record.function_queries[332].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained)); }; + let __ret: [G; OUT_328] = [__v_0]; + if let Some(result) = record.function_queries[328].get_mut(&inp[..]) { debug_assert_eq!(result.output, &__ret[..]); if !unconstrained { *result.multiplicity += G::ONE; } } else { record.function_queries[328].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained)); }; return Ok(__ret); }, 0u64 => { let __v_10: G = G::from_u64(3); let __v_11: G = { let __values: [G; 3] = [__v_10, __v_0, __v_1]; let __mq = record.memory_queries.get_mut(&3).ok_or(ExecError::InvalidMemorySize(3))?; if let Some(result) = __mq.get_mut(&__values[..]) { if !unconstrained { *result.multiplicity += G::ONE; } result.output[0] } else { let __ptr = G::from_usize(__mq.len()); __mq.insert(&__values[..], &[__ptr], G::from_bool(!unconstrained)); __ptr } }; - let __ret: [G; OUT_332] = [__v_11]; - if let Some(result) = record.function_queries[332].get_mut(&inp[..]) { debug_assert_eq!(result.output, &__ret[..]); if !unconstrained { *result.multiplicity += G::ONE; } } else { record.function_queries[332].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained)); }; + let __ret: [G; OUT_328] = [__v_11]; + if let Some(result) = record.function_queries[328].get_mut(&inp[..]) { debug_assert_eq!(result.output, &__ret[..]); if !unconstrained { *result.multiplicity += G::ONE; } } else { record.function_queries[328].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained)); }; return Ok(__ret); }, _ => { @@ -31194,15 +30920,15 @@ fn aiur_fn_332( }) } -const INPUT_SIZE_333: usize = 1; -const IN_333: usize = 1; -const OUT_333: usize = 1; -fn aiur_fn_333( - inp: [G; IN_333], +const INPUT_SIZE_329: usize = 1; +const IN_329: usize = 1; +const OUT_329: usize = 1; +fn aiur_fn_329( + inp: [G; IN_329], record: &mut QueryRecord, io_buffer: &mut IOBuffer, unconstrained: bool, -) -> Result<[G; OUT_333], ExecError> { +) -> Result<[G; OUT_329], ExecError> { stacker::maybe_grow(64 * 1024, 4 * 1024 * 1024, || { let __v_0: G = inp[0]; let __loaded: [G; 3] = { let __mq = record.memory_queries.get_mut(&3).ok_or(ExecError::InvalidMemorySize(3))?; let __ptr_u64 = __v_0.as_canonical_u64(); let __ptr_usize = usize::try_from(__ptr_u64).ok().ok_or(ExecError::PointerTooLarge(__ptr_u64))?; let (__args, __mult) = __mq.get_index_mut(__ptr_usize).ok_or(ExecError::UnboundPointer { ptr: __ptr_u64, size: 3 })?; if !unconstrained { *__mult += G::ONE; } let __arr: [G; 3] = __args[..3].try_into().unwrap(); __arr }; @@ -31214,48 +30940,48 @@ fn aiur_fn_333( let __v_4: G = G::from_u64(0); let __v_5: G = G::from_u64(0); let __v_6: G = { let __values: [G; 3] = [__v_4, __v_5, __v_5]; let __mq = record.memory_queries.get_mut(&3).ok_or(ExecError::InvalidMemorySize(3))?; if let Some(result) = __mq.get_mut(&__values[..]) { if !unconstrained { *result.multiplicity += G::ONE; } result.output[0] } else { let __ptr = G::from_usize(__mq.len()); __mq.insert(&__values[..], &[__ptr], G::from_bool(!unconstrained)); __ptr } }; - let __ret: [G; OUT_333] = [__v_6]; - if let Some(result) = record.function_queries[333].get_mut(&inp[..]) { debug_assert_eq!(result.output, &__ret[..]); if !unconstrained { *result.multiplicity += G::ONE; } } else { record.function_queries[333].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained)); }; + let __ret: [G; OUT_329] = [__v_6]; + if let Some(result) = record.function_queries[329].get_mut(&inp[..]) { debug_assert_eq!(result.output, &__ret[..]); if !unconstrained { *result.multiplicity += G::ONE; } } else { record.function_queries[329].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained)); }; return Ok(__ret); }, 4u64 => { let __v_4: G = G::from_u64(4); let __v_5: G = G::from_u64(0); let __v_6: G = { let __values: [G; 3] = [__v_4, __v_2, __v_5]; let __mq = record.memory_queries.get_mut(&3).ok_or(ExecError::InvalidMemorySize(3))?; if let Some(result) = __mq.get_mut(&__values[..]) { if !unconstrained { *result.multiplicity += G::ONE; } result.output[0] } else { let __ptr = G::from_usize(__mq.len()); __mq.insert(&__values[..], &[__ptr], G::from_bool(!unconstrained)); __ptr } }; - let __ret: [G; OUT_333] = [__v_6]; - if let Some(result) = record.function_queries[333].get_mut(&inp[..]) { debug_assert_eq!(result.output, &__ret[..]); if !unconstrained { *result.multiplicity += G::ONE; } } else { record.function_queries[333].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained)); }; + let __ret: [G; OUT_329] = [__v_6]; + if let Some(result) = record.function_queries[329].get_mut(&inp[..]) { debug_assert_eq!(result.output, &__ret[..]); if !unconstrained { *result.multiplicity += G::ONE; } } else { record.function_queries[329].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained)); }; return Ok(__ret); }, 1u64 => { let __v_4: G = G::from_u64(1); - let __r_arr: [G; OUT_333] = { let __args: [G; IN_333] = [__v_2]; let __cu = unconstrained; if let Some(result) = record.function_queries[333].get_mut(&__args[..]) { if !__cu && *result.multiplicity == G::ZERO { aiur_fn_333(__args, record, io_buffer, false)? } else { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_333] = unsafe { *(result.output.as_ptr() as *const [G; OUT_333]) }; __ret } } else { aiur_fn_333(__args, record, io_buffer, __cu)? } }; + let __r_arr: [G; OUT_329] = { let __args: [G; IN_329] = [__v_2]; let __cu = unconstrained; if let Some(result) = record.function_queries[329].get_mut(&__args[..]) { if !__cu && *result.multiplicity == G::ZERO { aiur_fn_329(__args, record, io_buffer, false)? } else { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_329] = unsafe { *(result.output.as_ptr() as *const [G; OUT_329]) }; __ret } } else { aiur_fn_329(__args, record, io_buffer, __cu)? } }; let __v_5: G = __r_arr[0]; let __v_6: G = G::from_u64(0); let __v_7: G = { let __values: [G; 3] = [__v_4, __v_5, __v_6]; let __mq = record.memory_queries.get_mut(&3).ok_or(ExecError::InvalidMemorySize(3))?; if let Some(result) = __mq.get_mut(&__values[..]) { if !unconstrained { *result.multiplicity += G::ONE; } result.output[0] } else { let __ptr = G::from_usize(__mq.len()); __mq.insert(&__values[..], &[__ptr], G::from_bool(!unconstrained)); __ptr } }; - let __ret: [G; OUT_333] = [__v_7]; - if let Some(result) = record.function_queries[333].get_mut(&inp[..]) { debug_assert_eq!(result.output, &__ret[..]); if !unconstrained { *result.multiplicity += G::ONE; } } else { record.function_queries[333].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained)); }; + let __ret: [G; OUT_329] = [__v_7]; + if let Some(result) = record.function_queries[329].get_mut(&inp[..]) { debug_assert_eq!(result.output, &__ret[..]); if !unconstrained { *result.multiplicity += G::ONE; } } else { record.function_queries[329].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained)); }; return Ok(__ret); }, 2u64 => { - let __r_arr: [G; OUT_333] = { let __args: [G; IN_333] = [__v_2]; let __cu = unconstrained; if let Some(result) = record.function_queries[333].get_mut(&__args[..]) { if !__cu && *result.multiplicity == G::ZERO { aiur_fn_333(__args, record, io_buffer, false)? } else { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_333] = unsafe { *(result.output.as_ptr() as *const [G; OUT_333]) }; __ret } } else { aiur_fn_333(__args, record, io_buffer, __cu)? } }; + let __r_arr: [G; OUT_329] = { let __args: [G; IN_329] = [__v_2]; let __cu = unconstrained; if let Some(result) = record.function_queries[329].get_mut(&__args[..]) { if !__cu && *result.multiplicity == G::ZERO { aiur_fn_329(__args, record, io_buffer, false)? } else { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_329] = unsafe { *(result.output.as_ptr() as *const [G; OUT_329]) }; __ret } } else { aiur_fn_329(__args, record, io_buffer, __cu)? } }; let __v_4: G = __r_arr[0]; - let __r_arr: [G; OUT_333] = { let __args: [G; IN_333] = [__v_3]; let __cu = unconstrained; if let Some(result) = record.function_queries[333].get_mut(&__args[..]) { if !__cu && *result.multiplicity == G::ZERO { aiur_fn_333(__args, record, io_buffer, false)? } else { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_333] = unsafe { *(result.output.as_ptr() as *const [G; OUT_333]) }; __ret } } else { aiur_fn_333(__args, record, io_buffer, __cu)? } }; + let __r_arr: [G; OUT_329] = { let __args: [G; IN_329] = [__v_3]; let __cu = unconstrained; if let Some(result) = record.function_queries[329].get_mut(&__args[..]) { if !__cu && *result.multiplicity == G::ZERO { aiur_fn_329(__args, record, io_buffer, false)? } else { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_329] = unsafe { *(result.output.as_ptr() as *const [G; OUT_329]) }; __ret } } else { aiur_fn_329(__args, record, io_buffer, __cu)? } }; let __v_5: G = __r_arr[0]; - let __r_arr: [G; OUT_325] = { let __args: [G; IN_325] = [__v_4, __v_5]; let __cu = unconstrained; if let Some(result) = record.function_queries[325].get_mut(&__args[..]) { if !__cu && *result.multiplicity == G::ZERO { aiur_fn_325(__args, record, io_buffer, false)? } else { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_325] = unsafe { *(result.output.as_ptr() as *const [G; OUT_325]) }; __ret } } else { aiur_fn_325(__args, record, io_buffer, __cu)? } }; + let __r_arr: [G; OUT_321] = { let __args: [G; IN_321] = [__v_4, __v_5]; let __cu = unconstrained; if let Some(result) = record.function_queries[321].get_mut(&__args[..]) { if !__cu && *result.multiplicity == G::ZERO { aiur_fn_321(__args, record, io_buffer, false)? } else { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_321] = unsafe { *(result.output.as_ptr() as *const [G; OUT_321]) }; __ret } } else { aiur_fn_321(__args, record, io_buffer, __cu)? } }; let __v_6: G = __r_arr[0]; - let __ret: [G; OUT_333] = [__v_6]; - if let Some(result) = record.function_queries[333].get_mut(&inp[..]) { debug_assert_eq!(result.output, &__ret[..]); if !unconstrained { *result.multiplicity += G::ONE; } } else { record.function_queries[333].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained)); }; + let __ret: [G; OUT_329] = [__v_6]; + if let Some(result) = record.function_queries[329].get_mut(&inp[..]) { debug_assert_eq!(result.output, &__ret[..]); if !unconstrained { *result.multiplicity += G::ONE; } } else { record.function_queries[329].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained)); }; return Ok(__ret); }, 3u64 => { - let __r_arr: [G; OUT_333] = { let __args: [G; IN_333] = [__v_2]; let __cu = unconstrained; if let Some(result) = record.function_queries[333].get_mut(&__args[..]) { if !__cu && *result.multiplicity == G::ZERO { aiur_fn_333(__args, record, io_buffer, false)? } else { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_333] = unsafe { *(result.output.as_ptr() as *const [G; OUT_333]) }; __ret } } else { aiur_fn_333(__args, record, io_buffer, __cu)? } }; + let __r_arr: [G; OUT_329] = { let __args: [G; IN_329] = [__v_2]; let __cu = unconstrained; if let Some(result) = record.function_queries[329].get_mut(&__args[..]) { if !__cu && *result.multiplicity == G::ZERO { aiur_fn_329(__args, record, io_buffer, false)? } else { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_329] = unsafe { *(result.output.as_ptr() as *const [G; OUT_329]) }; __ret } } else { aiur_fn_329(__args, record, io_buffer, __cu)? } }; let __v_4: G = __r_arr[0]; - let __r_arr: [G; OUT_333] = { let __args: [G; IN_333] = [__v_3]; let __cu = unconstrained; if let Some(result) = record.function_queries[333].get_mut(&__args[..]) { if !__cu && *result.multiplicity == G::ZERO { aiur_fn_333(__args, record, io_buffer, false)? } else { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_333] = unsafe { *(result.output.as_ptr() as *const [G; OUT_333]) }; __ret } } else { aiur_fn_333(__args, record, io_buffer, __cu)? } }; + let __r_arr: [G; OUT_329] = { let __args: [G; IN_329] = [__v_3]; let __cu = unconstrained; if let Some(result) = record.function_queries[329].get_mut(&__args[..]) { if !__cu && *result.multiplicity == G::ZERO { aiur_fn_329(__args, record, io_buffer, false)? } else { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_329] = unsafe { *(result.output.as_ptr() as *const [G; OUT_329]) }; __ret } } else { aiur_fn_329(__args, record, io_buffer, __cu)? } }; let __v_5: G = __r_arr[0]; - let __r_arr: [G; OUT_332] = { let __args: [G; IN_332] = [__v_4, __v_5]; let __cu = unconstrained; if let Some(result) = record.function_queries[332].get_mut(&__args[..]) { if !__cu && *result.multiplicity == G::ZERO { aiur_fn_332(__args, record, io_buffer, false)? } else { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_332] = unsafe { *(result.output.as_ptr() as *const [G; OUT_332]) }; __ret } } else { aiur_fn_332(__args, record, io_buffer, __cu)? } }; + let __r_arr: [G; OUT_328] = { let __args: [G; IN_328] = [__v_4, __v_5]; let __cu = unconstrained; if let Some(result) = record.function_queries[328].get_mut(&__args[..]) { if !__cu && *result.multiplicity == G::ZERO { aiur_fn_328(__args, record, io_buffer, false)? } else { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_328] = unsafe { *(result.output.as_ptr() as *const [G; OUT_328]) }; __ret } } else { aiur_fn_328(__args, record, io_buffer, __cu)? } }; let __v_6: G = __r_arr[0]; - let __ret: [G; OUT_333] = [__v_6]; - if let Some(result) = record.function_queries[333].get_mut(&inp[..]) { debug_assert_eq!(result.output, &__ret[..]); if !unconstrained { *result.multiplicity += G::ONE; } } else { record.function_queries[333].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained)); }; + let __ret: [G; OUT_329] = [__v_6]; + if let Some(result) = record.function_queries[329].get_mut(&inp[..]) { debug_assert_eq!(result.output, &__ret[..]); if !unconstrained { *result.multiplicity += G::ONE; } } else { record.function_queries[329].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained)); }; return Ok(__ret); }, _ => { @@ -31265,15 +30991,15 @@ fn aiur_fn_333( }) } -const INPUT_SIZE_334: usize = 2; -const IN_334: usize = 2; -const OUT_334: usize = 1; -fn aiur_fn_334( - inp: [G; IN_334], +const INPUT_SIZE_330: usize = 2; +const IN_330: usize = 2; +const OUT_330: usize = 1; +fn aiur_fn_330( + inp: [G; IN_330], record: &mut QueryRecord, io_buffer: &mut IOBuffer, unconstrained: bool, -) -> Result<[G; OUT_334], ExecError> { +) -> Result<[G; OUT_330], ExecError> { stacker::maybe_grow(64 * 1024, 4 * 1024 * 1024, || { let __v_0: G = inp[0]; let __v_1: G = inp[1]; @@ -31286,47 +31012,47 @@ fn aiur_fn_334( let __v_5: G = G::from_u64(0); let __v_6: G = G::from_u64(0); let __v_7: G = { let __values: [G; 3] = [__v_5, __v_6, __v_6]; let __mq = record.memory_queries.get_mut(&3).ok_or(ExecError::InvalidMemorySize(3))?; if let Some(result) = __mq.get_mut(&__values[..]) { if !unconstrained { *result.multiplicity += G::ONE; } result.output[0] } else { let __ptr = G::from_usize(__mq.len()); __mq.insert(&__values[..], &[__ptr], G::from_bool(!unconstrained)); __ptr } }; - let __ret: [G; OUT_334] = [__v_7]; - if let Some(result) = record.function_queries[334].get_mut(&inp[..]) { debug_assert_eq!(result.output, &__ret[..]); if !unconstrained { *result.multiplicity += G::ONE; } } else { record.function_queries[334].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained)); }; + let __ret: [G; OUT_330] = [__v_7]; + if let Some(result) = record.function_queries[330].get_mut(&inp[..]) { debug_assert_eq!(result.output, &__ret[..]); if !unconstrained { *result.multiplicity += G::ONE; } } else { record.function_queries[330].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained)); }; return Ok(__ret); }, 1u64 => { let __v_5: G = G::from_u64(1); - let __r_arr: [G; OUT_334] = { let __args: [G; IN_334] = [__v_3, __v_1]; let __cu = unconstrained; if let Some(result) = record.function_queries[334].get_mut(&__args[..]) { if !__cu && *result.multiplicity == G::ZERO { aiur_fn_334(__args, record, io_buffer, false)? } else { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_334] = unsafe { *(result.output.as_ptr() as *const [G; OUT_334]) }; __ret } } else { aiur_fn_334(__args, record, io_buffer, __cu)? } }; + let __r_arr: [G; OUT_330] = { let __args: [G; IN_330] = [__v_3, __v_1]; let __cu = unconstrained; if let Some(result) = record.function_queries[330].get_mut(&__args[..]) { if !__cu && *result.multiplicity == G::ZERO { aiur_fn_330(__args, record, io_buffer, false)? } else { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_330] = unsafe { *(result.output.as_ptr() as *const [G; OUT_330]) }; __ret } } else { aiur_fn_330(__args, record, io_buffer, __cu)? } }; let __v_6: G = __r_arr[0]; let __v_7: G = G::from_u64(0); let __v_8: G = { let __values: [G; 3] = [__v_5, __v_6, __v_7]; let __mq = record.memory_queries.get_mut(&3).ok_or(ExecError::InvalidMemorySize(3))?; if let Some(result) = __mq.get_mut(&__values[..]) { if !unconstrained { *result.multiplicity += G::ONE; } result.output[0] } else { let __ptr = G::from_usize(__mq.len()); __mq.insert(&__values[..], &[__ptr], G::from_bool(!unconstrained)); __ptr } }; - let __ret: [G; OUT_334] = [__v_8]; - if let Some(result) = record.function_queries[334].get_mut(&inp[..]) { debug_assert_eq!(result.output, &__ret[..]); if !unconstrained { *result.multiplicity += G::ONE; } } else { record.function_queries[334].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained)); }; + let __ret: [G; OUT_330] = [__v_8]; + if let Some(result) = record.function_queries[330].get_mut(&inp[..]) { debug_assert_eq!(result.output, &__ret[..]); if !unconstrained { *result.multiplicity += G::ONE; } } else { record.function_queries[330].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained)); }; return Ok(__ret); }, 2u64 => { - let __r_arr: [G; OUT_334] = { let __args: [G; IN_334] = [__v_3, __v_1]; let __cu = unconstrained; if let Some(result) = record.function_queries[334].get_mut(&__args[..]) { if !__cu && *result.multiplicity == G::ZERO { aiur_fn_334(__args, record, io_buffer, false)? } else { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_334] = unsafe { *(result.output.as_ptr() as *const [G; OUT_334]) }; __ret } } else { aiur_fn_334(__args, record, io_buffer, __cu)? } }; + let __r_arr: [G; OUT_330] = { let __args: [G; IN_330] = [__v_3, __v_1]; let __cu = unconstrained; if let Some(result) = record.function_queries[330].get_mut(&__args[..]) { if !__cu && *result.multiplicity == G::ZERO { aiur_fn_330(__args, record, io_buffer, false)? } else { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_330] = unsafe { *(result.output.as_ptr() as *const [G; OUT_330]) }; __ret } } else { aiur_fn_330(__args, record, io_buffer, __cu)? } }; let __v_5: G = __r_arr[0]; - let __r_arr: [G; OUT_334] = { let __args: [G; IN_334] = [__v_4, __v_1]; let __cu = unconstrained; if let Some(result) = record.function_queries[334].get_mut(&__args[..]) { if !__cu && *result.multiplicity == G::ZERO { aiur_fn_334(__args, record, io_buffer, false)? } else { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_334] = unsafe { *(result.output.as_ptr() as *const [G; OUT_334]) }; __ret } } else { aiur_fn_334(__args, record, io_buffer, __cu)? } }; + let __r_arr: [G; OUT_330] = { let __args: [G; IN_330] = [__v_4, __v_1]; let __cu = unconstrained; if let Some(result) = record.function_queries[330].get_mut(&__args[..]) { if !__cu && *result.multiplicity == G::ZERO { aiur_fn_330(__args, record, io_buffer, false)? } else { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_330] = unsafe { *(result.output.as_ptr() as *const [G; OUT_330]) }; __ret } } else { aiur_fn_330(__args, record, io_buffer, __cu)? } }; let __v_6: G = __r_arr[0]; - let __r_arr: [G; OUT_325] = { let __args: [G; IN_325] = [__v_5, __v_6]; let __cu = unconstrained; if let Some(result) = record.function_queries[325].get_mut(&__args[..]) { if !__cu && *result.multiplicity == G::ZERO { aiur_fn_325(__args, record, io_buffer, false)? } else { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_325] = unsafe { *(result.output.as_ptr() as *const [G; OUT_325]) }; __ret } } else { aiur_fn_325(__args, record, io_buffer, __cu)? } }; + let __r_arr: [G; OUT_321] = { let __args: [G; IN_321] = [__v_5, __v_6]; let __cu = unconstrained; if let Some(result) = record.function_queries[321].get_mut(&__args[..]) { if !__cu && *result.multiplicity == G::ZERO { aiur_fn_321(__args, record, io_buffer, false)? } else { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_321] = unsafe { *(result.output.as_ptr() as *const [G; OUT_321]) }; __ret } } else { aiur_fn_321(__args, record, io_buffer, __cu)? } }; let __v_7: G = __r_arr[0]; - let __ret: [G; OUT_334] = [__v_7]; - if let Some(result) = record.function_queries[334].get_mut(&inp[..]) { debug_assert_eq!(result.output, &__ret[..]); if !unconstrained { *result.multiplicity += G::ONE; } } else { record.function_queries[334].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained)); }; + let __ret: [G; OUT_330] = [__v_7]; + if let Some(result) = record.function_queries[330].get_mut(&inp[..]) { debug_assert_eq!(result.output, &__ret[..]); if !unconstrained { *result.multiplicity += G::ONE; } } else { record.function_queries[330].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained)); }; return Ok(__ret); }, 3u64 => { - let __r_arr: [G; OUT_334] = { let __args: [G; IN_334] = [__v_3, __v_1]; let __cu = unconstrained; if let Some(result) = record.function_queries[334].get_mut(&__args[..]) { if !__cu && *result.multiplicity == G::ZERO { aiur_fn_334(__args, record, io_buffer, false)? } else { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_334] = unsafe { *(result.output.as_ptr() as *const [G; OUT_334]) }; __ret } } else { aiur_fn_334(__args, record, io_buffer, __cu)? } }; + let __r_arr: [G; OUT_330] = { let __args: [G; IN_330] = [__v_3, __v_1]; let __cu = unconstrained; if let Some(result) = record.function_queries[330].get_mut(&__args[..]) { if !__cu && *result.multiplicity == G::ZERO { aiur_fn_330(__args, record, io_buffer, false)? } else { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_330] = unsafe { *(result.output.as_ptr() as *const [G; OUT_330]) }; __ret } } else { aiur_fn_330(__args, record, io_buffer, __cu)? } }; let __v_5: G = __r_arr[0]; - let __r_arr: [G; OUT_334] = { let __args: [G; IN_334] = [__v_4, __v_1]; let __cu = unconstrained; if let Some(result) = record.function_queries[334].get_mut(&__args[..]) { if !__cu && *result.multiplicity == G::ZERO { aiur_fn_334(__args, record, io_buffer, false)? } else { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_334] = unsafe { *(result.output.as_ptr() as *const [G; OUT_334]) }; __ret } } else { aiur_fn_334(__args, record, io_buffer, __cu)? } }; + let __r_arr: [G; OUT_330] = { let __args: [G; IN_330] = [__v_4, __v_1]; let __cu = unconstrained; if let Some(result) = record.function_queries[330].get_mut(&__args[..]) { if !__cu && *result.multiplicity == G::ZERO { aiur_fn_330(__args, record, io_buffer, false)? } else { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_330] = unsafe { *(result.output.as_ptr() as *const [G; OUT_330]) }; __ret } } else { aiur_fn_330(__args, record, io_buffer, __cu)? } }; let __v_6: G = __r_arr[0]; - let __r_arr: [G; OUT_332] = { let __args: [G; IN_332] = [__v_5, __v_6]; let __cu = unconstrained; if let Some(result) = record.function_queries[332].get_mut(&__args[..]) { if !__cu && *result.multiplicity == G::ZERO { aiur_fn_332(__args, record, io_buffer, false)? } else { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_332] = unsafe { *(result.output.as_ptr() as *const [G; OUT_332]) }; __ret } } else { aiur_fn_332(__args, record, io_buffer, __cu)? } }; + let __r_arr: [G; OUT_328] = { let __args: [G; IN_328] = [__v_5, __v_6]; let __cu = unconstrained; if let Some(result) = record.function_queries[328].get_mut(&__args[..]) { if !__cu && *result.multiplicity == G::ZERO { aiur_fn_328(__args, record, io_buffer, false)? } else { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_328] = unsafe { *(result.output.as_ptr() as *const [G; OUT_328]) }; __ret } } else { aiur_fn_328(__args, record, io_buffer, __cu)? } }; let __v_7: G = __r_arr[0]; - let __ret: [G; OUT_334] = [__v_7]; - if let Some(result) = record.function_queries[334].get_mut(&inp[..]) { debug_assert_eq!(result.output, &__ret[..]); if !unconstrained { *result.multiplicity += G::ONE; } } else { record.function_queries[334].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained)); }; + let __ret: [G; OUT_330] = [__v_7]; + if let Some(result) = record.function_queries[330].get_mut(&inp[..]) { debug_assert_eq!(result.output, &__ret[..]); if !unconstrained { *result.multiplicity += G::ONE; } } else { record.function_queries[330].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained)); }; return Ok(__ret); }, 4u64 => { - let __r_arr: [G; OUT_766] = { let __args: [G; IN_766] = [__v_1, __v_3]; let __cu = unconstrained; if let Some(result) = record.function_queries[766].get_mut(&__args[..]) { if !__cu && *result.multiplicity == G::ZERO { aiur_fn_766(__args, record, io_buffer, false)? } else { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_766] = unsafe { *(result.output.as_ptr() as *const [G; OUT_766]) }; __ret } } else { aiur_fn_766(__args, record, io_buffer, __cu)? } }; + let __r_arr: [G; OUT_762] = { let __args: [G; IN_762] = [__v_1, __v_3]; let __cu = unconstrained; if let Some(result) = record.function_queries[762].get_mut(&__args[..]) { if !__cu && *result.multiplicity == G::ZERO { aiur_fn_762(__args, record, io_buffer, false)? } else { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_762] = unsafe { *(result.output.as_ptr() as *const [G; OUT_762]) }; __ret } } else { aiur_fn_762(__args, record, io_buffer, __cu)? } }; let __v_5: G = __r_arr[0]; - let __ret: [G; OUT_334] = [__v_5]; - if let Some(result) = record.function_queries[334].get_mut(&inp[..]) { debug_assert_eq!(result.output, &__ret[..]); if !unconstrained { *result.multiplicity += G::ONE; } } else { record.function_queries[334].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained)); }; + let __ret: [G; OUT_330] = [__v_5]; + if let Some(result) = record.function_queries[330].get_mut(&inp[..]) { debug_assert_eq!(result.output, &__ret[..]); if !unconstrained { *result.multiplicity += G::ONE; } } else { record.function_queries[330].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained)); }; return Ok(__ret); }, _ => { @@ -31336,15 +31062,15 @@ fn aiur_fn_334( }) } -const INPUT_SIZE_335: usize = 2; -const IN_335: usize = 2; -const OUT_335: usize = 1; -fn aiur_fn_335( - inp: [G; IN_335], +const INPUT_SIZE_331: usize = 2; +const IN_331: usize = 2; +const OUT_331: usize = 1; +fn aiur_fn_331( + inp: [G; IN_331], record: &mut QueryRecord, io_buffer: &mut IOBuffer, unconstrained: bool, -) -> Result<[G; OUT_335], ExecError> { +) -> Result<[G; OUT_331], ExecError> { stacker::maybe_grow(64 * 1024, 4 * 1024 * 1024, || { let __v_0: G = inp[0]; let __v_1: G = inp[1]; @@ -31357,19 +31083,19 @@ fn aiur_fn_335( let __v_5: G = G::from_u64(1); let __v_6: G = G::from_u64(1); let __v_7: G = { let __values: [G; 3] = [__v_5, __v_6, __v_6]; let __mq = record.memory_queries.get_mut(&3).ok_or(ExecError::InvalidMemorySize(3))?; if let Some(result) = __mq.get_mut(&__values[..]) { if !unconstrained { *result.multiplicity += G::ONE; } result.output[0] } else { let __ptr = G::from_usize(__mq.len()); __mq.insert(&__values[..], &[__ptr], G::from_bool(!unconstrained)); __ptr } }; - let __ret: [G; OUT_335] = [__v_7]; - if let Some(result) = record.function_queries[335].get_mut(&inp[..]) { debug_assert_eq!(result.output, &__ret[..]); if !unconstrained { *result.multiplicity += G::ONE; } } else { record.function_queries[335].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained)); }; + let __ret: [G; OUT_331] = [__v_7]; + if let Some(result) = record.function_queries[331].get_mut(&inp[..]) { debug_assert_eq!(result.output, &__ret[..]); if !unconstrained { *result.multiplicity += G::ONE; } } else { record.function_queries[331].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained)); }; return Ok(__ret); }, 0u64 => { let __v_5: G = G::from_u64(0); - let __r_arr: [G; OUT_334] = { let __args: [G; IN_334] = [__v_3, __v_1]; let __cu = unconstrained; if let Some(result) = record.function_queries[334].get_mut(&__args[..]) { if !__cu && *result.multiplicity == G::ZERO { aiur_fn_334(__args, record, io_buffer, false)? } else { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_334] = unsafe { *(result.output.as_ptr() as *const [G; OUT_334]) }; __ret } } else { aiur_fn_334(__args, record, io_buffer, __cu)? } }; + let __r_arr: [G; OUT_330] = { let __args: [G; IN_330] = [__v_3, __v_1]; let __cu = unconstrained; if let Some(result) = record.function_queries[330].get_mut(&__args[..]) { if !__cu && *result.multiplicity == G::ZERO { aiur_fn_330(__args, record, io_buffer, false)? } else { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_330] = unsafe { *(result.output.as_ptr() as *const [G; OUT_330]) }; __ret } } else { aiur_fn_330(__args, record, io_buffer, __cu)? } }; let __v_6: G = __r_arr[0]; - let __r_arr: [G; OUT_335] = { let __args: [G; IN_335] = [__v_4, __v_1]; let __cu = unconstrained; if let Some(result) = record.function_queries[335].get_mut(&__args[..]) { if !__cu && *result.multiplicity == G::ZERO { aiur_fn_335(__args, record, io_buffer, false)? } else { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_335] = unsafe { *(result.output.as_ptr() as *const [G; OUT_335]) }; __ret } } else { aiur_fn_335(__args, record, io_buffer, __cu)? } }; + let __r_arr: [G; OUT_331] = { let __args: [G; IN_331] = [__v_4, __v_1]; let __cu = unconstrained; if let Some(result) = record.function_queries[331].get_mut(&__args[..]) { if !__cu && *result.multiplicity == G::ZERO { aiur_fn_331(__args, record, io_buffer, false)? } else { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_331] = unsafe { *(result.output.as_ptr() as *const [G; OUT_331]) }; __ret } } else { aiur_fn_331(__args, record, io_buffer, __cu)? } }; let __v_7: G = __r_arr[0]; let __v_8: G = { let __values: [G; 3] = [__v_5, __v_6, __v_7]; let __mq = record.memory_queries.get_mut(&3).ok_or(ExecError::InvalidMemorySize(3))?; if let Some(result) = __mq.get_mut(&__values[..]) { if !unconstrained { *result.multiplicity += G::ONE; } result.output[0] } else { let __ptr = G::from_usize(__mq.len()); __mq.insert(&__values[..], &[__ptr], G::from_bool(!unconstrained)); __ptr } }; - let __ret: [G; OUT_335] = [__v_8]; - if let Some(result) = record.function_queries[335].get_mut(&inp[..]) { debug_assert_eq!(result.output, &__ret[..]); if !unconstrained { *result.multiplicity += G::ONE; } } else { record.function_queries[335].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained)); }; + let __ret: [G; OUT_331] = [__v_8]; + if let Some(result) = record.function_queries[331].get_mut(&inp[..]) { debug_assert_eq!(result.output, &__ret[..]); if !unconstrained { *result.multiplicity += G::ONE; } } else { record.function_queries[331].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained)); }; return Ok(__ret); }, _ => { @@ -31379,15 +31105,15 @@ fn aiur_fn_335( }) } -const INPUT_SIZE_336: usize = 2; -const IN_336: usize = 2; -const OUT_336: usize = 1; -fn aiur_fn_336( - inp: [G; IN_336], +const INPUT_SIZE_332: usize = 2; +const IN_332: usize = 2; +const OUT_332: usize = 1; +fn aiur_fn_332( + inp: [G; IN_332], record: &mut QueryRecord, io_buffer: &mut IOBuffer, unconstrained: bool, -) -> Result<[G; OUT_336], ExecError> { +) -> Result<[G; OUT_332], ExecError> { stacker::maybe_grow(64 * 1024, 4 * 1024 * 1024, || { let __v_0: G = inp[0]; let __v_1: G = inp[1]; @@ -31397,30 +31123,30 @@ fn aiur_fn_336( let __v_4: G = __loaded[2]; match __v_2.as_canonical_u64() { 1u64 => { - let __ret: [G; OUT_336] = [__v_0]; - if let Some(result) = record.function_queries[336].get_mut(&inp[..]) { debug_assert_eq!(result.output, &__ret[..]); if !unconstrained { *result.multiplicity += G::ONE; } } else { record.function_queries[336].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained)); }; + let __ret: [G; OUT_332] = [__v_0]; + if let Some(result) = record.function_queries[332].get_mut(&inp[..]) { debug_assert_eq!(result.output, &__ret[..]); if !unconstrained { *result.multiplicity += G::ONE; } } else { record.function_queries[332].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained)); }; return Ok(__ret); }, _ => { - let __r_arr: [G; OUT_337] = { let __args: [G; IN_337] = [__v_0, __v_1]; let __cu = unconstrained; if let Some(result) = record.function_queries[337].get_mut(&__args[..]) { if !__cu && *result.multiplicity == G::ZERO { aiur_fn_337(__args, record, io_buffer, false)? } else { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_337] = unsafe { *(result.output.as_ptr() as *const [G; OUT_337]) }; __ret } } else { aiur_fn_337(__args, record, io_buffer, __cu)? } }; + let __r_arr: [G; OUT_333] = { let __args: [G; IN_333] = [__v_0, __v_1]; let __cu = unconstrained; if let Some(result) = record.function_queries[333].get_mut(&__args[..]) { if !__cu && *result.multiplicity == G::ZERO { aiur_fn_333(__args, record, io_buffer, false)? } else { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_333] = unsafe { *(result.output.as_ptr() as *const [G; OUT_333]) }; __ret } } else { aiur_fn_333(__args, record, io_buffer, __cu)? } }; let __v_5: G = __r_arr[0]; - let __ret: [G; OUT_336] = [__v_5]; - if let Some(result) = record.function_queries[336].get_mut(&inp[..]) { debug_assert_eq!(result.output, &__ret[..]); if !unconstrained { *result.multiplicity += G::ONE; } } else { record.function_queries[336].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained)); }; + let __ret: [G; OUT_332] = [__v_5]; + if let Some(result) = record.function_queries[332].get_mut(&inp[..]) { debug_assert_eq!(result.output, &__ret[..]); if !unconstrained { *result.multiplicity += G::ONE; } } else { record.function_queries[332].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained)); }; return Ok(__ret); }, } }) } -const INPUT_SIZE_337: usize = 2; -const IN_337: usize = 2; -const OUT_337: usize = 1; -fn aiur_fn_337( - inp: [G; IN_337], +const INPUT_SIZE_333: usize = 2; +const IN_333: usize = 2; +const OUT_333: usize = 1; +fn aiur_fn_333( + inp: [G; IN_333], record: &mut QueryRecord, io_buffer: &mut IOBuffer, unconstrained: bool, -) -> Result<[G; OUT_337], ExecError> { +) -> Result<[G; OUT_333], ExecError> { stacker::maybe_grow(64 * 1024, 4 * 1024 * 1024, || { let __v_0: G = inp[0]; let __v_1: G = inp[1]; @@ -31434,94 +31160,94 @@ fn aiur_fn_337( let __v_6: G = G::from_u64(0); let __v_7: G = G::from_u64(0); let __v_8: G = { let __values: [G; 4] = [__v_6, __v_3, __v_7, __v_7]; let __mq = record.memory_queries.get_mut(&4).ok_or(ExecError::InvalidMemorySize(4))?; if let Some(result) = __mq.get_mut(&__values[..]) { if !unconstrained { *result.multiplicity += G::ONE; } result.output[0] } else { let __ptr = G::from_usize(__mq.len()); __mq.insert(&__values[..], &[__ptr], G::from_bool(!unconstrained)); __ptr } }; - let __ret: [G; OUT_337] = [__v_8]; - if let Some(result) = record.function_queries[337].get_mut(&inp[..]) { debug_assert_eq!(result.output, &__ret[..]); if !unconstrained { *result.multiplicity += G::ONE; } } else { record.function_queries[337].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained)); }; + let __ret: [G; OUT_333] = [__v_8]; + if let Some(result) = record.function_queries[333].get_mut(&inp[..]) { debug_assert_eq!(result.output, &__ret[..]); if !unconstrained { *result.multiplicity += G::ONE; } } else { record.function_queries[333].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained)); }; return Ok(__ret); }, 1u64 => { let __v_6: G = G::from_u64(1); - let __r_arr: [G; OUT_334] = { let __args: [G; IN_334] = [__v_3, __v_1]; let __cu = unconstrained; if let Some(result) = record.function_queries[334].get_mut(&__args[..]) { if !__cu && *result.multiplicity == G::ZERO { aiur_fn_334(__args, record, io_buffer, false)? } else { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_334] = unsafe { *(result.output.as_ptr() as *const [G; OUT_334]) }; __ret } } else { aiur_fn_334(__args, record, io_buffer, __cu)? } }; + let __r_arr: [G; OUT_330] = { let __args: [G; IN_330] = [__v_3, __v_1]; let __cu = unconstrained; if let Some(result) = record.function_queries[330].get_mut(&__args[..]) { if !__cu && *result.multiplicity == G::ZERO { aiur_fn_330(__args, record, io_buffer, false)? } else { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_330] = unsafe { *(result.output.as_ptr() as *const [G; OUT_330]) }; __ret } } else { aiur_fn_330(__args, record, io_buffer, __cu)? } }; let __v_7: G = __r_arr[0]; let __v_8: G = G::from_u64(0); let __v_9: G = { let __values: [G; 4] = [__v_6, __v_7, __v_8, __v_8]; let __mq = record.memory_queries.get_mut(&4).ok_or(ExecError::InvalidMemorySize(4))?; if let Some(result) = __mq.get_mut(&__values[..]) { if !unconstrained { *result.multiplicity += G::ONE; } result.output[0] } else { let __ptr = G::from_usize(__mq.len()); __mq.insert(&__values[..], &[__ptr], G::from_bool(!unconstrained)); __ptr } }; - let __ret: [G; OUT_337] = [__v_9]; - if let Some(result) = record.function_queries[337].get_mut(&inp[..]) { debug_assert_eq!(result.output, &__ret[..]); if !unconstrained { *result.multiplicity += G::ONE; } } else { record.function_queries[337].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained)); }; + let __ret: [G; OUT_333] = [__v_9]; + if let Some(result) = record.function_queries[333].get_mut(&inp[..]) { debug_assert_eq!(result.output, &__ret[..]); if !unconstrained { *result.multiplicity += G::ONE; } } else { record.function_queries[333].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained)); }; return Ok(__ret); }, 2u64 => { let __v_6: G = G::from_u64(2); - let __r_arr: [G; OUT_335] = { let __args: [G; IN_335] = [__v_4, __v_1]; let __cu = unconstrained; if let Some(result) = record.function_queries[335].get_mut(&__args[..]) { if !__cu && *result.multiplicity == G::ZERO { aiur_fn_335(__args, record, io_buffer, false)? } else { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_335] = unsafe { *(result.output.as_ptr() as *const [G; OUT_335]) }; __ret } } else { aiur_fn_335(__args, record, io_buffer, __cu)? } }; + let __r_arr: [G; OUT_331] = { let __args: [G; IN_331] = [__v_4, __v_1]; let __cu = unconstrained; if let Some(result) = record.function_queries[331].get_mut(&__args[..]) { if !__cu && *result.multiplicity == G::ZERO { aiur_fn_331(__args, record, io_buffer, false)? } else { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_331] = unsafe { *(result.output.as_ptr() as *const [G; OUT_331]) }; __ret } } else { aiur_fn_331(__args, record, io_buffer, __cu)? } }; let __v_7: G = __r_arr[0]; let __v_8: G = G::from_u64(0); let __v_9: G = { let __values: [G; 4] = [__v_6, __v_3, __v_7, __v_8]; let __mq = record.memory_queries.get_mut(&4).ok_or(ExecError::InvalidMemorySize(4))?; if let Some(result) = __mq.get_mut(&__values[..]) { if !unconstrained { *result.multiplicity += G::ONE; } result.output[0] } else { let __ptr = G::from_usize(__mq.len()); __mq.insert(&__values[..], &[__ptr], G::from_bool(!unconstrained)); __ptr } }; - let __ret: [G; OUT_337] = [__v_9]; - if let Some(result) = record.function_queries[337].get_mut(&inp[..]) { debug_assert_eq!(result.output, &__ret[..]); if !unconstrained { *result.multiplicity += G::ONE; } } else { record.function_queries[337].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained)); }; + let __ret: [G; OUT_333] = [__v_9]; + if let Some(result) = record.function_queries[333].get_mut(&inp[..]) { debug_assert_eq!(result.output, &__ret[..]); if !unconstrained { *result.multiplicity += G::ONE; } } else { record.function_queries[333].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained)); }; return Ok(__ret); }, 3u64 => { let __v_6: G = G::from_u64(3); - let __r_arr: [G; OUT_336] = { let __args: [G; IN_336] = [__v_3, __v_1]; let __cu = unconstrained; if let Some(result) = record.function_queries[336].get_mut(&__args[..]) { if !__cu && *result.multiplicity == G::ZERO { aiur_fn_336(__args, record, io_buffer, false)? } else { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_336] = unsafe { *(result.output.as_ptr() as *const [G; OUT_336]) }; __ret } } else { aiur_fn_336(__args, record, io_buffer, __cu)? } }; + let __r_arr: [G; OUT_332] = { let __args: [G; IN_332] = [__v_3, __v_1]; let __cu = unconstrained; if let Some(result) = record.function_queries[332].get_mut(&__args[..]) { if !__cu && *result.multiplicity == G::ZERO { aiur_fn_332(__args, record, io_buffer, false)? } else { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_332] = unsafe { *(result.output.as_ptr() as *const [G; OUT_332]) }; __ret } } else { aiur_fn_332(__args, record, io_buffer, __cu)? } }; let __v_7: G = __r_arr[0]; - let __r_arr: [G; OUT_336] = { let __args: [G; IN_336] = [__v_4, __v_1]; let __cu = unconstrained; if let Some(result) = record.function_queries[336].get_mut(&__args[..]) { if !__cu && *result.multiplicity == G::ZERO { aiur_fn_336(__args, record, io_buffer, false)? } else { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_336] = unsafe { *(result.output.as_ptr() as *const [G; OUT_336]) }; __ret } } else { aiur_fn_336(__args, record, io_buffer, __cu)? } }; + let __r_arr: [G; OUT_332] = { let __args: [G; IN_332] = [__v_4, __v_1]; let __cu = unconstrained; if let Some(result) = record.function_queries[332].get_mut(&__args[..]) { if !__cu && *result.multiplicity == G::ZERO { aiur_fn_332(__args, record, io_buffer, false)? } else { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_332] = unsafe { *(result.output.as_ptr() as *const [G; OUT_332]) }; __ret } } else { aiur_fn_332(__args, record, io_buffer, __cu)? } }; let __v_8: G = __r_arr[0]; let __v_9: G = G::from_u64(0); let __v_10: G = { let __values: [G; 4] = [__v_6, __v_7, __v_8, __v_9]; let __mq = record.memory_queries.get_mut(&4).ok_or(ExecError::InvalidMemorySize(4))?; if let Some(result) = __mq.get_mut(&__values[..]) { if !unconstrained { *result.multiplicity += G::ONE; } result.output[0] } else { let __ptr = G::from_usize(__mq.len()); __mq.insert(&__values[..], &[__ptr], G::from_bool(!unconstrained)); __ptr } }; - let __ret: [G; OUT_337] = [__v_10]; - if let Some(result) = record.function_queries[337].get_mut(&inp[..]) { debug_assert_eq!(result.output, &__ret[..]); if !unconstrained { *result.multiplicity += G::ONE; } } else { record.function_queries[337].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained)); }; + let __ret: [G; OUT_333] = [__v_10]; + if let Some(result) = record.function_queries[333].get_mut(&inp[..]) { debug_assert_eq!(result.output, &__ret[..]); if !unconstrained { *result.multiplicity += G::ONE; } } else { record.function_queries[333].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained)); }; return Ok(__ret); }, 4u64 => { let __v_6: G = G::from_u64(4); - let __r_arr: [G; OUT_336] = { let __args: [G; IN_336] = [__v_3, __v_1]; let __cu = unconstrained; if let Some(result) = record.function_queries[336].get_mut(&__args[..]) { if !__cu && *result.multiplicity == G::ZERO { aiur_fn_336(__args, record, io_buffer, false)? } else { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_336] = unsafe { *(result.output.as_ptr() as *const [G; OUT_336]) }; __ret } } else { aiur_fn_336(__args, record, io_buffer, __cu)? } }; + let __r_arr: [G; OUT_332] = { let __args: [G; IN_332] = [__v_3, __v_1]; let __cu = unconstrained; if let Some(result) = record.function_queries[332].get_mut(&__args[..]) { if !__cu && *result.multiplicity == G::ZERO { aiur_fn_332(__args, record, io_buffer, false)? } else { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_332] = unsafe { *(result.output.as_ptr() as *const [G; OUT_332]) }; __ret } } else { aiur_fn_332(__args, record, io_buffer, __cu)? } }; let __v_7: G = __r_arr[0]; - let __r_arr: [G; OUT_336] = { let __args: [G; IN_336] = [__v_4, __v_1]; let __cu = unconstrained; if let Some(result) = record.function_queries[336].get_mut(&__args[..]) { if !__cu && *result.multiplicity == G::ZERO { aiur_fn_336(__args, record, io_buffer, false)? } else { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_336] = unsafe { *(result.output.as_ptr() as *const [G; OUT_336]) }; __ret } } else { aiur_fn_336(__args, record, io_buffer, __cu)? } }; + let __r_arr: [G; OUT_332] = { let __args: [G; IN_332] = [__v_4, __v_1]; let __cu = unconstrained; if let Some(result) = record.function_queries[332].get_mut(&__args[..]) { if !__cu && *result.multiplicity == G::ZERO { aiur_fn_332(__args, record, io_buffer, false)? } else { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_332] = unsafe { *(result.output.as_ptr() as *const [G; OUT_332]) }; __ret } } else { aiur_fn_332(__args, record, io_buffer, __cu)? } }; let __v_8: G = __r_arr[0]; let __v_9: G = G::from_u64(0); let __v_10: G = { let __values: [G; 4] = [__v_6, __v_7, __v_8, __v_9]; let __mq = record.memory_queries.get_mut(&4).ok_or(ExecError::InvalidMemorySize(4))?; if let Some(result) = __mq.get_mut(&__values[..]) { if !unconstrained { *result.multiplicity += G::ONE; } result.output[0] } else { let __ptr = G::from_usize(__mq.len()); __mq.insert(&__values[..], &[__ptr], G::from_bool(!unconstrained)); __ptr } }; - let __ret: [G; OUT_337] = [__v_10]; - if let Some(result) = record.function_queries[337].get_mut(&inp[..]) { debug_assert_eq!(result.output, &__ret[..]); if !unconstrained { *result.multiplicity += G::ONE; } } else { record.function_queries[337].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained)); }; + let __ret: [G; OUT_333] = [__v_10]; + if let Some(result) = record.function_queries[333].get_mut(&inp[..]) { debug_assert_eq!(result.output, &__ret[..]); if !unconstrained { *result.multiplicity += G::ONE; } } else { record.function_queries[333].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained)); }; return Ok(__ret); }, 5u64 => { let __v_6: G = G::from_u64(5); - let __r_arr: [G; OUT_336] = { let __args: [G; IN_336] = [__v_3, __v_1]; let __cu = unconstrained; if let Some(result) = record.function_queries[336].get_mut(&__args[..]) { if !__cu && *result.multiplicity == G::ZERO { aiur_fn_336(__args, record, io_buffer, false)? } else { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_336] = unsafe { *(result.output.as_ptr() as *const [G; OUT_336]) }; __ret } } else { aiur_fn_336(__args, record, io_buffer, __cu)? } }; + let __r_arr: [G; OUT_332] = { let __args: [G; IN_332] = [__v_3, __v_1]; let __cu = unconstrained; if let Some(result) = record.function_queries[332].get_mut(&__args[..]) { if !__cu && *result.multiplicity == G::ZERO { aiur_fn_332(__args, record, io_buffer, false)? } else { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_332] = unsafe { *(result.output.as_ptr() as *const [G; OUT_332]) }; __ret } } else { aiur_fn_332(__args, record, io_buffer, __cu)? } }; let __v_7: G = __r_arr[0]; - let __r_arr: [G; OUT_336] = { let __args: [G; IN_336] = [__v_4, __v_1]; let __cu = unconstrained; if let Some(result) = record.function_queries[336].get_mut(&__args[..]) { if !__cu && *result.multiplicity == G::ZERO { aiur_fn_336(__args, record, io_buffer, false)? } else { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_336] = unsafe { *(result.output.as_ptr() as *const [G; OUT_336]) }; __ret } } else { aiur_fn_336(__args, record, io_buffer, __cu)? } }; + let __r_arr: [G; OUT_332] = { let __args: [G; IN_332] = [__v_4, __v_1]; let __cu = unconstrained; if let Some(result) = record.function_queries[332].get_mut(&__args[..]) { if !__cu && *result.multiplicity == G::ZERO { aiur_fn_332(__args, record, io_buffer, false)? } else { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_332] = unsafe { *(result.output.as_ptr() as *const [G; OUT_332]) }; __ret } } else { aiur_fn_332(__args, record, io_buffer, __cu)? } }; let __v_8: G = __r_arr[0]; let __v_9: G = G::from_u64(0); let __v_10: G = { let __values: [G; 4] = [__v_6, __v_7, __v_8, __v_9]; let __mq = record.memory_queries.get_mut(&4).ok_or(ExecError::InvalidMemorySize(4))?; if let Some(result) = __mq.get_mut(&__values[..]) { if !unconstrained { *result.multiplicity += G::ONE; } result.output[0] } else { let __ptr = G::from_usize(__mq.len()); __mq.insert(&__values[..], &[__ptr], G::from_bool(!unconstrained)); __ptr } }; - let __ret: [G; OUT_337] = [__v_10]; - if let Some(result) = record.function_queries[337].get_mut(&inp[..]) { debug_assert_eq!(result.output, &__ret[..]); if !unconstrained { *result.multiplicity += G::ONE; } } else { record.function_queries[337].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained)); }; + let __ret: [G; OUT_333] = [__v_10]; + if let Some(result) = record.function_queries[333].get_mut(&inp[..]) { debug_assert_eq!(result.output, &__ret[..]); if !unconstrained { *result.multiplicity += G::ONE; } } else { record.function_queries[333].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained)); }; return Ok(__ret); }, 6u64 => { let __v_6: G = G::from_u64(6); - let __r_arr: [G; OUT_336] = { let __args: [G; IN_336] = [__v_3, __v_1]; let __cu = unconstrained; if let Some(result) = record.function_queries[336].get_mut(&__args[..]) { if !__cu && *result.multiplicity == G::ZERO { aiur_fn_336(__args, record, io_buffer, false)? } else { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_336] = unsafe { *(result.output.as_ptr() as *const [G; OUT_336]) }; __ret } } else { aiur_fn_336(__args, record, io_buffer, __cu)? } }; + let __r_arr: [G; OUT_332] = { let __args: [G; IN_332] = [__v_3, __v_1]; let __cu = unconstrained; if let Some(result) = record.function_queries[332].get_mut(&__args[..]) { if !__cu && *result.multiplicity == G::ZERO { aiur_fn_332(__args, record, io_buffer, false)? } else { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_332] = unsafe { *(result.output.as_ptr() as *const [G; OUT_332]) }; __ret } } else { aiur_fn_332(__args, record, io_buffer, __cu)? } }; let __v_7: G = __r_arr[0]; - let __r_arr: [G; OUT_336] = { let __args: [G; IN_336] = [__v_4, __v_1]; let __cu = unconstrained; if let Some(result) = record.function_queries[336].get_mut(&__args[..]) { if !__cu && *result.multiplicity == G::ZERO { aiur_fn_336(__args, record, io_buffer, false)? } else { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_336] = unsafe { *(result.output.as_ptr() as *const [G; OUT_336]) }; __ret } } else { aiur_fn_336(__args, record, io_buffer, __cu)? } }; + let __r_arr: [G; OUT_332] = { let __args: [G; IN_332] = [__v_4, __v_1]; let __cu = unconstrained; if let Some(result) = record.function_queries[332].get_mut(&__args[..]) { if !__cu && *result.multiplicity == G::ZERO { aiur_fn_332(__args, record, io_buffer, false)? } else { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_332] = unsafe { *(result.output.as_ptr() as *const [G; OUT_332]) }; __ret } } else { aiur_fn_332(__args, record, io_buffer, __cu)? } }; let __v_8: G = __r_arr[0]; - let __r_arr: [G; OUT_336] = { let __args: [G; IN_336] = [__v_5, __v_1]; let __cu = unconstrained; if let Some(result) = record.function_queries[336].get_mut(&__args[..]) { if !__cu && *result.multiplicity == G::ZERO { aiur_fn_336(__args, record, io_buffer, false)? } else { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_336] = unsafe { *(result.output.as_ptr() as *const [G; OUT_336]) }; __ret } } else { aiur_fn_336(__args, record, io_buffer, __cu)? } }; + let __r_arr: [G; OUT_332] = { let __args: [G; IN_332] = [__v_5, __v_1]; let __cu = unconstrained; if let Some(result) = record.function_queries[332].get_mut(&__args[..]) { if !__cu && *result.multiplicity == G::ZERO { aiur_fn_332(__args, record, io_buffer, false)? } else { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_332] = unsafe { *(result.output.as_ptr() as *const [G; OUT_332]) }; __ret } } else { aiur_fn_332(__args, record, io_buffer, __cu)? } }; let __v_9: G = __r_arr[0]; let __v_10: G = { let __values: [G; 4] = [__v_6, __v_7, __v_8, __v_9]; let __mq = record.memory_queries.get_mut(&4).ok_or(ExecError::InvalidMemorySize(4))?; if let Some(result) = __mq.get_mut(&__values[..]) { if !unconstrained { *result.multiplicity += G::ONE; } result.output[0] } else { let __ptr = G::from_usize(__mq.len()); __mq.insert(&__values[..], &[__ptr], G::from_bool(!unconstrained)); __ptr } }; - let __ret: [G; OUT_337] = [__v_10]; - if let Some(result) = record.function_queries[337].get_mut(&inp[..]) { debug_assert_eq!(result.output, &__ret[..]); if !unconstrained { *result.multiplicity += G::ONE; } } else { record.function_queries[337].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained)); }; + let __ret: [G; OUT_333] = [__v_10]; + if let Some(result) = record.function_queries[333].get_mut(&inp[..]) { debug_assert_eq!(result.output, &__ret[..]); if !unconstrained { *result.multiplicity += G::ONE; } } else { record.function_queries[333].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained)); }; return Ok(__ret); }, 7u64 => { let __v_6: G = G::from_u64(7); let __v_7: G = G::from_u64(0); let __v_8: G = { let __values: [G; 4] = [__v_6, __v_3, __v_4, __v_7]; let __mq = record.memory_queries.get_mut(&4).ok_or(ExecError::InvalidMemorySize(4))?; if let Some(result) = __mq.get_mut(&__values[..]) { if !unconstrained { *result.multiplicity += G::ONE; } result.output[0] } else { let __ptr = G::from_usize(__mq.len()); __mq.insert(&__values[..], &[__ptr], G::from_bool(!unconstrained)); __ptr } }; - let __ret: [G; OUT_337] = [__v_8]; - if let Some(result) = record.function_queries[337].get_mut(&inp[..]) { debug_assert_eq!(result.output, &__ret[..]); if !unconstrained { *result.multiplicity += G::ONE; } } else { record.function_queries[337].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained)); }; + let __ret: [G; OUT_333] = [__v_8]; + if let Some(result) = record.function_queries[333].get_mut(&inp[..]) { debug_assert_eq!(result.output, &__ret[..]); if !unconstrained { *result.multiplicity += G::ONE; } } else { record.function_queries[333].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained)); }; return Ok(__ret); }, 8u64 => { let __v_6: G = G::from_u64(8); - let __r_arr: [G; OUT_336] = { let __args: [G; IN_336] = [__v_5, __v_1]; let __cu = unconstrained; if let Some(result) = record.function_queries[336].get_mut(&__args[..]) { if !__cu && *result.multiplicity == G::ZERO { aiur_fn_336(__args, record, io_buffer, false)? } else { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_336] = unsafe { *(result.output.as_ptr() as *const [G; OUT_336]) }; __ret } } else { aiur_fn_336(__args, record, io_buffer, __cu)? } }; + let __r_arr: [G; OUT_332] = { let __args: [G; IN_332] = [__v_5, __v_1]; let __cu = unconstrained; if let Some(result) = record.function_queries[332].get_mut(&__args[..]) { if !__cu && *result.multiplicity == G::ZERO { aiur_fn_332(__args, record, io_buffer, false)? } else { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_332] = unsafe { *(result.output.as_ptr() as *const [G; OUT_332]) }; __ret } } else { aiur_fn_332(__args, record, io_buffer, __cu)? } }; let __v_7: G = __r_arr[0]; let __v_8: G = { let __values: [G; 4] = [__v_6, __v_3, __v_4, __v_7]; let __mq = record.memory_queries.get_mut(&4).ok_or(ExecError::InvalidMemorySize(4))?; if let Some(result) = __mq.get_mut(&__values[..]) { if !unconstrained { *result.multiplicity += G::ONE; } result.output[0] } else { let __ptr = G::from_usize(__mq.len()); __mq.insert(&__values[..], &[__ptr], G::from_bool(!unconstrained)); __ptr } }; - let __ret: [G; OUT_337] = [__v_8]; - if let Some(result) = record.function_queries[337].get_mut(&inp[..]) { debug_assert_eq!(result.output, &__ret[..]); if !unconstrained { *result.multiplicity += G::ONE; } } else { record.function_queries[337].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained)); }; + let __ret: [G; OUT_333] = [__v_8]; + if let Some(result) = record.function_queries[333].get_mut(&inp[..]) { debug_assert_eq!(result.output, &__ret[..]); if !unconstrained { *result.multiplicity += G::ONE; } } else { record.function_queries[333].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained)); }; return Ok(__ret); }, _ => { @@ -31531,15 +31257,15 @@ fn aiur_fn_337( }) } -const INPUT_SIZE_338: usize = 2; -const IN_338: usize = 2; -const OUT_338: usize = 1; -fn aiur_fn_338( - inp: [G; IN_338], +const INPUT_SIZE_334: usize = 2; +const IN_334: usize = 2; +const OUT_334: usize = 1; +fn aiur_fn_334( + inp: [G; IN_334], record: &mut QueryRecord, io_buffer: &mut IOBuffer, unconstrained: bool, -) -> Result<[G; OUT_338], ExecError> { +) -> Result<[G; OUT_334], ExecError> { stacker::maybe_grow(64 * 1024, 4 * 1024 * 1024, || { let __v_0: G = inp[0]; let __v_1: G = inp[1]; @@ -31570,14 +31296,14 @@ fn aiur_fn_338( match __v_12.as_canonical_u64() { 1u64 => { let __v_22: G = G::from_u64(1); - let __ret: [G; OUT_338] = [__v_22]; - if let Some(result) = record.function_queries[338].get_mut(&inp[..]) { debug_assert_eq!(result.output, &__ret[..]); if !unconstrained { *result.multiplicity += G::ONE; } } else { record.function_queries[338].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained)); }; + let __ret: [G; OUT_334] = [__v_22]; + if let Some(result) = record.function_queries[334].get_mut(&inp[..]) { debug_assert_eq!(result.output, &__ret[..]); if !unconstrained { *result.multiplicity += G::ONE; } } else { record.function_queries[334].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained)); }; return Ok(__ret); }, _ => { let __v_22: G = G::from_u64(0); - let __ret: [G; OUT_338] = [__v_22]; - if let Some(result) = record.function_queries[338].get_mut(&inp[..]) { debug_assert_eq!(result.output, &__ret[..]); if !unconstrained { *result.multiplicity += G::ONE; } } else { record.function_queries[338].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained)); }; + let __ret: [G; OUT_334] = [__v_22]; + if let Some(result) = record.function_queries[334].get_mut(&inp[..]) { debug_assert_eq!(result.output, &__ret[..]); if !unconstrained { *result.multiplicity += G::ONE; } } else { record.function_queries[334].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained)); }; return Ok(__ret); }, } @@ -31597,8 +31323,8 @@ fn aiur_fn_338( match __v_12.as_canonical_u64() { 1u64 => { let __v_22: G = G::from_u64(0); - let __ret: [G; OUT_338] = [__v_22]; - if let Some(result) = record.function_queries[338].get_mut(&inp[..]) { debug_assert_eq!(result.output, &__ret[..]); if !unconstrained { *result.multiplicity += G::ONE; } } else { record.function_queries[338].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained)); }; + let __ret: [G; OUT_334] = [__v_22]; + if let Some(result) = record.function_queries[334].get_mut(&inp[..]) { debug_assert_eq!(result.output, &__ret[..]); if !unconstrained { *result.multiplicity += G::ONE; } } else { record.function_queries[334].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained)); }; return Ok(__ret); }, 0u64 => { @@ -31606,16 +31332,16 @@ fn aiur_fn_338( let __v_22: G = __r_arr[0]; match __v_22.as_canonical_u64() { 1u64 => { - let __r_arr: [G; OUT_338] = { let __args: [G; IN_338] = [__v_11, __v_21]; let __cu = unconstrained; if let Some(result) = record.function_queries[338].get_mut(&__args[..]) { if !__cu && *result.multiplicity == G::ZERO { aiur_fn_338(__args, record, io_buffer, false)? } else { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_338] = unsafe { *(result.output.as_ptr() as *const [G; OUT_338]) }; __ret } } else { aiur_fn_338(__args, record, io_buffer, __cu)? } }; + let __r_arr: [G; OUT_334] = { let __args: [G; IN_334] = [__v_11, __v_21]; let __cu = unconstrained; if let Some(result) = record.function_queries[334].get_mut(&__args[..]) { if !__cu && *result.multiplicity == G::ZERO { aiur_fn_334(__args, record, io_buffer, false)? } else { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_334] = unsafe { *(result.output.as_ptr() as *const [G; OUT_334]) }; __ret } } else { aiur_fn_334(__args, record, io_buffer, __cu)? } }; let __v_23: G = __r_arr[0]; - let __ret: [G; OUT_338] = [__v_23]; - if let Some(result) = record.function_queries[338].get_mut(&inp[..]) { debug_assert_eq!(result.output, &__ret[..]); if !unconstrained { *result.multiplicity += G::ONE; } } else { record.function_queries[338].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained)); }; + let __ret: [G; OUT_334] = [__v_23]; + if let Some(result) = record.function_queries[334].get_mut(&inp[..]) { debug_assert_eq!(result.output, &__ret[..]); if !unconstrained { *result.multiplicity += G::ONE; } } else { record.function_queries[334].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained)); }; return Ok(__ret); }, 0u64 => { let __v_23: G = G::from_u64(0); - let __ret: [G; OUT_338] = [__v_23]; - if let Some(result) = record.function_queries[338].get_mut(&inp[..]) { debug_assert_eq!(result.output, &__ret[..]); if !unconstrained { *result.multiplicity += G::ONE; } } else { record.function_queries[338].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained)); }; + let __ret: [G; OUT_334] = [__v_23]; + if let Some(result) = record.function_queries[334].get_mut(&inp[..]) { debug_assert_eq!(result.output, &__ret[..]); if !unconstrained { *result.multiplicity += G::ONE; } } else { record.function_queries[334].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained)); }; return Ok(__ret); }, _ => { @@ -31635,15 +31361,15 @@ fn aiur_fn_338( }) } -const INPUT_SIZE_339: usize = 2; -const IN_339: usize = 2; -const OUT_339: usize = 1; -fn aiur_fn_339( - inp: [G; IN_339], +const INPUT_SIZE_335: usize = 2; +const IN_335: usize = 2; +const OUT_335: usize = 1; +fn aiur_fn_335( + inp: [G; IN_335], record: &mut QueryRecord, io_buffer: &mut IOBuffer, unconstrained: bool, -) -> Result<[G; OUT_339], ExecError> { +) -> Result<[G; OUT_335], ExecError> { stacker::maybe_grow(64 * 1024, 4 * 1024 * 1024, || { let __v_0: G = inp[0]; let __v_1: G = inp[1]; @@ -31660,14 +31386,14 @@ fn aiur_fn_339( match __v_5.as_canonical_u64() { 1u64 => { let __v_8: G = G::from_u64(1); - let __ret: [G; OUT_339] = [__v_8]; - if let Some(result) = record.function_queries[339].get_mut(&inp[..]) { debug_assert_eq!(result.output, &__ret[..]); if !unconstrained { *result.multiplicity += G::ONE; } } else { record.function_queries[339].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained)); }; + let __ret: [G; OUT_335] = [__v_8]; + if let Some(result) = record.function_queries[335].get_mut(&inp[..]) { debug_assert_eq!(result.output, &__ret[..]); if !unconstrained { *result.multiplicity += G::ONE; } } else { record.function_queries[335].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained)); }; return Ok(__ret); }, _ => { let __v_8: G = G::from_u64(0); - let __ret: [G; OUT_339] = [__v_8]; - if let Some(result) = record.function_queries[339].get_mut(&inp[..]) { debug_assert_eq!(result.output, &__ret[..]); if !unconstrained { *result.multiplicity += G::ONE; } } else { record.function_queries[339].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained)); }; + let __ret: [G; OUT_335] = [__v_8]; + if let Some(result) = record.function_queries[335].get_mut(&inp[..]) { debug_assert_eq!(result.output, &__ret[..]); if !unconstrained { *result.multiplicity += G::ONE; } } else { record.function_queries[335].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained)); }; return Ok(__ret); }, } @@ -31680,24 +31406,24 @@ fn aiur_fn_339( match __v_5.as_canonical_u64() { 1u64 => { let __v_8: G = G::from_u64(0); - let __ret: [G; OUT_339] = [__v_8]; - if let Some(result) = record.function_queries[339].get_mut(&inp[..]) { debug_assert_eq!(result.output, &__ret[..]); if !unconstrained { *result.multiplicity += G::ONE; } } else { record.function_queries[339].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained)); }; + let __ret: [G; OUT_335] = [__v_8]; + if let Some(result) = record.function_queries[335].get_mut(&inp[..]) { debug_assert_eq!(result.output, &__ret[..]); if !unconstrained { *result.multiplicity += G::ONE; } } else { record.function_queries[335].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained)); }; return Ok(__ret); }, 0u64 => { let __v_8: G = (__v_3 - __v_6); match __v_8.as_canonical_u64() { 0u64 => { - let __r_arr: [G; OUT_339] = { let __args: [G; IN_339] = [__v_4, __v_7]; let __cu = unconstrained; if let Some(result) = record.function_queries[339].get_mut(&__args[..]) { if !__cu && *result.multiplicity == G::ZERO { aiur_fn_339(__args, record, io_buffer, false)? } else { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_339] = unsafe { *(result.output.as_ptr() as *const [G; OUT_339]) }; __ret } } else { aiur_fn_339(__args, record, io_buffer, __cu)? } }; + let __r_arr: [G; OUT_335] = { let __args: [G; IN_335] = [__v_4, __v_7]; let __cu = unconstrained; if let Some(result) = record.function_queries[335].get_mut(&__args[..]) { if !__cu && *result.multiplicity == G::ZERO { aiur_fn_335(__args, record, io_buffer, false)? } else { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_335] = unsafe { *(result.output.as_ptr() as *const [G; OUT_335]) }; __ret } } else { aiur_fn_335(__args, record, io_buffer, __cu)? } }; let __v_9: G = __r_arr[0]; - let __ret: [G; OUT_339] = [__v_9]; - if let Some(result) = record.function_queries[339].get_mut(&inp[..]) { debug_assert_eq!(result.output, &__ret[..]); if !unconstrained { *result.multiplicity += G::ONE; } } else { record.function_queries[339].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained)); }; + let __ret: [G; OUT_335] = [__v_9]; + if let Some(result) = record.function_queries[335].get_mut(&inp[..]) { debug_assert_eq!(result.output, &__ret[..]); if !unconstrained { *result.multiplicity += G::ONE; } } else { record.function_queries[335].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained)); }; return Ok(__ret); }, _ => { let __v_9: G = G::from_u64(0); - let __ret: [G; OUT_339] = [__v_9]; - if let Some(result) = record.function_queries[339].get_mut(&inp[..]) { debug_assert_eq!(result.output, &__ret[..]); if !unconstrained { *result.multiplicity += G::ONE; } } else { record.function_queries[339].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained)); }; + let __ret: [G; OUT_335] = [__v_9]; + if let Some(result) = record.function_queries[335].get_mut(&inp[..]) { debug_assert_eq!(result.output, &__ret[..]); if !unconstrained { *result.multiplicity += G::ONE; } } else { record.function_queries[335].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained)); }; return Ok(__ret); }, } @@ -31714,15 +31440,15 @@ fn aiur_fn_339( }) } -const INPUT_SIZE_340: usize = 4; -const IN_340: usize = 4; -const OUT_340: usize = 1; -fn aiur_fn_340( - inp: [G; IN_340], +const INPUT_SIZE_336: usize = 4; +const IN_336: usize = 4; +const OUT_336: usize = 1; +fn aiur_fn_336( + inp: [G; IN_336], record: &mut QueryRecord, io_buffer: &mut IOBuffer, unconstrained: bool, -) -> Result<[G; OUT_340], ExecError> { +) -> Result<[G; OUT_336], ExecError> { stacker::maybe_grow(64 * 1024, 4 * 1024 * 1024, || { let __v_0: G = inp[0]; let __v_1: G = inp[1]; @@ -31732,16 +31458,16 @@ fn aiur_fn_340( 0u64 => { match __v_2.as_canonical_u64() { 0u64 => { - let __r_arr: [G; OUT_338] = { let __args: [G; IN_338] = [__v_1, __v_3]; let __cu = unconstrained; if let Some(result) = record.function_queries[338].get_mut(&__args[..]) { if !__cu && *result.multiplicity == G::ZERO { aiur_fn_338(__args, record, io_buffer, false)? } else { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_338] = unsafe { *(result.output.as_ptr() as *const [G; OUT_338]) }; __ret } } else { aiur_fn_338(__args, record, io_buffer, __cu)? } }; + let __r_arr: [G; OUT_334] = { let __args: [G; IN_334] = [__v_1, __v_3]; let __cu = unconstrained; if let Some(result) = record.function_queries[334].get_mut(&__args[..]) { if !__cu && *result.multiplicity == G::ZERO { aiur_fn_334(__args, record, io_buffer, false)? } else { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_334] = unsafe { *(result.output.as_ptr() as *const [G; OUT_334]) }; __ret } } else { aiur_fn_334(__args, record, io_buffer, __cu)? } }; let __v_4: G = __r_arr[0]; - let __ret: [G; OUT_340] = [__v_4]; - if let Some(result) = record.function_queries[340].get_mut(&inp[..]) { debug_assert_eq!(result.output, &__ret[..]); if !unconstrained { *result.multiplicity += G::ONE; } } else { record.function_queries[340].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained)); }; + let __ret: [G; OUT_336] = [__v_4]; + if let Some(result) = record.function_queries[336].get_mut(&inp[..]) { debug_assert_eq!(result.output, &__ret[..]); if !unconstrained { *result.multiplicity += G::ONE; } } else { record.function_queries[336].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained)); }; return Ok(__ret); }, _ => { let __v_4: G = G::from_u64(0); - let __ret: [G; OUT_340] = [__v_4]; - if let Some(result) = record.function_queries[340].get_mut(&inp[..]) { debug_assert_eq!(result.output, &__ret[..]); if !unconstrained { *result.multiplicity += G::ONE; } } else { record.function_queries[340].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained)); }; + let __ret: [G; OUT_336] = [__v_4]; + if let Some(result) = record.function_queries[336].get_mut(&inp[..]) { debug_assert_eq!(result.output, &__ret[..]); if !unconstrained { *result.multiplicity += G::ONE; } } else { record.function_queries[336].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained)); }; return Ok(__ret); }, } @@ -31749,16 +31475,16 @@ fn aiur_fn_340( 1u64 => { match __v_2.as_canonical_u64() { 1u64 => { - let __r_arr: [G; OUT_339] = { let __args: [G; IN_339] = [__v_1, __v_3]; let __cu = unconstrained; if let Some(result) = record.function_queries[339].get_mut(&__args[..]) { if !__cu && *result.multiplicity == G::ZERO { aiur_fn_339(__args, record, io_buffer, false)? } else { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_339] = unsafe { *(result.output.as_ptr() as *const [G; OUT_339]) }; __ret } } else { aiur_fn_339(__args, record, io_buffer, __cu)? } }; + let __r_arr: [G; OUT_335] = { let __args: [G; IN_335] = [__v_1, __v_3]; let __cu = unconstrained; if let Some(result) = record.function_queries[335].get_mut(&__args[..]) { if !__cu && *result.multiplicity == G::ZERO { aiur_fn_335(__args, record, io_buffer, false)? } else { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_335] = unsafe { *(result.output.as_ptr() as *const [G; OUT_335]) }; __ret } } else { aiur_fn_335(__args, record, io_buffer, __cu)? } }; let __v_4: G = __r_arr[0]; - let __ret: [G; OUT_340] = [__v_4]; - if let Some(result) = record.function_queries[340].get_mut(&inp[..]) { debug_assert_eq!(result.output, &__ret[..]); if !unconstrained { *result.multiplicity += G::ONE; } } else { record.function_queries[340].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained)); }; + let __ret: [G; OUT_336] = [__v_4]; + if let Some(result) = record.function_queries[336].get_mut(&inp[..]) { debug_assert_eq!(result.output, &__ret[..]); if !unconstrained { *result.multiplicity += G::ONE; } } else { record.function_queries[336].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained)); }; return Ok(__ret); }, _ => { let __v_4: G = G::from_u64(0); - let __ret: [G; OUT_340] = [__v_4]; - if let Some(result) = record.function_queries[340].get_mut(&inp[..]) { debug_assert_eq!(result.output, &__ret[..]); if !unconstrained { *result.multiplicity += G::ONE; } } else { record.function_queries[340].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained)); }; + let __ret: [G; OUT_336] = [__v_4]; + if let Some(result) = record.function_queries[336].get_mut(&inp[..]) { debug_assert_eq!(result.output, &__ret[..]); if !unconstrained { *result.multiplicity += G::ONE; } } else { record.function_queries[336].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained)); }; return Ok(__ret); }, } @@ -31770,15 +31496,15 @@ fn aiur_fn_340( }) } -const INPUT_SIZE_341: usize = 1; -const IN_341: usize = 1; -const OUT_341: usize = 1; -fn aiur_fn_341( - inp: [G; IN_341], +const INPUT_SIZE_337: usize = 1; +const IN_337: usize = 1; +const OUT_337: usize = 1; +fn aiur_fn_337( + inp: [G; IN_337], record: &mut QueryRecord, io_buffer: &mut IOBuffer, unconstrained: bool, -) -> Result<[G; OUT_341], ExecError> { +) -> Result<[G; OUT_337], ExecError> { stacker::maybe_grow(64 * 1024, 4 * 1024 * 1024, || { let __v_0: G = inp[0]; let __loaded: [G; 4] = { let __mq = record.memory_queries.get_mut(&4).ok_or(ExecError::InvalidMemorySize(4))?; let __ptr_u64 = __v_0.as_canonical_u64(); let __ptr_usize = usize::try_from(__ptr_u64).ok().ok_or(ExecError::PointerTooLarge(__ptr_u64))?; let (__args, __mult) = __mq.get_index_mut(__ptr_usize).ok_or(ExecError::UnboundPointer { ptr: __ptr_u64, size: 4 })?; if !unconstrained { *__mult += G::ONE; } let __arr: [G; 4] = __args[..4].try_into().unwrap(); __arr }; @@ -31790,77 +31516,77 @@ fn aiur_fn_341( 0u64 => { let __v_5: G = G::from_u64(1); let __v_6: G = (__v_2 + __v_5); - let __ret: [G; OUT_341] = [__v_6]; - if let Some(result) = record.function_queries[341].get_mut(&inp[..]) { debug_assert_eq!(result.output, &__ret[..]); if !unconstrained { *result.multiplicity += G::ONE; } } else { record.function_queries[341].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained)); }; + let __ret: [G; OUT_337] = [__v_6]; + if let Some(result) = record.function_queries[337].get_mut(&inp[..]) { debug_assert_eq!(result.output, &__ret[..]); if !unconstrained { *result.multiplicity += G::ONE; } } else { record.function_queries[337].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained)); }; return Ok(__ret); }, 1u64 => { let __v_5: G = G::from_u64(0); - let __ret: [G; OUT_341] = [__v_5]; - if let Some(result) = record.function_queries[341].get_mut(&inp[..]) { debug_assert_eq!(result.output, &__ret[..]); if !unconstrained { *result.multiplicity += G::ONE; } } else { record.function_queries[341].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained)); }; + let __ret: [G; OUT_337] = [__v_5]; + if let Some(result) = record.function_queries[337].get_mut(&inp[..]) { debug_assert_eq!(result.output, &__ret[..]); if !unconstrained { *result.multiplicity += G::ONE; } } else { record.function_queries[337].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained)); }; return Ok(__ret); }, 2u64 => { let __v_5: G = G::from_u64(0); - let __ret: [G; OUT_341] = [__v_5]; - if let Some(result) = record.function_queries[341].get_mut(&inp[..]) { debug_assert_eq!(result.output, &__ret[..]); if !unconstrained { *result.multiplicity += G::ONE; } } else { record.function_queries[341].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained)); }; + let __ret: [G; OUT_337] = [__v_5]; + if let Some(result) = record.function_queries[337].get_mut(&inp[..]) { debug_assert_eq!(result.output, &__ret[..]); if !unconstrained { *result.multiplicity += G::ONE; } } else { record.function_queries[337].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained)); }; return Ok(__ret); }, 7u64 => { let __v_5: G = G::from_u64(0); - let __ret: [G; OUT_341] = [__v_5]; - if let Some(result) = record.function_queries[341].get_mut(&inp[..]) { debug_assert_eq!(result.output, &__ret[..]); if !unconstrained { *result.multiplicity += G::ONE; } } else { record.function_queries[341].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained)); }; + let __ret: [G; OUT_337] = [__v_5]; + if let Some(result) = record.function_queries[337].get_mut(&inp[..]) { debug_assert_eq!(result.output, &__ret[..]); if !unconstrained { *result.multiplicity += G::ONE; } } else { record.function_queries[337].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained)); }; return Ok(__ret); }, 3u64 => { - let __r_arr: [G; OUT_341] = { let __args: [G; IN_341] = [__v_2]; let __cu = unconstrained; if let Some(result) = record.function_queries[341].get_mut(&__args[..]) { if !__cu && *result.multiplicity == G::ZERO { aiur_fn_341(__args, record, io_buffer, false)? } else { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_341] = unsafe { *(result.output.as_ptr() as *const [G; OUT_341]) }; __ret } } else { aiur_fn_341(__args, record, io_buffer, __cu)? } }; + let __r_arr: [G; OUT_337] = { let __args: [G; IN_337] = [__v_2]; let __cu = unconstrained; if let Some(result) = record.function_queries[337].get_mut(&__args[..]) { if !__cu && *result.multiplicity == G::ZERO { aiur_fn_337(__args, record, io_buffer, false)? } else { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_337] = unsafe { *(result.output.as_ptr() as *const [G; OUT_337]) }; __ret } } else { aiur_fn_337(__args, record, io_buffer, __cu)? } }; let __v_5: G = __r_arr[0]; - let __r_arr: [G; OUT_341] = { let __args: [G; IN_341] = [__v_3]; let __cu = unconstrained; if let Some(result) = record.function_queries[341].get_mut(&__args[..]) { if !__cu && *result.multiplicity == G::ZERO { aiur_fn_341(__args, record, io_buffer, false)? } else { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_341] = unsafe { *(result.output.as_ptr() as *const [G; OUT_341]) }; __ret } } else { aiur_fn_341(__args, record, io_buffer, __cu)? } }; + let __r_arr: [G; OUT_337] = { let __args: [G; IN_337] = [__v_3]; let __cu = unconstrained; if let Some(result) = record.function_queries[337].get_mut(&__args[..]) { if !__cu && *result.multiplicity == G::ZERO { aiur_fn_337(__args, record, io_buffer, false)? } else { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_337] = unsafe { *(result.output.as_ptr() as *const [G; OUT_337]) }; __ret } } else { aiur_fn_337(__args, record, io_buffer, __cu)? } }; let __v_6: G = __r_arr[0]; - let __r_arr: [G; OUT_343] = { let __args: [G; IN_343] = [__v_5, __v_6]; let __cu = unconstrained; if let Some(result) = record.function_queries[343].get_mut(&__args[..]) { if !__cu && *result.multiplicity == G::ZERO { aiur_fn_343(__args, record, io_buffer, false)? } else { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_343] = unsafe { *(result.output.as_ptr() as *const [G; OUT_343]) }; __ret } } else { aiur_fn_343(__args, record, io_buffer, __cu)? } }; + let __r_arr: [G; OUT_339] = { let __args: [G; IN_339] = [__v_5, __v_6]; let __cu = unconstrained; if let Some(result) = record.function_queries[339].get_mut(&__args[..]) { if !__cu && *result.multiplicity == G::ZERO { aiur_fn_339(__args, record, io_buffer, false)? } else { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_339] = unsafe { *(result.output.as_ptr() as *const [G; OUT_339]) }; __ret } } else { aiur_fn_339(__args, record, io_buffer, __cu)? } }; let __v_7: G = __r_arr[0]; - let __ret: [G; OUT_341] = [__v_7]; - if let Some(result) = record.function_queries[341].get_mut(&inp[..]) { debug_assert_eq!(result.output, &__ret[..]); if !unconstrained { *result.multiplicity += G::ONE; } } else { record.function_queries[341].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained)); }; + let __ret: [G; OUT_337] = [__v_7]; + if let Some(result) = record.function_queries[337].get_mut(&inp[..]) { debug_assert_eq!(result.output, &__ret[..]); if !unconstrained { *result.multiplicity += G::ONE; } } else { record.function_queries[337].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained)); }; return Ok(__ret); }, 4u64 => { - let __r_arr: [G; OUT_341] = { let __args: [G; IN_341] = [__v_2]; let __cu = unconstrained; if let Some(result) = record.function_queries[341].get_mut(&__args[..]) { if !__cu && *result.multiplicity == G::ZERO { aiur_fn_341(__args, record, io_buffer, false)? } else { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_341] = unsafe { *(result.output.as_ptr() as *const [G; OUT_341]) }; __ret } } else { aiur_fn_341(__args, record, io_buffer, __cu)? } }; + let __r_arr: [G; OUT_337] = { let __args: [G; IN_337] = [__v_2]; let __cu = unconstrained; if let Some(result) = record.function_queries[337].get_mut(&__args[..]) { if !__cu && *result.multiplicity == G::ZERO { aiur_fn_337(__args, record, io_buffer, false)? } else { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_337] = unsafe { *(result.output.as_ptr() as *const [G; OUT_337]) }; __ret } } else { aiur_fn_337(__args, record, io_buffer, __cu)? } }; let __v_5: G = __r_arr[0]; - let __r_arr: [G; OUT_341] = { let __args: [G; IN_341] = [__v_3]; let __cu = unconstrained; if let Some(result) = record.function_queries[341].get_mut(&__args[..]) { if !__cu && *result.multiplicity == G::ZERO { aiur_fn_341(__args, record, io_buffer, false)? } else { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_341] = unsafe { *(result.output.as_ptr() as *const [G; OUT_341]) }; __ret } } else { aiur_fn_341(__args, record, io_buffer, __cu)? } }; + let __r_arr: [G; OUT_337] = { let __args: [G; IN_337] = [__v_3]; let __cu = unconstrained; if let Some(result) = record.function_queries[337].get_mut(&__args[..]) { if !__cu && *result.multiplicity == G::ZERO { aiur_fn_337(__args, record, io_buffer, false)? } else { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_337] = unsafe { *(result.output.as_ptr() as *const [G; OUT_337]) }; __ret } } else { aiur_fn_337(__args, record, io_buffer, __cu)? } }; let __v_6: G = __r_arr[0]; - let __r_arr: [G; OUT_344] = { let __args: [G; IN_344] = [__v_6]; let __cu = unconstrained; if let Some(result) = record.function_queries[344].get_mut(&__args[..]) { if !__cu && *result.multiplicity == G::ZERO { aiur_fn_344(__args, record, io_buffer, false)? } else { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_344] = unsafe { *(result.output.as_ptr() as *const [G; OUT_344]) }; __ret } } else { aiur_fn_344(__args, record, io_buffer, __cu)? } }; + let __r_arr: [G; OUT_340] = { let __args: [G; IN_340] = [__v_6]; let __cu = unconstrained; if let Some(result) = record.function_queries[340].get_mut(&__args[..]) { if !__cu && *result.multiplicity == G::ZERO { aiur_fn_340(__args, record, io_buffer, false)? } else { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_340] = unsafe { *(result.output.as_ptr() as *const [G; OUT_340]) }; __ret } } else { aiur_fn_340(__args, record, io_buffer, __cu)? } }; let __v_7: G = __r_arr[0]; - let __r_arr: [G; OUT_343] = { let __args: [G; IN_343] = [__v_5, __v_7]; let __cu = unconstrained; if let Some(result) = record.function_queries[343].get_mut(&__args[..]) { if !__cu && *result.multiplicity == G::ZERO { aiur_fn_343(__args, record, io_buffer, false)? } else { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_343] = unsafe { *(result.output.as_ptr() as *const [G; OUT_343]) }; __ret } } else { aiur_fn_343(__args, record, io_buffer, __cu)? } }; + let __r_arr: [G; OUT_339] = { let __args: [G; IN_339] = [__v_5, __v_7]; let __cu = unconstrained; if let Some(result) = record.function_queries[339].get_mut(&__args[..]) { if !__cu && *result.multiplicity == G::ZERO { aiur_fn_339(__args, record, io_buffer, false)? } else { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_339] = unsafe { *(result.output.as_ptr() as *const [G; OUT_339]) }; __ret } } else { aiur_fn_339(__args, record, io_buffer, __cu)? } }; let __v_8: G = __r_arr[0]; - let __ret: [G; OUT_341] = [__v_8]; - if let Some(result) = record.function_queries[341].get_mut(&inp[..]) { debug_assert_eq!(result.output, &__ret[..]); if !unconstrained { *result.multiplicity += G::ONE; } } else { record.function_queries[341].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained)); }; + let __ret: [G; OUT_337] = [__v_8]; + if let Some(result) = record.function_queries[337].get_mut(&inp[..]) { debug_assert_eq!(result.output, &__ret[..]); if !unconstrained { *result.multiplicity += G::ONE; } } else { record.function_queries[337].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained)); }; return Ok(__ret); }, 5u64 => { - let __r_arr: [G; OUT_341] = { let __args: [G; IN_341] = [__v_2]; let __cu = unconstrained; if let Some(result) = record.function_queries[341].get_mut(&__args[..]) { if !__cu && *result.multiplicity == G::ZERO { aiur_fn_341(__args, record, io_buffer, false)? } else { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_341] = unsafe { *(result.output.as_ptr() as *const [G; OUT_341]) }; __ret } } else { aiur_fn_341(__args, record, io_buffer, __cu)? } }; + let __r_arr: [G; OUT_337] = { let __args: [G; IN_337] = [__v_2]; let __cu = unconstrained; if let Some(result) = record.function_queries[337].get_mut(&__args[..]) { if !__cu && *result.multiplicity == G::ZERO { aiur_fn_337(__args, record, io_buffer, false)? } else { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_337] = unsafe { *(result.output.as_ptr() as *const [G; OUT_337]) }; __ret } } else { aiur_fn_337(__args, record, io_buffer, __cu)? } }; let __v_5: G = __r_arr[0]; - let __r_arr: [G; OUT_341] = { let __args: [G; IN_341] = [__v_3]; let __cu = unconstrained; if let Some(result) = record.function_queries[341].get_mut(&__args[..]) { if !__cu && *result.multiplicity == G::ZERO { aiur_fn_341(__args, record, io_buffer, false)? } else { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_341] = unsafe { *(result.output.as_ptr() as *const [G; OUT_341]) }; __ret } } else { aiur_fn_341(__args, record, io_buffer, __cu)? } }; + let __r_arr: [G; OUT_337] = { let __args: [G; IN_337] = [__v_3]; let __cu = unconstrained; if let Some(result) = record.function_queries[337].get_mut(&__args[..]) { if !__cu && *result.multiplicity == G::ZERO { aiur_fn_337(__args, record, io_buffer, false)? } else { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_337] = unsafe { *(result.output.as_ptr() as *const [G; OUT_337]) }; __ret } } else { aiur_fn_337(__args, record, io_buffer, __cu)? } }; let __v_6: G = __r_arr[0]; - let __r_arr: [G; OUT_344] = { let __args: [G; IN_344] = [__v_6]; let __cu = unconstrained; if let Some(result) = record.function_queries[344].get_mut(&__args[..]) { if !__cu && *result.multiplicity == G::ZERO { aiur_fn_344(__args, record, io_buffer, false)? } else { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_344] = unsafe { *(result.output.as_ptr() as *const [G; OUT_344]) }; __ret } } else { aiur_fn_344(__args, record, io_buffer, __cu)? } }; + let __r_arr: [G; OUT_340] = { let __args: [G; IN_340] = [__v_6]; let __cu = unconstrained; if let Some(result) = record.function_queries[340].get_mut(&__args[..]) { if !__cu && *result.multiplicity == G::ZERO { aiur_fn_340(__args, record, io_buffer, false)? } else { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_340] = unsafe { *(result.output.as_ptr() as *const [G; OUT_340]) }; __ret } } else { aiur_fn_340(__args, record, io_buffer, __cu)? } }; let __v_7: G = __r_arr[0]; - let __r_arr: [G; OUT_343] = { let __args: [G; IN_343] = [__v_5, __v_7]; let __cu = unconstrained; if let Some(result) = record.function_queries[343].get_mut(&__args[..]) { if !__cu && *result.multiplicity == G::ZERO { aiur_fn_343(__args, record, io_buffer, false)? } else { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_343] = unsafe { *(result.output.as_ptr() as *const [G; OUT_343]) }; __ret } } else { aiur_fn_343(__args, record, io_buffer, __cu)? } }; + let __r_arr: [G; OUT_339] = { let __args: [G; IN_339] = [__v_5, __v_7]; let __cu = unconstrained; if let Some(result) = record.function_queries[339].get_mut(&__args[..]) { if !__cu && *result.multiplicity == G::ZERO { aiur_fn_339(__args, record, io_buffer, false)? } else { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_339] = unsafe { *(result.output.as_ptr() as *const [G; OUT_339]) }; __ret } } else { aiur_fn_339(__args, record, io_buffer, __cu)? } }; let __v_8: G = __r_arr[0]; - let __ret: [G; OUT_341] = [__v_8]; - if let Some(result) = record.function_queries[341].get_mut(&inp[..]) { debug_assert_eq!(result.output, &__ret[..]); if !unconstrained { *result.multiplicity += G::ONE; } } else { record.function_queries[341].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained)); }; + let __ret: [G; OUT_337] = [__v_8]; + if let Some(result) = record.function_queries[337].get_mut(&inp[..]) { debug_assert_eq!(result.output, &__ret[..]); if !unconstrained { *result.multiplicity += G::ONE; } } else { record.function_queries[337].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained)); }; return Ok(__ret); }, 6u64 => { - let __r_arr: [G; OUT_342] = { let __args: [G; IN_342] = [__v_2, __v_3, __v_4]; let __cu = unconstrained; if let Some(result) = record.function_queries[342].get_mut(&__args[..]) { if !__cu && *result.multiplicity == G::ZERO { aiur_fn_342(__args, record, io_buffer, false)? } else { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_342] = unsafe { *(result.output.as_ptr() as *const [G; OUT_342]) }; __ret } } else { aiur_fn_342(__args, record, io_buffer, __cu)? } }; + let __r_arr: [G; OUT_338] = { let __args: [G; IN_338] = [__v_2, __v_3, __v_4]; let __cu = unconstrained; if let Some(result) = record.function_queries[338].get_mut(&__args[..]) { if !__cu && *result.multiplicity == G::ZERO { aiur_fn_338(__args, record, io_buffer, false)? } else { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_338] = unsafe { *(result.output.as_ptr() as *const [G; OUT_338]) }; __ret } } else { aiur_fn_338(__args, record, io_buffer, __cu)? } }; let __v_5: G = __r_arr[0]; - let __ret: [G; OUT_341] = [__v_5]; - if let Some(result) = record.function_queries[341].get_mut(&inp[..]) { debug_assert_eq!(result.output, &__ret[..]); if !unconstrained { *result.multiplicity += G::ONE; } } else { record.function_queries[341].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained)); }; + let __ret: [G; OUT_337] = [__v_5]; + if let Some(result) = record.function_queries[337].get_mut(&inp[..]) { debug_assert_eq!(result.output, &__ret[..]); if !unconstrained { *result.multiplicity += G::ONE; } } else { record.function_queries[337].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained)); }; return Ok(__ret); }, 8u64 => { - let __r_arr: [G; OUT_341] = { let __args: [G; IN_341] = [__v_4]; let __cu = unconstrained; if let Some(result) = record.function_queries[341].get_mut(&__args[..]) { if !__cu && *result.multiplicity == G::ZERO { aiur_fn_341(__args, record, io_buffer, false)? } else { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_341] = unsafe { *(result.output.as_ptr() as *const [G; OUT_341]) }; __ret } } else { aiur_fn_341(__args, record, io_buffer, __cu)? } }; + let __r_arr: [G; OUT_337] = { let __args: [G; IN_337] = [__v_4]; let __cu = unconstrained; if let Some(result) = record.function_queries[337].get_mut(&__args[..]) { if !__cu && *result.multiplicity == G::ZERO { aiur_fn_337(__args, record, io_buffer, false)? } else { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_337] = unsafe { *(result.output.as_ptr() as *const [G; OUT_337]) }; __ret } } else { aiur_fn_337(__args, record, io_buffer, __cu)? } }; let __v_5: G = __r_arr[0]; - let __ret: [G; OUT_341] = [__v_5]; - if let Some(result) = record.function_queries[341].get_mut(&inp[..]) { debug_assert_eq!(result.output, &__ret[..]); if !unconstrained { *result.multiplicity += G::ONE; } } else { record.function_queries[341].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained)); }; + let __ret: [G; OUT_337] = [__v_5]; + if let Some(result) = record.function_queries[337].get_mut(&inp[..]) { debug_assert_eq!(result.output, &__ret[..]); if !unconstrained { *result.multiplicity += G::ONE; } } else { record.function_queries[337].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained)); }; return Ok(__ret); }, _ => { @@ -31870,59 +31596,59 @@ fn aiur_fn_341( }) } -const INPUT_SIZE_342: usize = 3; -const IN_342: usize = 3; -const OUT_342: usize = 1; -fn aiur_fn_342( - inp: [G; IN_342], +const INPUT_SIZE_338: usize = 3; +const IN_338: usize = 3; +const OUT_338: usize = 1; +fn aiur_fn_338( + inp: [G; IN_338], record: &mut QueryRecord, io_buffer: &mut IOBuffer, unconstrained: bool, -) -> Result<[G; OUT_342], ExecError> { +) -> Result<[G; OUT_338], ExecError> { stacker::maybe_grow(64 * 1024, 4 * 1024 * 1024, || { let __v_0: G = inp[0]; let __v_1: G = inp[1]; let __v_2: G = inp[2]; - let __r_arr: [G; OUT_341] = { let __args: [G; IN_341] = [__v_0]; let __cu = unconstrained; if let Some(result) = record.function_queries[341].get_mut(&__args[..]) { if !__cu && *result.multiplicity == G::ZERO { aiur_fn_341(__args, record, io_buffer, false)? } else { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_341] = unsafe { *(result.output.as_ptr() as *const [G; OUT_341]) }; __ret } } else { aiur_fn_341(__args, record, io_buffer, __cu)? } }; + let __r_arr: [G; OUT_337] = { let __args: [G; IN_337] = [__v_0]; let __cu = unconstrained; if let Some(result) = record.function_queries[337].get_mut(&__args[..]) { if !__cu && *result.multiplicity == G::ZERO { aiur_fn_337(__args, record, io_buffer, false)? } else { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_337] = unsafe { *(result.output.as_ptr() as *const [G; OUT_337]) }; __ret } } else { aiur_fn_337(__args, record, io_buffer, __cu)? } }; let __v_3: G = __r_arr[0]; - let __r_arr: [G; OUT_341] = { let __args: [G; IN_341] = [__v_1]; let __cu = unconstrained; if let Some(result) = record.function_queries[341].get_mut(&__args[..]) { if !__cu && *result.multiplicity == G::ZERO { aiur_fn_341(__args, record, io_buffer, false)? } else { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_341] = unsafe { *(result.output.as_ptr() as *const [G; OUT_341]) }; __ret } } else { aiur_fn_341(__args, record, io_buffer, __cu)? } }; + let __r_arr: [G; OUT_337] = { let __args: [G; IN_337] = [__v_1]; let __cu = unconstrained; if let Some(result) = record.function_queries[337].get_mut(&__args[..]) { if !__cu && *result.multiplicity == G::ZERO { aiur_fn_337(__args, record, io_buffer, false)? } else { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_337] = unsafe { *(result.output.as_ptr() as *const [G; OUT_337]) }; __ret } } else { aiur_fn_337(__args, record, io_buffer, __cu)? } }; let __v_4: G = __r_arr[0]; - let __r_arr: [G; OUT_343] = { let __args: [G; IN_343] = [__v_3, __v_4]; let __cu = unconstrained; if let Some(result) = record.function_queries[343].get_mut(&__args[..]) { if !__cu && *result.multiplicity == G::ZERO { aiur_fn_343(__args, record, io_buffer, false)? } else { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_343] = unsafe { *(result.output.as_ptr() as *const [G; OUT_343]) }; __ret } } else { aiur_fn_343(__args, record, io_buffer, __cu)? } }; + let __r_arr: [G; OUT_339] = { let __args: [G; IN_339] = [__v_3, __v_4]; let __cu = unconstrained; if let Some(result) = record.function_queries[339].get_mut(&__args[..]) { if !__cu && *result.multiplicity == G::ZERO { aiur_fn_339(__args, record, io_buffer, false)? } else { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_339] = unsafe { *(result.output.as_ptr() as *const [G; OUT_339]) }; __ret } } else { aiur_fn_339(__args, record, io_buffer, __cu)? } }; let __v_5: G = __r_arr[0]; - let __r_arr: [G; OUT_341] = { let __args: [G; IN_341] = [__v_2]; let __cu = unconstrained; if let Some(result) = record.function_queries[341].get_mut(&__args[..]) { if !__cu && *result.multiplicity == G::ZERO { aiur_fn_341(__args, record, io_buffer, false)? } else { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_341] = unsafe { *(result.output.as_ptr() as *const [G; OUT_341]) }; __ret } } else { aiur_fn_341(__args, record, io_buffer, __cu)? } }; + let __r_arr: [G; OUT_337] = { let __args: [G; IN_337] = [__v_2]; let __cu = unconstrained; if let Some(result) = record.function_queries[337].get_mut(&__args[..]) { if !__cu && *result.multiplicity == G::ZERO { aiur_fn_337(__args, record, io_buffer, false)? } else { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_337] = unsafe { *(result.output.as_ptr() as *const [G; OUT_337]) }; __ret } } else { aiur_fn_337(__args, record, io_buffer, __cu)? } }; let __v_6: G = __r_arr[0]; - let __r_arr: [G; OUT_344] = { let __args: [G; IN_344] = [__v_6]; let __cu = unconstrained; if let Some(result) = record.function_queries[344].get_mut(&__args[..]) { if !__cu && *result.multiplicity == G::ZERO { aiur_fn_344(__args, record, io_buffer, false)? } else { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_344] = unsafe { *(result.output.as_ptr() as *const [G; OUT_344]) }; __ret } } else { aiur_fn_344(__args, record, io_buffer, __cu)? } }; + let __r_arr: [G; OUT_340] = { let __args: [G; IN_340] = [__v_6]; let __cu = unconstrained; if let Some(result) = record.function_queries[340].get_mut(&__args[..]) { if !__cu && *result.multiplicity == G::ZERO { aiur_fn_340(__args, record, io_buffer, false)? } else { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_340] = unsafe { *(result.output.as_ptr() as *const [G; OUT_340]) }; __ret } } else { aiur_fn_340(__args, record, io_buffer, __cu)? } }; let __v_7: G = __r_arr[0]; - let __r_arr: [G; OUT_343] = { let __args: [G; IN_343] = [__v_5, __v_7]; let __cu = unconstrained; if let Some(result) = record.function_queries[343].get_mut(&__args[..]) { if !__cu && *result.multiplicity == G::ZERO { aiur_fn_343(__args, record, io_buffer, false)? } else { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_343] = unsafe { *(result.output.as_ptr() as *const [G; OUT_343]) }; __ret } } else { aiur_fn_343(__args, record, io_buffer, __cu)? } }; + let __r_arr: [G; OUT_339] = { let __args: [G; IN_339] = [__v_5, __v_7]; let __cu = unconstrained; if let Some(result) = record.function_queries[339].get_mut(&__args[..]) { if !__cu && *result.multiplicity == G::ZERO { aiur_fn_339(__args, record, io_buffer, false)? } else { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_339] = unsafe { *(result.output.as_ptr() as *const [G; OUT_339]) }; __ret } } else { aiur_fn_339(__args, record, io_buffer, __cu)? } }; let __v_8: G = __r_arr[0]; - let __ret: [G; OUT_342] = [__v_8]; - if let Some(result) = record.function_queries[342].get_mut(&inp[..]) { debug_assert_eq!(result.output, &__ret[..]); if !unconstrained { *result.multiplicity += G::ONE; } } else { record.function_queries[342].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained)); }; + let __ret: [G; OUT_338] = [__v_8]; + if let Some(result) = record.function_queries[338].get_mut(&inp[..]) { debug_assert_eq!(result.output, &__ret[..]); if !unconstrained { *result.multiplicity += G::ONE; } } else { record.function_queries[338].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained)); }; return Ok(__ret); }) } -const INPUT_SIZE_343: usize = 2; -const IN_343: usize = 2; -const OUT_343: usize = 1; -fn aiur_fn_343( - inp: [G; IN_343], +const INPUT_SIZE_339: usize = 2; +const IN_339: usize = 2; +const OUT_339: usize = 1; +fn aiur_fn_339( + inp: [G; IN_339], record: &mut QueryRecord, io_buffer: &mut IOBuffer, unconstrained: bool, -) -> Result<[G; OUT_343], ExecError> { +) -> Result<[G; OUT_339], ExecError> { stacker::maybe_grow(64 * 1024, 4 * 1024 * 1024, || { let __v_0: G = inp[0]; let __v_1: G = inp[1]; let __v_2: G = { let __a_val = __v_0.as_canonical_u64(); let __b_val = __v_1.as_canonical_u64(); let __a_u32 = u32::try_from(__a_val).ok().ok_or(ExecError::U32OutOfRange(__a_val))?; let __b_u32 = u32::try_from(__b_val).ok().ok_or(ExecError::U32OutOfRange(__b_val))?; let __result = G::from_bool(__a_u32 < __b_u32); if !unconstrained { let __x_bytes = __a_u32.to_le_bytes(); let __z_bytes = __b_u32.to_le_bytes(); let __c_u32 = __b_u32.wrapping_sub(__a_u32).wrapping_sub(1); let __y_bytes = __c_u32.to_le_bytes(); record.bytes2_queries.bump_range_check(&G::from_u8(__x_bytes[0]), &G::from_u8(__x_bytes[1])); record.bytes2_queries.bump_range_check(&G::from_u8(__x_bytes[2]), &G::from_u8(__x_bytes[3])); record.bytes2_queries.bump_range_check(&G::from_u8(__y_bytes[0]), &G::from_u8(__y_bytes[1])); record.bytes2_queries.bump_range_check(&G::from_u8(__y_bytes[2]), &G::from_u8(__y_bytes[3])); record.bytes2_queries.bump_range_check(&G::from_u8(__z_bytes[0]), &G::from_u8(__z_bytes[1])); record.bytes2_queries.bump_range_check(&G::from_u8(__z_bytes[2]), &G::from_u8(__z_bytes[3])); } __result }; match __v_2.as_canonical_u64() { 1u64 => { - let __ret: [G; OUT_343] = [__v_1]; - if let Some(result) = record.function_queries[343].get_mut(&inp[..]) { debug_assert_eq!(result.output, &__ret[..]); if !unconstrained { *result.multiplicity += G::ONE; } } else { record.function_queries[343].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained)); }; + let __ret: [G; OUT_339] = [__v_1]; + if let Some(result) = record.function_queries[339].get_mut(&inp[..]) { debug_assert_eq!(result.output, &__ret[..]); if !unconstrained { *result.multiplicity += G::ONE; } } else { record.function_queries[339].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained)); }; return Ok(__ret); }, 0u64 => { - let __ret: [G; OUT_343] = [__v_0]; - if let Some(result) = record.function_queries[343].get_mut(&inp[..]) { debug_assert_eq!(result.output, &__ret[..]); if !unconstrained { *result.multiplicity += G::ONE; } } else { record.function_queries[343].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained)); }; + let __ret: [G; OUT_339] = [__v_0]; + if let Some(result) = record.function_queries[339].get_mut(&inp[..]) { debug_assert_eq!(result.output, &__ret[..]); if !unconstrained { *result.multiplicity += G::ONE; } } else { record.function_queries[339].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained)); }; return Ok(__ret); }, _ => { @@ -31932,57 +31658,57 @@ fn aiur_fn_343( }) } -const INPUT_SIZE_344: usize = 1; -const IN_344: usize = 1; -const OUT_344: usize = 1; -fn aiur_fn_344( - inp: [G; IN_344], +const INPUT_SIZE_340: usize = 1; +const IN_340: usize = 1; +const OUT_340: usize = 1; +fn aiur_fn_340( + inp: [G; IN_340], record: &mut QueryRecord, io_buffer: &mut IOBuffer, unconstrained: bool, -) -> Result<[G; OUT_344], ExecError> { +) -> Result<[G; OUT_340], ExecError> { stacker::maybe_grow(64 * 1024, 4 * 1024 * 1024, || { let __v_0: G = inp[0]; match __v_0.as_canonical_u64() { 0u64 => { let __v_1: G = G::from_u64(0); - let __ret: [G; OUT_344] = [__v_1]; - if let Some(result) = record.function_queries[344].get_mut(&inp[..]) { debug_assert_eq!(result.output, &__ret[..]); if !unconstrained { *result.multiplicity += G::ONE; } } else { record.function_queries[344].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained)); }; + let __ret: [G; OUT_340] = [__v_1]; + if let Some(result) = record.function_queries[340].get_mut(&inp[..]) { debug_assert_eq!(result.output, &__ret[..]); if !unconstrained { *result.multiplicity += G::ONE; } } else { record.function_queries[340].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained)); }; return Ok(__ret); }, _ => { let __v_1: G = G::from_u64(1); let __v_2: G = (__v_0 - __v_1); - let __ret: [G; OUT_344] = [__v_2]; - if let Some(result) = record.function_queries[344].get_mut(&inp[..]) { debug_assert_eq!(result.output, &__ret[..]); if !unconstrained { *result.multiplicity += G::ONE; } } else { record.function_queries[344].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained)); }; + let __ret: [G; OUT_340] = [__v_2]; + if let Some(result) = record.function_queries[340].get_mut(&inp[..]) { debug_assert_eq!(result.output, &__ret[..]); if !unconstrained { *result.multiplicity += G::ONE; } } else { record.function_queries[340].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained)); }; return Ok(__ret); }, } }) } -const INPUT_SIZE_345: usize = 2; -const IN_345: usize = 2; -const OUT_345: usize = 1; -fn aiur_fn_345( - inp: [G; IN_345], +const INPUT_SIZE_341: usize = 2; +const IN_341: usize = 2; +const OUT_341: usize = 1; +fn aiur_fn_341( + inp: [G; IN_341], record: &mut QueryRecord, io_buffer: &mut IOBuffer, unconstrained: bool, -) -> Result<[G; OUT_345], ExecError> { +) -> Result<[G; OUT_341], ExecError> { stacker::maybe_grow(64 * 1024, 4 * 1024 * 1024, || { let __v_0: G = inp[0]; let __v_1: G = inp[1]; let __v_2: G = { let __a_val = __v_0.as_canonical_u64(); let __b_val = __v_1.as_canonical_u64(); let __a_u32 = u32::try_from(__a_val).ok().ok_or(ExecError::U32OutOfRange(__a_val))?; let __b_u32 = u32::try_from(__b_val).ok().ok_or(ExecError::U32OutOfRange(__b_val))?; let __result = G::from_bool(__a_u32 < __b_u32); if !unconstrained { let __x_bytes = __a_u32.to_le_bytes(); let __z_bytes = __b_u32.to_le_bytes(); let __c_u32 = __b_u32.wrapping_sub(__a_u32).wrapping_sub(1); let __y_bytes = __c_u32.to_le_bytes(); record.bytes2_queries.bump_range_check(&G::from_u8(__x_bytes[0]), &G::from_u8(__x_bytes[1])); record.bytes2_queries.bump_range_check(&G::from_u8(__x_bytes[2]), &G::from_u8(__x_bytes[3])); record.bytes2_queries.bump_range_check(&G::from_u8(__y_bytes[0]), &G::from_u8(__y_bytes[1])); record.bytes2_queries.bump_range_check(&G::from_u8(__y_bytes[2]), &G::from_u8(__y_bytes[3])); record.bytes2_queries.bump_range_check(&G::from_u8(__z_bytes[0]), &G::from_u8(__z_bytes[1])); record.bytes2_queries.bump_range_check(&G::from_u8(__z_bytes[2]), &G::from_u8(__z_bytes[3])); } __result }; match __v_2.as_canonical_u64() { 1u64 => { - let __ret: [G; OUT_345] = [__v_0]; - if let Some(result) = record.function_queries[345].get_mut(&inp[..]) { debug_assert_eq!(result.output, &__ret[..]); if !unconstrained { *result.multiplicity += G::ONE; } } else { record.function_queries[345].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained)); }; + let __ret: [G; OUT_341] = [__v_0]; + if let Some(result) = record.function_queries[341].get_mut(&inp[..]) { debug_assert_eq!(result.output, &__ret[..]); if !unconstrained { *result.multiplicity += G::ONE; } } else { record.function_queries[341].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained)); }; return Ok(__ret); }, 0u64 => { - let __ret: [G; OUT_345] = [__v_1]; - if let Some(result) = record.function_queries[345].get_mut(&inp[..]) { debug_assert_eq!(result.output, &__ret[..]); if !unconstrained { *result.multiplicity += G::ONE; } } else { record.function_queries[345].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained)); }; + let __ret: [G; OUT_341] = [__v_1]; + if let Some(result) = record.function_queries[341].get_mut(&inp[..]) { debug_assert_eq!(result.output, &__ret[..]); if !unconstrained { *result.multiplicity += G::ONE; } } else { record.function_queries[341].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained)); }; return Ok(__ret); }, _ => { @@ -31992,34 +31718,34 @@ fn aiur_fn_345( }) } -const INPUT_SIZE_346: usize = 2; -const IN_346: usize = 2; -const OUT_346: usize = 1; -fn aiur_fn_346( - inp: [G; IN_346], +const INPUT_SIZE_342: usize = 2; +const IN_342: usize = 2; +const OUT_342: usize = 1; +fn aiur_fn_342( + inp: [G; IN_342], record: &mut QueryRecord, io_buffer: &mut IOBuffer, unconstrained: bool, -) -> Result<[G; OUT_346], ExecError> { +) -> Result<[G; OUT_342], ExecError> { stacker::maybe_grow(64 * 1024, 4 * 1024 * 1024, || { let __v_0: G = inp[0]; let __v_1: G = inp[1]; let __v_2: G = { let __a_val = __v_0.as_canonical_u64(); let __b_val = __v_1.as_canonical_u64(); let __a_u32 = u32::try_from(__a_val).ok().ok_or(ExecError::U32OutOfRange(__a_val))?; let __b_u32 = u32::try_from(__b_val).ok().ok_or(ExecError::U32OutOfRange(__b_val))?; let __result = G::from_bool(__a_u32 < __b_u32); if !unconstrained { let __x_bytes = __a_u32.to_le_bytes(); let __z_bytes = __b_u32.to_le_bytes(); let __c_u32 = __b_u32.wrapping_sub(__a_u32).wrapping_sub(1); let __y_bytes = __c_u32.to_le_bytes(); record.bytes2_queries.bump_range_check(&G::from_u8(__x_bytes[0]), &G::from_u8(__x_bytes[1])); record.bytes2_queries.bump_range_check(&G::from_u8(__x_bytes[2]), &G::from_u8(__x_bytes[3])); record.bytes2_queries.bump_range_check(&G::from_u8(__y_bytes[0]), &G::from_u8(__y_bytes[1])); record.bytes2_queries.bump_range_check(&G::from_u8(__y_bytes[2]), &G::from_u8(__y_bytes[3])); record.bytes2_queries.bump_range_check(&G::from_u8(__z_bytes[0]), &G::from_u8(__z_bytes[1])); record.bytes2_queries.bump_range_check(&G::from_u8(__z_bytes[2]), &G::from_u8(__z_bytes[3])); } __result }; - let __ret: [G; OUT_346] = [__v_2]; - if let Some(result) = record.function_queries[346].get_mut(&inp[..]) { debug_assert_eq!(result.output, &__ret[..]); if !unconstrained { *result.multiplicity += G::ONE; } } else { record.function_queries[346].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained)); }; + let __ret: [G; OUT_342] = [__v_2]; + if let Some(result) = record.function_queries[342].get_mut(&inp[..]) { debug_assert_eq!(result.output, &__ret[..]); if !unconstrained { *result.multiplicity += G::ONE; } } else { record.function_queries[342].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained)); }; return Ok(__ret); }) } -const INPUT_SIZE_347: usize = 3; -const IN_347: usize = 3; -const OUT_347: usize = 1; -fn aiur_fn_347( - inp: [G; IN_347], +const INPUT_SIZE_343: usize = 3; +const IN_343: usize = 3; +const OUT_343: usize = 1; +fn aiur_fn_343( + inp: [G; IN_343], record: &mut QueryRecord, io_buffer: &mut IOBuffer, unconstrained: bool, -) -> Result<[G; OUT_347], ExecError> { +) -> Result<[G; OUT_343], ExecError> { stacker::maybe_grow(64 * 1024, 4 * 1024 * 1024, || { let __v_0: G = inp[0]; let __v_1: G = inp[1]; @@ -32035,14 +31761,14 @@ fn aiur_fn_347( match __v_7.as_canonical_u64() { 1u64 => { let __v_8: G = G::from_u64(0); - let __ret: [G; OUT_347] = [__v_8]; - if let Some(result) = record.function_queries[347].get_mut(&inp[..]) { debug_assert_eq!(result.output, &__ret[..]); if !unconstrained { *result.multiplicity += G::ONE; } } else { record.function_queries[347].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained)); }; + let __ret: [G; OUT_343] = [__v_8]; + if let Some(result) = record.function_queries[343].get_mut(&inp[..]) { debug_assert_eq!(result.output, &__ret[..]); if !unconstrained { *result.multiplicity += G::ONE; } } else { record.function_queries[343].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained)); }; return Ok(__ret); }, 0u64 => { let __v_8: G = { let __a_val = __v_4.as_canonical_u64(); let __b_val = __v_2.as_canonical_u64(); let __a_u32 = u32::try_from(__a_val).ok().ok_or(ExecError::U32OutOfRange(__a_val))?; let __b_u32 = u32::try_from(__b_val).ok().ok_or(ExecError::U32OutOfRange(__b_val))?; let __result = G::from_bool(__a_u32 < __b_u32); if !unconstrained { let __x_bytes = __a_u32.to_le_bytes(); let __z_bytes = __b_u32.to_le_bytes(); let __c_u32 = __b_u32.wrapping_sub(__a_u32).wrapping_sub(1); let __y_bytes = __c_u32.to_le_bytes(); record.bytes2_queries.bump_range_check(&G::from_u8(__x_bytes[0]), &G::from_u8(__x_bytes[1])); record.bytes2_queries.bump_range_check(&G::from_u8(__x_bytes[2]), &G::from_u8(__x_bytes[3])); record.bytes2_queries.bump_range_check(&G::from_u8(__y_bytes[0]), &G::from_u8(__y_bytes[1])); record.bytes2_queries.bump_range_check(&G::from_u8(__y_bytes[2]), &G::from_u8(__y_bytes[3])); record.bytes2_queries.bump_range_check(&G::from_u8(__z_bytes[0]), &G::from_u8(__z_bytes[1])); record.bytes2_queries.bump_range_check(&G::from_u8(__z_bytes[2]), &G::from_u8(__z_bytes[3])); } __result }; - let __ret: [G; OUT_347] = [__v_8]; - if let Some(result) = record.function_queries[347].get_mut(&inp[..]) { debug_assert_eq!(result.output, &__ret[..]); if !unconstrained { *result.multiplicity += G::ONE; } } else { record.function_queries[347].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained)); }; + let __ret: [G; OUT_343] = [__v_8]; + if let Some(result) = record.function_queries[343].get_mut(&inp[..]) { debug_assert_eq!(result.output, &__ret[..]); if !unconstrained { *result.multiplicity += G::ONE; } } else { record.function_queries[343].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained)); }; return Ok(__ret); }, _ => { @@ -32052,37 +31778,37 @@ fn aiur_fn_347( }, 1u64 => { let __v_7: G = G::from_u64(0); - let __ret: [G; OUT_347] = [__v_7]; - if let Some(result) = record.function_queries[347].get_mut(&inp[..]) { debug_assert_eq!(result.output, &__ret[..]); if !unconstrained { *result.multiplicity += G::ONE; } } else { record.function_queries[347].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained)); }; + let __ret: [G; OUT_343] = [__v_7]; + if let Some(result) = record.function_queries[343].get_mut(&inp[..]) { debug_assert_eq!(result.output, &__ret[..]); if !unconstrained { *result.multiplicity += G::ONE; } } else { record.function_queries[343].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained)); }; return Ok(__ret); }, 2u64 => { let __v_7: G = G::from_u64(0); - let __ret: [G; OUT_347] = [__v_7]; - if let Some(result) = record.function_queries[347].get_mut(&inp[..]) { debug_assert_eq!(result.output, &__ret[..]); if !unconstrained { *result.multiplicity += G::ONE; } } else { record.function_queries[347].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained)); }; + let __ret: [G; OUT_343] = [__v_7]; + if let Some(result) = record.function_queries[343].get_mut(&inp[..]) { debug_assert_eq!(result.output, &__ret[..]); if !unconstrained { *result.multiplicity += G::ONE; } } else { record.function_queries[343].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained)); }; return Ok(__ret); }, 7u64 => { let __v_7: G = G::from_u64(0); - let __ret: [G; OUT_347] = [__v_7]; - if let Some(result) = record.function_queries[347].get_mut(&inp[..]) { debug_assert_eq!(result.output, &__ret[..]); if !unconstrained { *result.multiplicity += G::ONE; } } else { record.function_queries[347].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained)); }; + let __ret: [G; OUT_343] = [__v_7]; + if let Some(result) = record.function_queries[343].get_mut(&inp[..]) { debug_assert_eq!(result.output, &__ret[..]); if !unconstrained { *result.multiplicity += G::ONE; } } else { record.function_queries[343].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained)); }; return Ok(__ret); }, 3u64 => { - let __r_arr: [G; OUT_347] = { let __args: [G; IN_347] = [__v_4, __v_1, __v_2]; let __cu = unconstrained; if let Some(result) = record.function_queries[347].get_mut(&__args[..]) { if !__cu && *result.multiplicity == G::ZERO { aiur_fn_347(__args, record, io_buffer, false)? } else { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_347] = unsafe { *(result.output.as_ptr() as *const [G; OUT_347]) }; __ret } } else { aiur_fn_347(__args, record, io_buffer, __cu)? } }; + let __r_arr: [G; OUT_343] = { let __args: [G; IN_343] = [__v_4, __v_1, __v_2]; let __cu = unconstrained; if let Some(result) = record.function_queries[343].get_mut(&__args[..]) { if !__cu && *result.multiplicity == G::ZERO { aiur_fn_343(__args, record, io_buffer, false)? } else { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_343] = unsafe { *(result.output.as_ptr() as *const [G; OUT_343]) }; __ret } } else { aiur_fn_343(__args, record, io_buffer, __cu)? } }; let __v_7: G = __r_arr[0]; match __v_7.as_canonical_u64() { 1u64 => { let __v_8: G = G::from_u64(1); - let __ret: [G; OUT_347] = [__v_8]; - if let Some(result) = record.function_queries[347].get_mut(&inp[..]) { debug_assert_eq!(result.output, &__ret[..]); if !unconstrained { *result.multiplicity += G::ONE; } } else { record.function_queries[347].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained)); }; + let __ret: [G; OUT_343] = [__v_8]; + if let Some(result) = record.function_queries[343].get_mut(&inp[..]) { debug_assert_eq!(result.output, &__ret[..]); if !unconstrained { *result.multiplicity += G::ONE; } } else { record.function_queries[343].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained)); }; return Ok(__ret); }, 0u64 => { - let __r_arr: [G; OUT_347] = { let __args: [G; IN_347] = [__v_5, __v_1, __v_2]; let __cu = unconstrained; if let Some(result) = record.function_queries[347].get_mut(&__args[..]) { if !__cu && *result.multiplicity == G::ZERO { aiur_fn_347(__args, record, io_buffer, false)? } else { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_347] = unsafe { *(result.output.as_ptr() as *const [G; OUT_347]) }; __ret } } else { aiur_fn_347(__args, record, io_buffer, __cu)? } }; + let __r_arr: [G; OUT_343] = { let __args: [G; IN_343] = [__v_5, __v_1, __v_2]; let __cu = unconstrained; if let Some(result) = record.function_queries[343].get_mut(&__args[..]) { if !__cu && *result.multiplicity == G::ZERO { aiur_fn_343(__args, record, io_buffer, false)? } else { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_343] = unsafe { *(result.output.as_ptr() as *const [G; OUT_343]) }; __ret } } else { aiur_fn_343(__args, record, io_buffer, __cu)? } }; let __v_8: G = __r_arr[0]; - let __ret: [G; OUT_347] = [__v_8]; - if let Some(result) = record.function_queries[347].get_mut(&inp[..]) { debug_assert_eq!(result.output, &__ret[..]); if !unconstrained { *result.multiplicity += G::ONE; } } else { record.function_queries[347].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained)); }; + let __ret: [G; OUT_343] = [__v_8]; + if let Some(result) = record.function_queries[343].get_mut(&inp[..]) { debug_assert_eq!(result.output, &__ret[..]); if !unconstrained { *result.multiplicity += G::ONE; } } else { record.function_queries[343].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained)); }; return Ok(__ret); }, _ => { @@ -32091,31 +31817,31 @@ fn aiur_fn_347( } }, 4u64 => { - let __r_arr: [G; OUT_348] = { let __args: [G; IN_348] = [__v_4, __v_5, __v_1, __v_2]; let __cu = unconstrained; if let Some(result) = record.function_queries[348].get_mut(&__args[..]) { if !__cu && *result.multiplicity == G::ZERO { aiur_fn_348(__args, record, io_buffer, false)? } else { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_348] = unsafe { *(result.output.as_ptr() as *const [G; OUT_348]) }; __ret } } else { aiur_fn_348(__args, record, io_buffer, __cu)? } }; + let __r_arr: [G; OUT_344] = { let __args: [G; IN_344] = [__v_4, __v_5, __v_1, __v_2]; let __cu = unconstrained; if let Some(result) = record.function_queries[344].get_mut(&__args[..]) { if !__cu && *result.multiplicity == G::ZERO { aiur_fn_344(__args, record, io_buffer, false)? } else { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_344] = unsafe { *(result.output.as_ptr() as *const [G; OUT_344]) }; __ret } } else { aiur_fn_344(__args, record, io_buffer, __cu)? } }; let __v_7: G = __r_arr[0]; - let __ret: [G; OUT_347] = [__v_7]; - if let Some(result) = record.function_queries[347].get_mut(&inp[..]) { debug_assert_eq!(result.output, &__ret[..]); if !unconstrained { *result.multiplicity += G::ONE; } } else { record.function_queries[347].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained)); }; + let __ret: [G; OUT_343] = [__v_7]; + if let Some(result) = record.function_queries[343].get_mut(&inp[..]) { debug_assert_eq!(result.output, &__ret[..]); if !unconstrained { *result.multiplicity += G::ONE; } } else { record.function_queries[343].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained)); }; return Ok(__ret); }, 5u64 => { - let __r_arr: [G; OUT_348] = { let __args: [G; IN_348] = [__v_4, __v_5, __v_1, __v_2]; let __cu = unconstrained; if let Some(result) = record.function_queries[348].get_mut(&__args[..]) { if !__cu && *result.multiplicity == G::ZERO { aiur_fn_348(__args, record, io_buffer, false)? } else { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_348] = unsafe { *(result.output.as_ptr() as *const [G; OUT_348]) }; __ret } } else { aiur_fn_348(__args, record, io_buffer, __cu)? } }; + let __r_arr: [G; OUT_344] = { let __args: [G; IN_344] = [__v_4, __v_5, __v_1, __v_2]; let __cu = unconstrained; if let Some(result) = record.function_queries[344].get_mut(&__args[..]) { if !__cu && *result.multiplicity == G::ZERO { aiur_fn_344(__args, record, io_buffer, false)? } else { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_344] = unsafe { *(result.output.as_ptr() as *const [G; OUT_344]) }; __ret } } else { aiur_fn_344(__args, record, io_buffer, __cu)? } }; let __v_7: G = __r_arr[0]; - let __ret: [G; OUT_347] = [__v_7]; - if let Some(result) = record.function_queries[347].get_mut(&inp[..]) { debug_assert_eq!(result.output, &__ret[..]); if !unconstrained { *result.multiplicity += G::ONE; } } else { record.function_queries[347].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained)); }; + let __ret: [G; OUT_343] = [__v_7]; + if let Some(result) = record.function_queries[343].get_mut(&inp[..]) { debug_assert_eq!(result.output, &__ret[..]); if !unconstrained { *result.multiplicity += G::ONE; } } else { record.function_queries[343].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained)); }; return Ok(__ret); }, 6u64 => { - let __r_arr: [G; OUT_349] = { let __args: [G; IN_349] = [__v_4, __v_5, __v_6, __v_1, __v_2]; let __cu = unconstrained; if let Some(result) = record.function_queries[349].get_mut(&__args[..]) { if !__cu && *result.multiplicity == G::ZERO { aiur_fn_349(__args, record, io_buffer, false)? } else { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_349] = unsafe { *(result.output.as_ptr() as *const [G; OUT_349]) }; __ret } } else { aiur_fn_349(__args, record, io_buffer, __cu)? } }; + let __r_arr: [G; OUT_345] = { let __args: [G; IN_345] = [__v_4, __v_5, __v_6, __v_1, __v_2]; let __cu = unconstrained; if let Some(result) = record.function_queries[345].get_mut(&__args[..]) { if !__cu && *result.multiplicity == G::ZERO { aiur_fn_345(__args, record, io_buffer, false)? } else { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_345] = unsafe { *(result.output.as_ptr() as *const [G; OUT_345]) }; __ret } } else { aiur_fn_345(__args, record, io_buffer, __cu)? } }; let __v_7: G = __r_arr[0]; - let __ret: [G; OUT_347] = [__v_7]; - if let Some(result) = record.function_queries[347].get_mut(&inp[..]) { debug_assert_eq!(result.output, &__ret[..]); if !unconstrained { *result.multiplicity += G::ONE; } } else { record.function_queries[347].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained)); }; + let __ret: [G; OUT_343] = [__v_7]; + if let Some(result) = record.function_queries[343].get_mut(&inp[..]) { debug_assert_eq!(result.output, &__ret[..]); if !unconstrained { *result.multiplicity += G::ONE; } } else { record.function_queries[343].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained)); }; return Ok(__ret); }, 8u64 => { - let __r_arr: [G; OUT_347] = { let __args: [G; IN_347] = [__v_6, __v_1, __v_2]; let __cu = unconstrained; if let Some(result) = record.function_queries[347].get_mut(&__args[..]) { if !__cu && *result.multiplicity == G::ZERO { aiur_fn_347(__args, record, io_buffer, false)? } else { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_347] = unsafe { *(result.output.as_ptr() as *const [G; OUT_347]) }; __ret } } else { aiur_fn_347(__args, record, io_buffer, __cu)? } }; + let __r_arr: [G; OUT_343] = { let __args: [G; IN_343] = [__v_6, __v_1, __v_2]; let __cu = unconstrained; if let Some(result) = record.function_queries[343].get_mut(&__args[..]) { if !__cu && *result.multiplicity == G::ZERO { aiur_fn_343(__args, record, io_buffer, false)? } else { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_343] = unsafe { *(result.output.as_ptr() as *const [G; OUT_343]) }; __ret } } else { aiur_fn_343(__args, record, io_buffer, __cu)? } }; let __v_7: G = __r_arr[0]; - let __ret: [G; OUT_347] = [__v_7]; - if let Some(result) = record.function_queries[347].get_mut(&inp[..]) { debug_assert_eq!(result.output, &__ret[..]); if !unconstrained { *result.multiplicity += G::ONE; } } else { record.function_queries[347].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained)); }; + let __ret: [G; OUT_343] = [__v_7]; + if let Some(result) = record.function_queries[343].get_mut(&inp[..]) { debug_assert_eq!(result.output, &__ret[..]); if !unconstrained { *result.multiplicity += G::ONE; } } else { record.function_queries[343].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained)); }; return Ok(__ret); }, _ => { @@ -32125,27 +31851,27 @@ fn aiur_fn_347( }) } -const INPUT_SIZE_348: usize = 4; -const IN_348: usize = 4; -const OUT_348: usize = 1; -fn aiur_fn_348( - inp: [G; IN_348], +const INPUT_SIZE_344: usize = 4; +const IN_344: usize = 4; +const OUT_344: usize = 1; +fn aiur_fn_344( + inp: [G; IN_344], record: &mut QueryRecord, io_buffer: &mut IOBuffer, unconstrained: bool, -) -> Result<[G; OUT_348], ExecError> { +) -> Result<[G; OUT_344], ExecError> { stacker::maybe_grow(64 * 1024, 4 * 1024 * 1024, || { let __v_0: G = inp[0]; let __v_1: G = inp[1]; let __v_2: G = inp[2]; let __v_3: G = inp[3]; - let __r_arr: [G; OUT_347] = { let __args: [G; IN_347] = [__v_0, __v_2, __v_3]; let __cu = unconstrained; if let Some(result) = record.function_queries[347].get_mut(&__args[..]) { if !__cu && *result.multiplicity == G::ZERO { aiur_fn_347(__args, record, io_buffer, false)? } else { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_347] = unsafe { *(result.output.as_ptr() as *const [G; OUT_347]) }; __ret } } else { aiur_fn_347(__args, record, io_buffer, __cu)? } }; + let __r_arr: [G; OUT_343] = { let __args: [G; IN_343] = [__v_0, __v_2, __v_3]; let __cu = unconstrained; if let Some(result) = record.function_queries[343].get_mut(&__args[..]) { if !__cu && *result.multiplicity == G::ZERO { aiur_fn_343(__args, record, io_buffer, false)? } else { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_343] = unsafe { *(result.output.as_ptr() as *const [G; OUT_343]) }; __ret } } else { aiur_fn_343(__args, record, io_buffer, __cu)? } }; let __v_4: G = __r_arr[0]; match __v_4.as_canonical_u64() { 1u64 => { let __v_5: G = G::from_u64(1); - let __ret: [G; OUT_348] = [__v_5]; - if let Some(result) = record.function_queries[348].get_mut(&inp[..]) { debug_assert_eq!(result.output, &__ret[..]); if !unconstrained { *result.multiplicity += G::ONE; } } else { record.function_queries[348].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained)); }; + let __ret: [G; OUT_344] = [__v_5]; + if let Some(result) = record.function_queries[344].get_mut(&inp[..]) { debug_assert_eq!(result.output, &__ret[..]); if !unconstrained { *result.multiplicity += G::ONE; } } else { record.function_queries[344].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained)); }; return Ok(__ret); }, 0u64 => { @@ -32153,10 +31879,10 @@ fn aiur_fn_348( let __v_6: G = (__v_2 + __v_5); let __v_7: G = G::from_u64(1); let __v_8: G = (__v_3 + __v_7); - let __r_arr: [G; OUT_347] = { let __args: [G; IN_347] = [__v_1, __v_6, __v_8]; let __cu = unconstrained; if let Some(result) = record.function_queries[347].get_mut(&__args[..]) { if !__cu && *result.multiplicity == G::ZERO { aiur_fn_347(__args, record, io_buffer, false)? } else { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_347] = unsafe { *(result.output.as_ptr() as *const [G; OUT_347]) }; __ret } } else { aiur_fn_347(__args, record, io_buffer, __cu)? } }; + let __r_arr: [G; OUT_343] = { let __args: [G; IN_343] = [__v_1, __v_6, __v_8]; let __cu = unconstrained; if let Some(result) = record.function_queries[343].get_mut(&__args[..]) { if !__cu && *result.multiplicity == G::ZERO { aiur_fn_343(__args, record, io_buffer, false)? } else { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_343] = unsafe { *(result.output.as_ptr() as *const [G; OUT_343]) }; __ret } } else { aiur_fn_343(__args, record, io_buffer, __cu)? } }; let __v_9: G = __r_arr[0]; - let __ret: [G; OUT_348] = [__v_9]; - if let Some(result) = record.function_queries[348].get_mut(&inp[..]) { debug_assert_eq!(result.output, &__ret[..]); if !unconstrained { *result.multiplicity += G::ONE; } } else { record.function_queries[348].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained)); }; + let __ret: [G; OUT_344] = [__v_9]; + if let Some(result) = record.function_queries[344].get_mut(&inp[..]) { debug_assert_eq!(result.output, &__ret[..]); if !unconstrained { *result.multiplicity += G::ONE; } } else { record.function_queries[344].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained)); }; return Ok(__ret); }, _ => { @@ -32166,38 +31892,38 @@ fn aiur_fn_348( }) } -const INPUT_SIZE_349: usize = 5; -const IN_349: usize = 5; -const OUT_349: usize = 1; -fn aiur_fn_349( - inp: [G; IN_349], +const INPUT_SIZE_345: usize = 5; +const IN_345: usize = 5; +const OUT_345: usize = 1; +fn aiur_fn_345( + inp: [G; IN_345], record: &mut QueryRecord, io_buffer: &mut IOBuffer, unconstrained: bool, -) -> Result<[G; OUT_349], ExecError> { +) -> Result<[G; OUT_345], ExecError> { stacker::maybe_grow(64 * 1024, 4 * 1024 * 1024, || { let __v_0: G = inp[0]; let __v_1: G = inp[1]; let __v_2: G = inp[2]; let __v_3: G = inp[3]; let __v_4: G = inp[4]; - let __r_arr: [G; OUT_347] = { let __args: [G; IN_347] = [__v_0, __v_3, __v_4]; let __cu = unconstrained; if let Some(result) = record.function_queries[347].get_mut(&__args[..]) { if !__cu && *result.multiplicity == G::ZERO { aiur_fn_347(__args, record, io_buffer, false)? } else { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_347] = unsafe { *(result.output.as_ptr() as *const [G; OUT_347]) }; __ret } } else { aiur_fn_347(__args, record, io_buffer, __cu)? } }; + let __r_arr: [G; OUT_343] = { let __args: [G; IN_343] = [__v_0, __v_3, __v_4]; let __cu = unconstrained; if let Some(result) = record.function_queries[343].get_mut(&__args[..]) { if !__cu && *result.multiplicity == G::ZERO { aiur_fn_343(__args, record, io_buffer, false)? } else { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_343] = unsafe { *(result.output.as_ptr() as *const [G; OUT_343]) }; __ret } } else { aiur_fn_343(__args, record, io_buffer, __cu)? } }; let __v_5: G = __r_arr[0]; match __v_5.as_canonical_u64() { 1u64 => { let __v_6: G = G::from_u64(1); - let __ret: [G; OUT_349] = [__v_6]; - if let Some(result) = record.function_queries[349].get_mut(&inp[..]) { debug_assert_eq!(result.output, &__ret[..]); if !unconstrained { *result.multiplicity += G::ONE; } } else { record.function_queries[349].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained)); }; + let __ret: [G; OUT_345] = [__v_6]; + if let Some(result) = record.function_queries[345].get_mut(&inp[..]) { debug_assert_eq!(result.output, &__ret[..]); if !unconstrained { *result.multiplicity += G::ONE; } } else { record.function_queries[345].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained)); }; return Ok(__ret); }, 0u64 => { - let __r_arr: [G; OUT_347] = { let __args: [G; IN_347] = [__v_1, __v_3, __v_4]; let __cu = unconstrained; if let Some(result) = record.function_queries[347].get_mut(&__args[..]) { if !__cu && *result.multiplicity == G::ZERO { aiur_fn_347(__args, record, io_buffer, false)? } else { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_347] = unsafe { *(result.output.as_ptr() as *const [G; OUT_347]) }; __ret } } else { aiur_fn_347(__args, record, io_buffer, __cu)? } }; + let __r_arr: [G; OUT_343] = { let __args: [G; IN_343] = [__v_1, __v_3, __v_4]; let __cu = unconstrained; if let Some(result) = record.function_queries[343].get_mut(&__args[..]) { if !__cu && *result.multiplicity == G::ZERO { aiur_fn_343(__args, record, io_buffer, false)? } else { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_343] = unsafe { *(result.output.as_ptr() as *const [G; OUT_343]) }; __ret } } else { aiur_fn_343(__args, record, io_buffer, __cu)? } }; let __v_6: G = __r_arr[0]; match __v_6.as_canonical_u64() { 1u64 => { let __v_7: G = G::from_u64(1); - let __ret: [G; OUT_349] = [__v_7]; - if let Some(result) = record.function_queries[349].get_mut(&inp[..]) { debug_assert_eq!(result.output, &__ret[..]); if !unconstrained { *result.multiplicity += G::ONE; } } else { record.function_queries[349].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained)); }; + let __ret: [G; OUT_345] = [__v_7]; + if let Some(result) = record.function_queries[345].get_mut(&inp[..]) { debug_assert_eq!(result.output, &__ret[..]); if !unconstrained { *result.multiplicity += G::ONE; } } else { record.function_queries[345].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained)); }; return Ok(__ret); }, 0u64 => { @@ -32205,10 +31931,10 @@ fn aiur_fn_349( let __v_8: G = (__v_3 + __v_7); let __v_9: G = G::from_u64(1); let __v_10: G = (__v_4 + __v_9); - let __r_arr: [G; OUT_347] = { let __args: [G; IN_347] = [__v_2, __v_8, __v_10]; let __cu = unconstrained; if let Some(result) = record.function_queries[347].get_mut(&__args[..]) { if !__cu && *result.multiplicity == G::ZERO { aiur_fn_347(__args, record, io_buffer, false)? } else { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_347] = unsafe { *(result.output.as_ptr() as *const [G; OUT_347]) }; __ret } } else { aiur_fn_347(__args, record, io_buffer, __cu)? } }; + let __r_arr: [G; OUT_343] = { let __args: [G; IN_343] = [__v_2, __v_8, __v_10]; let __cu = unconstrained; if let Some(result) = record.function_queries[343].get_mut(&__args[..]) { if !__cu && *result.multiplicity == G::ZERO { aiur_fn_343(__args, record, io_buffer, false)? } else { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_343] = unsafe { *(result.output.as_ptr() as *const [G; OUT_343]) }; __ret } } else { aiur_fn_343(__args, record, io_buffer, __cu)? } }; let __v_11: G = __r_arr[0]; - let __ret: [G; OUT_349] = [__v_11]; - if let Some(result) = record.function_queries[349].get_mut(&inp[..]) { debug_assert_eq!(result.output, &__ret[..]); if !unconstrained { *result.multiplicity += G::ONE; } } else { record.function_queries[349].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained)); }; + let __ret: [G; OUT_345] = [__v_11]; + if let Some(result) = record.function_queries[345].get_mut(&inp[..]) { debug_assert_eq!(result.output, &__ret[..]); if !unconstrained { *result.multiplicity += G::ONE; } } else { record.function_queries[345].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained)); }; return Ok(__ret); }, _ => { @@ -32223,60 +31949,60 @@ fn aiur_fn_349( }) } -const INPUT_SIZE_350: usize = 2; -const IN_350: usize = 2; -const OUT_350: usize = 1; -fn aiur_fn_350( - inp: [G; IN_350], +const INPUT_SIZE_346: usize = 2; +const IN_346: usize = 2; +const OUT_346: usize = 1; +fn aiur_fn_346( + inp: [G; IN_346], record: &mut QueryRecord, io_buffer: &mut IOBuffer, unconstrained: bool, -) -> Result<[G; OUT_350], ExecError> { +) -> Result<[G; OUT_346], ExecError> { stacker::maybe_grow(64 * 1024, 4 * 1024 * 1024, || { let __v_0: G = inp[0]; let __v_1: G = inp[1]; - let __r_arr: [G; OUT_764] = { let __args: [G; IN_764] = [__v_0]; let __cu = unconstrained; if let Some(result) = record.function_queries[764].get_mut(&__args[..]) { if !__cu && *result.multiplicity == G::ZERO { aiur_fn_764(__args, record, io_buffer, false)? } else { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_764] = unsafe { *(result.output.as_ptr() as *const [G; OUT_764]) }; __ret } } else { aiur_fn_764(__args, record, io_buffer, __cu)? } }; + let __r_arr: [G; OUT_760] = { let __args: [G; IN_760] = [__v_0]; let __cu = unconstrained; if let Some(result) = record.function_queries[760].get_mut(&__args[..]) { if !__cu && *result.multiplicity == G::ZERO { aiur_fn_760(__args, record, io_buffer, false)? } else { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_760] = unsafe { *(result.output.as_ptr() as *const [G; OUT_760]) }; __ret } } else { aiur_fn_760(__args, record, io_buffer, __cu)? } }; let __v_2: G = __r_arr[0]; - let __r_arr: [G; OUT_345] = { let __args: [G; IN_345] = [__v_1, __v_2]; let __cu = unconstrained; if let Some(result) = record.function_queries[345].get_mut(&__args[..]) { if !__cu && *result.multiplicity == G::ZERO { aiur_fn_345(__args, record, io_buffer, false)? } else { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_345] = unsafe { *(result.output.as_ptr() as *const [G; OUT_345]) }; __ret } } else { aiur_fn_345(__args, record, io_buffer, __cu)? } }; + let __r_arr: [G; OUT_341] = { let __args: [G; IN_341] = [__v_1, __v_2]; let __cu = unconstrained; if let Some(result) = record.function_queries[341].get_mut(&__args[..]) { if !__cu && *result.multiplicity == G::ZERO { aiur_fn_341(__args, record, io_buffer, false)? } else { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_341] = unsafe { *(result.output.as_ptr() as *const [G; OUT_341]) }; __ret } } else { aiur_fn_341(__args, record, io_buffer, __cu)? } }; let __v_3: G = __r_arr[0]; - let __r_arr: [G; OUT_351] = { let __args: [G; IN_351] = [__v_0, __v_3]; let __cu = unconstrained; if let Some(result) = record.function_queries[351].get_mut(&__args[..]) { if !__cu && *result.multiplicity == G::ZERO { aiur_fn_351(__args, record, io_buffer, false)? } else { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_351] = unsafe { *(result.output.as_ptr() as *const [G; OUT_351]) }; __ret } } else { aiur_fn_351(__args, record, io_buffer, __cu)? } }; + let __r_arr: [G; OUT_347] = { let __args: [G; IN_347] = [__v_0, __v_3]; let __cu = unconstrained; if let Some(result) = record.function_queries[347].get_mut(&__args[..]) { if !__cu && *result.multiplicity == G::ZERO { aiur_fn_347(__args, record, io_buffer, false)? } else { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_347] = unsafe { *(result.output.as_ptr() as *const [G; OUT_347]) }; __ret } } else { aiur_fn_347(__args, record, io_buffer, __cu)? } }; let __v_4: G = __r_arr[0]; - let __ret: [G; OUT_350] = [__v_4]; - if let Some(result) = record.function_queries[350].get_mut(&inp[..]) { debug_assert_eq!(result.output, &__ret[..]); if !unconstrained { *result.multiplicity += G::ONE; } } else { record.function_queries[350].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained)); }; + let __ret: [G; OUT_346] = [__v_4]; + if let Some(result) = record.function_queries[346].get_mut(&inp[..]) { debug_assert_eq!(result.output, &__ret[..]); if !unconstrained { *result.multiplicity += G::ONE; } } else { record.function_queries[346].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained)); }; return Ok(__ret); }) } -const INPUT_SIZE_351: usize = 2; -const IN_351: usize = 2; -const OUT_351: usize = 1; -fn aiur_fn_351( - inp: [G; IN_351], +const INPUT_SIZE_347: usize = 2; +const IN_347: usize = 2; +const OUT_347: usize = 1; +fn aiur_fn_347( + inp: [G; IN_347], record: &mut QueryRecord, io_buffer: &mut IOBuffer, unconstrained: bool, -) -> Result<[G; OUT_351], ExecError> { +) -> Result<[G; OUT_347], ExecError> { stacker::maybe_grow(64 * 1024, 4 * 1024 * 1024, || { let __v_0: G = inp[0]; let __v_1: G = inp[1]; - let __r_arr: [G; OUT_352] = { let __args: [G; IN_352] = [__v_0]; let __cu = unconstrained; if let Some(result) = record.function_queries[352].get_mut(&__args[..]) { if !__cu && *result.multiplicity == G::ZERO { aiur_fn_352(__args, record, io_buffer, false)? } else { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_352] = unsafe { *(result.output.as_ptr() as *const [G; OUT_352]) }; __ret } } else { aiur_fn_352(__args, record, io_buffer, __cu)? } }; + let __r_arr: [G; OUT_348] = { let __args: [G; IN_348] = [__v_0]; let __cu = unconstrained; if let Some(result) = record.function_queries[348].get_mut(&__args[..]) { if !__cu && *result.multiplicity == G::ZERO { aiur_fn_348(__args, record, io_buffer, false)? } else { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_348] = unsafe { *(result.output.as_ptr() as *const [G; OUT_348]) }; __ret } } else { aiur_fn_348(__args, record, io_buffer, __cu)? } }; let __v_2: G = __r_arr[0]; let __v_3: G = { let __a_val = __v_2.as_canonical_u64(); let __b_val = __v_1.as_canonical_u64(); let __a_u32 = u32::try_from(__a_val).ok().ok_or(ExecError::U32OutOfRange(__a_val))?; let __b_u32 = u32::try_from(__b_val).ok().ok_or(ExecError::U32OutOfRange(__b_val))?; let __result = G::from_bool(__a_u32 < __b_u32); if !unconstrained { let __x_bytes = __a_u32.to_le_bytes(); let __z_bytes = __b_u32.to_le_bytes(); let __c_u32 = __b_u32.wrapping_sub(__a_u32).wrapping_sub(1); let __y_bytes = __c_u32.to_le_bytes(); record.bytes2_queries.bump_range_check(&G::from_u8(__x_bytes[0]), &G::from_u8(__x_bytes[1])); record.bytes2_queries.bump_range_check(&G::from_u8(__x_bytes[2]), &G::from_u8(__x_bytes[3])); record.bytes2_queries.bump_range_check(&G::from_u8(__y_bytes[0]), &G::from_u8(__y_bytes[1])); record.bytes2_queries.bump_range_check(&G::from_u8(__y_bytes[2]), &G::from_u8(__y_bytes[3])); record.bytes2_queries.bump_range_check(&G::from_u8(__z_bytes[0]), &G::from_u8(__z_bytes[1])); record.bytes2_queries.bump_range_check(&G::from_u8(__z_bytes[2]), &G::from_u8(__z_bytes[3])); } __result }; match __v_3.as_canonical_u64() { 0u64 => { - let __ret: [G; OUT_351] = [__v_2]; - if let Some(result) = record.function_queries[351].get_mut(&inp[..]) { debug_assert_eq!(result.output, &__ret[..]); if !unconstrained { *result.multiplicity += G::ONE; } } else { record.function_queries[351].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained)); }; + let __ret: [G; OUT_347] = [__v_2]; + if let Some(result) = record.function_queries[347].get_mut(&inp[..]) { debug_assert_eq!(result.output, &__ret[..]); if !unconstrained { *result.multiplicity += G::ONE; } } else { record.function_queries[347].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained)); }; return Ok(__ret); }, 1u64 => { - let __r_arr: [G; OUT_775] = { let __args: [G; IN_775] = [__v_0, __v_2]; let __cu = unconstrained; if let Some(result) = record.function_queries[775].get_mut(&__args[..]) { if !__cu && *result.multiplicity == G::ZERO { aiur_fn_775(__args, record, io_buffer, false)? } else { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_775] = unsafe { *(result.output.as_ptr() as *const [G; OUT_775]) }; __ret } } else { aiur_fn_775(__args, record, io_buffer, __cu)? } }; + let __r_arr: [G; OUT_771] = { let __args: [G; IN_771] = [__v_0, __v_2]; let __cu = unconstrained; if let Some(result) = record.function_queries[771].get_mut(&__args[..]) { if !__cu && *result.multiplicity == G::ZERO { aiur_fn_771(__args, record, io_buffer, false)? } else { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_771] = unsafe { *(result.output.as_ptr() as *const [G; OUT_771]) }; __ret } } else { aiur_fn_771(__args, record, io_buffer, __cu)? } }; let __v_4: G = __r_arr[0]; let __v_5: G = (__v_1 - __v_2); - let __r_arr: [G; OUT_351] = { let __args: [G; IN_351] = [__v_4, __v_5]; let __cu = unconstrained; if let Some(result) = record.function_queries[351].get_mut(&__args[..]) { if !__cu && *result.multiplicity == G::ZERO { aiur_fn_351(__args, record, io_buffer, false)? } else { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_351] = unsafe { *(result.output.as_ptr() as *const [G; OUT_351]) }; __ret } } else { aiur_fn_351(__args, record, io_buffer, __cu)? } }; + let __r_arr: [G; OUT_347] = { let __args: [G; IN_347] = [__v_4, __v_5]; let __cu = unconstrained; if let Some(result) = record.function_queries[347].get_mut(&__args[..]) { if !__cu && *result.multiplicity == G::ZERO { aiur_fn_347(__args, record, io_buffer, false)? } else { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_347] = unsafe { *(result.output.as_ptr() as *const [G; OUT_347]) }; __ret } } else { aiur_fn_347(__args, record, io_buffer, __cu)? } }; let __v_6: G = __r_arr[0]; let __v_7: G = (__v_2 + __v_6); - let __ret: [G; OUT_351] = [__v_7]; - if let Some(result) = record.function_queries[351].get_mut(&inp[..]) { debug_assert_eq!(result.output, &__ret[..]); if !unconstrained { *result.multiplicity += G::ONE; } } else { record.function_queries[351].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained)); }; + let __ret: [G; OUT_347] = [__v_7]; + if let Some(result) = record.function_queries[347].get_mut(&inp[..]) { debug_assert_eq!(result.output, &__ret[..]); if !unconstrained { *result.multiplicity += G::ONE; } } else { record.function_queries[347].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained)); }; return Ok(__ret); }, _ => { @@ -32286,15 +32012,15 @@ fn aiur_fn_351( }) } -const INPUT_SIZE_352: usize = 1; -const IN_352: usize = 1; -const OUT_352: usize = 1; -fn aiur_fn_352( - inp: [G; IN_352], +const INPUT_SIZE_348: usize = 1; +const IN_348: usize = 1; +const OUT_348: usize = 1; +fn aiur_fn_348( + inp: [G; IN_348], record: &mut QueryRecord, io_buffer: &mut IOBuffer, unconstrained: bool, -) -> Result<[G; OUT_352], ExecError> { +) -> Result<[G; OUT_348], ExecError> { stacker::maybe_grow(64 * 1024, 4 * 1024 * 1024, || { let __v_0: G = inp[0]; let __loaded: [G; 3] = { let __mq = record.memory_queries.get_mut(&3).ok_or(ExecError::InvalidMemorySize(3))?; let __ptr_u64 = __v_0.as_canonical_u64(); let __ptr_usize = usize::try_from(__ptr_u64).ok().ok_or(ExecError::PointerTooLarge(__ptr_u64))?; let (__args, __mult) = __mq.get_index_mut(__ptr_usize).ok_or(ExecError::UnboundPointer { ptr: __ptr_u64, size: 3 })?; if !unconstrained { *__mult += G::ONE; } let __arr: [G; 3] = __args[..3].try_into().unwrap(); __arr }; @@ -32304,13 +32030,13 @@ fn aiur_fn_352( match __v_1.as_canonical_u64() { 0u64 => { let __v_4: G = G::from_u64(1); - let __r_arr: [G; OUT_341] = { let __args: [G; IN_341] = [__v_2]; let __cu = unconstrained; if let Some(result) = record.function_queries[341].get_mut(&__args[..]) { if !__cu && *result.multiplicity == G::ZERO { aiur_fn_341(__args, record, io_buffer, false)? } else { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_341] = unsafe { *(result.output.as_ptr() as *const [G; OUT_341]) }; __ret } } else { aiur_fn_341(__args, record, io_buffer, __cu)? } }; + let __r_arr: [G; OUT_337] = { let __args: [G; IN_337] = [__v_2]; let __cu = unconstrained; if let Some(result) = record.function_queries[337].get_mut(&__args[..]) { if !__cu && *result.multiplicity == G::ZERO { aiur_fn_337(__args, record, io_buffer, false)? } else { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_337] = unsafe { *(result.output.as_ptr() as *const [G; OUT_337]) }; __ret } } else { aiur_fn_337(__args, record, io_buffer, __cu)? } }; let __v_5: G = __r_arr[0]; - let __r_arr: [G; OUT_353] = { let __args: [G; IN_353] = [__v_3, __v_5]; let __cu = unconstrained; if let Some(result) = record.function_queries[353].get_mut(&__args[..]) { if !__cu && *result.multiplicity == G::ZERO { aiur_fn_353(__args, record, io_buffer, false)? } else { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_353] = unsafe { *(result.output.as_ptr() as *const [G; OUT_353]) }; __ret } } else { aiur_fn_353(__args, record, io_buffer, __cu)? } }; + let __r_arr: [G; OUT_349] = { let __args: [G; IN_349] = [__v_3, __v_5]; let __cu = unconstrained; if let Some(result) = record.function_queries[349].get_mut(&__args[..]) { if !__cu && *result.multiplicity == G::ZERO { aiur_fn_349(__args, record, io_buffer, false)? } else { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_349] = unsafe { *(result.output.as_ptr() as *const [G; OUT_349]) }; __ret } } else { aiur_fn_349(__args, record, io_buffer, __cu)? } }; let __v_6: G = __r_arr[0]; let __v_7: G = (__v_4 + __v_6); - let __ret: [G; OUT_352] = [__v_7]; - if let Some(result) = record.function_queries[352].get_mut(&inp[..]) { debug_assert_eq!(result.output, &__ret[..]); if !unconstrained { *result.multiplicity += G::ONE; } } else { record.function_queries[352].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained)); }; + let __ret: [G; OUT_348] = [__v_7]; + if let Some(result) = record.function_queries[348].get_mut(&inp[..]) { debug_assert_eq!(result.output, &__ret[..]); if !unconstrained { *result.multiplicity += G::ONE; } } else { record.function_queries[348].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained)); }; return Ok(__ret); }, _ => { @@ -32320,44 +32046,44 @@ fn aiur_fn_352( }) } -const INPUT_SIZE_353: usize = 2; -const IN_353: usize = 2; -const OUT_353: usize = 1; -fn aiur_fn_353( - inp: [G; IN_353], +const INPUT_SIZE_349: usize = 2; +const IN_349: usize = 2; +const OUT_349: usize = 1; +fn aiur_fn_349( + inp: [G; IN_349], record: &mut QueryRecord, io_buffer: &mut IOBuffer, unconstrained: bool, -) -> Result<[G; OUT_353], ExecError> { +) -> Result<[G; OUT_349], ExecError> { stacker::maybe_grow(64 * 1024, 4 * 1024 * 1024, || { let __v_0: G = inp[0]; let __v_1: G = inp[1]; match __v_1.as_canonical_u64() { 0u64 => { let __v_2: G = G::from_u64(0); - let __ret: [G; OUT_353] = [__v_2]; - if let Some(result) = record.function_queries[353].get_mut(&inp[..]) { debug_assert_eq!(result.output, &__ret[..]); if !unconstrained { *result.multiplicity += G::ONE; } } else { record.function_queries[353].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained)); }; + let __ret: [G; OUT_349] = [__v_2]; + if let Some(result) = record.function_queries[349].get_mut(&inp[..]) { debug_assert_eq!(result.output, &__ret[..]); if !unconstrained { *result.multiplicity += G::ONE; } } else { record.function_queries[349].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained)); }; return Ok(__ret); }, _ => { - let __r_arr: [G; OUT_352] = { let __args: [G; IN_352] = [__v_0]; let __cu = unconstrained; if let Some(result) = record.function_queries[352].get_mut(&__args[..]) { if !__cu && *result.multiplicity == G::ZERO { aiur_fn_352(__args, record, io_buffer, false)? } else { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_352] = unsafe { *(result.output.as_ptr() as *const [G; OUT_352]) }; __ret } } else { aiur_fn_352(__args, record, io_buffer, __cu)? } }; + let __r_arr: [G; OUT_348] = { let __args: [G; IN_348] = [__v_0]; let __cu = unconstrained; if let Some(result) = record.function_queries[348].get_mut(&__args[..]) { if !__cu && *result.multiplicity == G::ZERO { aiur_fn_348(__args, record, io_buffer, false)? } else { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_348] = unsafe { *(result.output.as_ptr() as *const [G; OUT_348]) }; __ret } } else { aiur_fn_348(__args, record, io_buffer, __cu)? } }; let __v_2: G = __r_arr[0]; let __v_3: G = { let __a_val = __v_2.as_canonical_u64(); let __b_val = __v_1.as_canonical_u64(); let __a_u32 = u32::try_from(__a_val).ok().ok_or(ExecError::U32OutOfRange(__a_val))?; let __b_u32 = u32::try_from(__b_val).ok().ok_or(ExecError::U32OutOfRange(__b_val))?; let __result = G::from_bool(__a_u32 < __b_u32); if !unconstrained { let __x_bytes = __a_u32.to_le_bytes(); let __z_bytes = __b_u32.to_le_bytes(); let __c_u32 = __b_u32.wrapping_sub(__a_u32).wrapping_sub(1); let __y_bytes = __c_u32.to_le_bytes(); record.bytes2_queries.bump_range_check(&G::from_u8(__x_bytes[0]), &G::from_u8(__x_bytes[1])); record.bytes2_queries.bump_range_check(&G::from_u8(__x_bytes[2]), &G::from_u8(__x_bytes[3])); record.bytes2_queries.bump_range_check(&G::from_u8(__y_bytes[0]), &G::from_u8(__y_bytes[1])); record.bytes2_queries.bump_range_check(&G::from_u8(__y_bytes[2]), &G::from_u8(__y_bytes[3])); record.bytes2_queries.bump_range_check(&G::from_u8(__z_bytes[0]), &G::from_u8(__z_bytes[1])); record.bytes2_queries.bump_range_check(&G::from_u8(__z_bytes[2]), &G::from_u8(__z_bytes[3])); } __result }; match __v_3.as_canonical_u64() { 0u64 => { - let __ret: [G; OUT_353] = [__v_2]; - if let Some(result) = record.function_queries[353].get_mut(&inp[..]) { debug_assert_eq!(result.output, &__ret[..]); if !unconstrained { *result.multiplicity += G::ONE; } } else { record.function_queries[353].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained)); }; + let __ret: [G; OUT_349] = [__v_2]; + if let Some(result) = record.function_queries[349].get_mut(&inp[..]) { debug_assert_eq!(result.output, &__ret[..]); if !unconstrained { *result.multiplicity += G::ONE; } } else { record.function_queries[349].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained)); }; return Ok(__ret); }, 1u64 => { - let __r_arr: [G; OUT_775] = { let __args: [G; IN_775] = [__v_0, __v_2]; let __cu = unconstrained; if let Some(result) = record.function_queries[775].get_mut(&__args[..]) { if !__cu && *result.multiplicity == G::ZERO { aiur_fn_775(__args, record, io_buffer, false)? } else { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_775] = unsafe { *(result.output.as_ptr() as *const [G; OUT_775]) }; __ret } } else { aiur_fn_775(__args, record, io_buffer, __cu)? } }; + let __r_arr: [G; OUT_771] = { let __args: [G; IN_771] = [__v_0, __v_2]; let __cu = unconstrained; if let Some(result) = record.function_queries[771].get_mut(&__args[..]) { if !__cu && *result.multiplicity == G::ZERO { aiur_fn_771(__args, record, io_buffer, false)? } else { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_771] = unsafe { *(result.output.as_ptr() as *const [G; OUT_771]) }; __ret } } else { aiur_fn_771(__args, record, io_buffer, __cu)? } }; let __v_4: G = __r_arr[0]; let __v_5: G = (__v_1 - __v_2); - let __r_arr: [G; OUT_353] = { let __args: [G; IN_353] = [__v_4, __v_5]; let __cu = unconstrained; if let Some(result) = record.function_queries[353].get_mut(&__args[..]) { if !__cu && *result.multiplicity == G::ZERO { aiur_fn_353(__args, record, io_buffer, false)? } else { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_353] = unsafe { *(result.output.as_ptr() as *const [G; OUT_353]) }; __ret } } else { aiur_fn_353(__args, record, io_buffer, __cu)? } }; + let __r_arr: [G; OUT_349] = { let __args: [G; IN_349] = [__v_4, __v_5]; let __cu = unconstrained; if let Some(result) = record.function_queries[349].get_mut(&__args[..]) { if !__cu && *result.multiplicity == G::ZERO { aiur_fn_349(__args, record, io_buffer, false)? } else { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_349] = unsafe { *(result.output.as_ptr() as *const [G; OUT_349]) }; __ret } } else { aiur_fn_349(__args, record, io_buffer, __cu)? } }; let __v_6: G = __r_arr[0]; let __v_7: G = (__v_2 + __v_6); - let __ret: [G; OUT_353] = [__v_7]; - if let Some(result) = record.function_queries[353].get_mut(&inp[..]) { debug_assert_eq!(result.output, &__ret[..]); if !unconstrained { *result.multiplicity += G::ONE; } } else { record.function_queries[353].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained)); }; + let __ret: [G; OUT_349] = [__v_7]; + if let Some(result) = record.function_queries[349].get_mut(&inp[..]) { debug_assert_eq!(result.output, &__ret[..]); if !unconstrained { *result.multiplicity += G::ONE; } } else { record.function_queries[349].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained)); }; return Ok(__ret); }, _ => { @@ -32369,15 +32095,15 @@ fn aiur_fn_353( }) } -const INPUT_SIZE_354: usize = 2; -const IN_354: usize = 2; -const OUT_354: usize = 1; -fn aiur_fn_354( - inp: [G; IN_354], +const INPUT_SIZE_350: usize = 2; +const IN_350: usize = 2; +const OUT_350: usize = 1; +fn aiur_fn_350( + inp: [G; IN_350], record: &mut QueryRecord, io_buffer: &mut IOBuffer, unconstrained: bool, -) -> Result<[G; OUT_354], ExecError> { +) -> Result<[G; OUT_350], ExecError> { stacker::maybe_grow(64 * 1024, 4 * 1024 * 1024, || { let __v_0: G = inp[0]; let __v_1: G = inp[1]; @@ -32386,31 +32112,31 @@ fn aiur_fn_354( let __v_2: G = G::from_u64(1); let __v_3: G = G::from_u64(1); let __v_4: G = { let __values: [G; 3] = [__v_2, __v_3, __v_3]; let __mq = record.memory_queries.get_mut(&3).ok_or(ExecError::InvalidMemorySize(3))?; if let Some(result) = __mq.get_mut(&__values[..]) { if !unconstrained { *result.multiplicity += G::ONE; } result.output[0] } else { let __ptr = G::from_usize(__mq.len()); __mq.insert(&__values[..], &[__ptr], G::from_bool(!unconstrained)); __ptr } }; - let __ret: [G; OUT_354] = [__v_4]; - if let Some(result) = record.function_queries[354].get_mut(&inp[..]) { debug_assert_eq!(result.output, &__ret[..]); if !unconstrained { *result.multiplicity += G::ONE; } } else { record.function_queries[354].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained)); }; + let __ret: [G; OUT_350] = [__v_4]; + if let Some(result) = record.function_queries[350].get_mut(&inp[..]) { debug_assert_eq!(result.output, &__ret[..]); if !unconstrained { *result.multiplicity += G::ONE; } } else { record.function_queries[350].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained)); }; return Ok(__ret); }, _ => { - let __r_arr: [G; OUT_764] = { let __args: [G; IN_764] = [__v_0]; let __cu = unconstrained; if let Some(result) = record.function_queries[764].get_mut(&__args[..]) { if !__cu && *result.multiplicity == G::ZERO { aiur_fn_764(__args, record, io_buffer, false)? } else { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_764] = unsafe { *(result.output.as_ptr() as *const [G; OUT_764]) }; __ret } } else { aiur_fn_764(__args, record, io_buffer, __cu)? } }; + let __r_arr: [G; OUT_760] = { let __args: [G; IN_760] = [__v_0]; let __cu = unconstrained; if let Some(result) = record.function_queries[760].get_mut(&__args[..]) { if !__cu && *result.multiplicity == G::ZERO { aiur_fn_760(__args, record, io_buffer, false)? } else { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_760] = unsafe { *(result.output.as_ptr() as *const [G; OUT_760]) }; __ret } } else { aiur_fn_760(__args, record, io_buffer, __cu)? } }; let __v_2: G = __r_arr[0]; let __v_3: G = { let __a_val = __v_1.as_canonical_u64(); let __b_val = __v_2.as_canonical_u64(); let __a_u32 = u32::try_from(__a_val).ok().ok_or(ExecError::U32OutOfRange(__a_val))?; let __b_u32 = u32::try_from(__b_val).ok().ok_or(ExecError::U32OutOfRange(__b_val))?; let __result = G::from_bool(__a_u32 < __b_u32); if !unconstrained { let __x_bytes = __a_u32.to_le_bytes(); let __z_bytes = __b_u32.to_le_bytes(); let __c_u32 = __b_u32.wrapping_sub(__a_u32).wrapping_sub(1); let __y_bytes = __c_u32.to_le_bytes(); record.bytes2_queries.bump_range_check(&G::from_u8(__x_bytes[0]), &G::from_u8(__x_bytes[1])); record.bytes2_queries.bump_range_check(&G::from_u8(__x_bytes[2]), &G::from_u8(__x_bytes[3])); record.bytes2_queries.bump_range_check(&G::from_u8(__y_bytes[0]), &G::from_u8(__y_bytes[1])); record.bytes2_queries.bump_range_check(&G::from_u8(__y_bytes[2]), &G::from_u8(__y_bytes[3])); record.bytes2_queries.bump_range_check(&G::from_u8(__z_bytes[0]), &G::from_u8(__z_bytes[1])); record.bytes2_queries.bump_range_check(&G::from_u8(__z_bytes[2]), &G::from_u8(__z_bytes[3])); } __result }; match __v_3.as_canonical_u64() { 0u64 => { - let __ret: [G; OUT_354] = [__v_0]; - if let Some(result) = record.function_queries[354].get_mut(&inp[..]) { debug_assert_eq!(result.output, &__ret[..]); if !unconstrained { *result.multiplicity += G::ONE; } } else { record.function_queries[354].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained)); }; + let __ret: [G; OUT_350] = [__v_0]; + if let Some(result) = record.function_queries[350].get_mut(&inp[..]) { debug_assert_eq!(result.output, &__ret[..]); if !unconstrained { *result.multiplicity += G::ONE; } } else { record.function_queries[350].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained)); }; return Ok(__ret); }, 1u64 => { - let __r_arr: [G; OUT_764] = { let __args: [G; IN_764] = [__v_0]; let __cu = unconstrained; if let Some(result) = record.function_queries[764].get_mut(&__args[..]) { if !__cu && *result.multiplicity == G::ZERO { aiur_fn_764(__args, record, io_buffer, false)? } else { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_764] = unsafe { *(result.output.as_ptr() as *const [G; OUT_764]) }; __ret } } else { aiur_fn_764(__args, record, io_buffer, __cu)? } }; + let __r_arr: [G; OUT_760] = { let __args: [G; IN_760] = [__v_0]; let __cu = unconstrained; if let Some(result) = record.function_queries[760].get_mut(&__args[..]) { if !__cu && *result.multiplicity == G::ZERO { aiur_fn_760(__args, record, io_buffer, false)? } else { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_760] = unsafe { *(result.output.as_ptr() as *const [G; OUT_760]) }; __ret } } else { aiur_fn_760(__args, record, io_buffer, __cu)? } }; let __v_4: G = __r_arr[0]; - let __r_arr: [G; OUT_345] = { let __args: [G; IN_345] = [__v_1, __v_4]; let __cu = unconstrained; if let Some(result) = record.function_queries[345].get_mut(&__args[..]) { if !__cu && *result.multiplicity == G::ZERO { aiur_fn_345(__args, record, io_buffer, false)? } else { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_345] = unsafe { *(result.output.as_ptr() as *const [G; OUT_345]) }; __ret } } else { aiur_fn_345(__args, record, io_buffer, __cu)? } }; + let __r_arr: [G; OUT_341] = { let __args: [G; IN_341] = [__v_1, __v_4]; let __cu = unconstrained; if let Some(result) = record.function_queries[341].get_mut(&__args[..]) { if !__cu && *result.multiplicity == G::ZERO { aiur_fn_341(__args, record, io_buffer, false)? } else { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_341] = unsafe { *(result.output.as_ptr() as *const [G; OUT_341]) }; __ret } } else { aiur_fn_341(__args, record, io_buffer, __cu)? } }; let __v_5: G = __r_arr[0]; - let __r_arr: [G; OUT_351] = { let __args: [G; IN_351] = [__v_0, __v_5]; let __cu = unconstrained; if let Some(result) = record.function_queries[351].get_mut(&__args[..]) { if !__cu && *result.multiplicity == G::ZERO { aiur_fn_351(__args, record, io_buffer, false)? } else { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_351] = unsafe { *(result.output.as_ptr() as *const [G; OUT_351]) }; __ret } } else { aiur_fn_351(__args, record, io_buffer, __cu)? } }; + let __r_arr: [G; OUT_347] = { let __args: [G; IN_347] = [__v_0, __v_5]; let __cu = unconstrained; if let Some(result) = record.function_queries[347].get_mut(&__args[..]) { if !__cu && *result.multiplicity == G::ZERO { aiur_fn_347(__args, record, io_buffer, false)? } else { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_347] = unsafe { *(result.output.as_ptr() as *const [G; OUT_347]) }; __ret } } else { aiur_fn_347(__args, record, io_buffer, __cu)? } }; let __v_6: G = __r_arr[0]; - let __r_arr: [G; OUT_774] = { let __args: [G; IN_774] = [__v_0, __v_6]; let __cu = unconstrained; if let Some(result) = record.function_queries[774].get_mut(&__args[..]) { if !__cu && *result.multiplicity == G::ZERO { aiur_fn_774(__args, record, io_buffer, false)? } else { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_774] = unsafe { *(result.output.as_ptr() as *const [G; OUT_774]) }; __ret } } else { aiur_fn_774(__args, record, io_buffer, __cu)? } }; + let __r_arr: [G; OUT_770] = { let __args: [G; IN_770] = [__v_0, __v_6]; let __cu = unconstrained; if let Some(result) = record.function_queries[770].get_mut(&__args[..]) { if !__cu && *result.multiplicity == G::ZERO { aiur_fn_770(__args, record, io_buffer, false)? } else { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_770] = unsafe { *(result.output.as_ptr() as *const [G; OUT_770]) }; __ret } } else { aiur_fn_770(__args, record, io_buffer, __cu)? } }; let __v_7: G = __r_arr[0]; - let __ret: [G; OUT_354] = [__v_7]; - if let Some(result) = record.function_queries[354].get_mut(&inp[..]) { debug_assert_eq!(result.output, &__ret[..]); if !unconstrained { *result.multiplicity += G::ONE; } } else { record.function_queries[354].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained)); }; + let __ret: [G; OUT_350] = [__v_7]; + if let Some(result) = record.function_queries[350].get_mut(&inp[..]) { debug_assert_eq!(result.output, &__ret[..]); if !unconstrained { *result.multiplicity += G::ONE; } } else { record.function_queries[350].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained)); }; return Ok(__ret); }, _ => { @@ -32422,51 +32148,51 @@ fn aiur_fn_354( }) } -const INPUT_SIZE_355: usize = 2; -const IN_355: usize = 2; -const OUT_355: usize = 1; -fn aiur_fn_355( - inp: [G; IN_355], +const INPUT_SIZE_351: usize = 2; +const IN_351: usize = 2; +const OUT_351: usize = 1; +fn aiur_fn_351( + inp: [G; IN_351], record: &mut QueryRecord, io_buffer: &mut IOBuffer, unconstrained: bool, -) -> Result<[G; OUT_355], ExecError> { +) -> Result<[G; OUT_351], ExecError> { stacker::maybe_grow(64 * 1024, 4 * 1024 * 1024, || { let __v_0: G = inp[0]; let __v_1: G = inp[1]; - let __r_arr: [G; OUT_341] = { let __args: [G; IN_341] = [__v_0]; let __cu = unconstrained; if let Some(result) = record.function_queries[341].get_mut(&__args[..]) { if !__cu && *result.multiplicity == G::ZERO { aiur_fn_341(__args, record, io_buffer, false)? } else { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_341] = unsafe { *(result.output.as_ptr() as *const [G; OUT_341]) }; __ret } } else { aiur_fn_341(__args, record, io_buffer, __cu)? } }; + let __r_arr: [G; OUT_337] = { let __args: [G; IN_337] = [__v_0]; let __cu = unconstrained; if let Some(result) = record.function_queries[337].get_mut(&__args[..]) { if !__cu && *result.multiplicity == G::ZERO { aiur_fn_337(__args, record, io_buffer, false)? } else { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_337] = unsafe { *(result.output.as_ptr() as *const [G; OUT_337]) }; __ret } } else { aiur_fn_337(__args, record, io_buffer, __cu)? } }; let __v_2: G = __r_arr[0]; let __v_3: G = G::from_u64(1); let __v_4: G = (__v_1 + __v_3); - let __r_arr: [G; OUT_346] = { let __args: [G; IN_346] = [__v_2, __v_4]; let __cu = unconstrained; if let Some(result) = record.function_queries[346].get_mut(&__args[..]) { if !__cu && *result.multiplicity == G::ZERO { aiur_fn_346(__args, record, io_buffer, false)? } else { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_346] = unsafe { *(result.output.as_ptr() as *const [G; OUT_346]) }; __ret } } else { aiur_fn_346(__args, record, io_buffer, __cu)? } }; + let __r_arr: [G; OUT_342] = { let __args: [G; IN_342] = [__v_2, __v_4]; let __cu = unconstrained; if let Some(result) = record.function_queries[342].get_mut(&__args[..]) { if !__cu && *result.multiplicity == G::ZERO { aiur_fn_342(__args, record, io_buffer, false)? } else { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_342] = unsafe { *(result.output.as_ptr() as *const [G; OUT_342]) }; __ret } } else { aiur_fn_342(__args, record, io_buffer, __cu)? } }; let __v_5: G = __r_arr[0]; match __v_5.as_canonical_u64() { 1u64 => { let __v_6: G = G::from_u64(4294967295); - let __ret: [G; OUT_355] = [__v_6]; - if let Some(result) = record.function_queries[355].get_mut(&inp[..]) { debug_assert_eq!(result.output, &__ret[..]); if !unconstrained { *result.multiplicity += G::ONE; } } else { record.function_queries[355].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained)); }; + let __ret: [G; OUT_351] = [__v_6]; + if let Some(result) = record.function_queries[351].get_mut(&inp[..]) { debug_assert_eq!(result.output, &__ret[..]); if !unconstrained { *result.multiplicity += G::ONE; } } else { record.function_queries[351].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained)); }; return Ok(__ret); }, _ => { - let __r_arr: [G; OUT_356] = { let __args: [G; IN_356] = [__v_0, __v_1]; let __cu = unconstrained; if let Some(result) = record.function_queries[356].get_mut(&__args[..]) { if !__cu && *result.multiplicity == G::ZERO { aiur_fn_356(__args, record, io_buffer, false)? } else { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_356] = unsafe { *(result.output.as_ptr() as *const [G; OUT_356]) }; __ret } } else { aiur_fn_356(__args, record, io_buffer, __cu)? } }; + let __r_arr: [G; OUT_352] = { let __args: [G; IN_352] = [__v_0, __v_1]; let __cu = unconstrained; if let Some(result) = record.function_queries[352].get_mut(&__args[..]) { if !__cu && *result.multiplicity == G::ZERO { aiur_fn_352(__args, record, io_buffer, false)? } else { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_352] = unsafe { *(result.output.as_ptr() as *const [G; OUT_352]) }; __ret } } else { aiur_fn_352(__args, record, io_buffer, __cu)? } }; let __v_6: G = __r_arr[0]; - let __ret: [G; OUT_355] = [__v_6]; - if let Some(result) = record.function_queries[355].get_mut(&inp[..]) { debug_assert_eq!(result.output, &__ret[..]); if !unconstrained { *result.multiplicity += G::ONE; } } else { record.function_queries[355].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained)); }; + let __ret: [G; OUT_351] = [__v_6]; + if let Some(result) = record.function_queries[351].get_mut(&inp[..]) { debug_assert_eq!(result.output, &__ret[..]); if !unconstrained { *result.multiplicity += G::ONE; } } else { record.function_queries[351].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained)); }; return Ok(__ret); }, } }) } -const INPUT_SIZE_356: usize = 2; -const IN_356: usize = 2; -const OUT_356: usize = 1; -fn aiur_fn_356( - inp: [G; IN_356], +const INPUT_SIZE_352: usize = 2; +const IN_352: usize = 2; +const OUT_352: usize = 1; +fn aiur_fn_352( + inp: [G; IN_352], record: &mut QueryRecord, io_buffer: &mut IOBuffer, unconstrained: bool, -) -> Result<[G; OUT_356], ExecError> { +) -> Result<[G; OUT_352], ExecError> { stacker::maybe_grow(64 * 1024, 4 * 1024 * 1024, || { let __v_0: G = inp[0]; let __v_1: G = inp[1]; @@ -32477,19 +32203,19 @@ fn aiur_fn_356( let __v_5: G = __loaded[3]; match __v_2.as_canonical_u64() { 0u64 => { - let __r_arr: [G; OUT_346] = { let __args: [G; IN_346] = [__v_3, __v_1]; let __cu = unconstrained; if let Some(result) = record.function_queries[346].get_mut(&__args[..]) { if !__cu && *result.multiplicity == G::ZERO { aiur_fn_346(__args, record, io_buffer, false)? } else { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_346] = unsafe { *(result.output.as_ptr() as *const [G; OUT_346]) }; __ret } } else { aiur_fn_346(__args, record, io_buffer, __cu)? } }; + let __r_arr: [G; OUT_342] = { let __args: [G; IN_342] = [__v_3, __v_1]; let __cu = unconstrained; if let Some(result) = record.function_queries[342].get_mut(&__args[..]) { if !__cu && *result.multiplicity == G::ZERO { aiur_fn_342(__args, record, io_buffer, false)? } else { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_342] = unsafe { *(result.output.as_ptr() as *const [G; OUT_342]) }; __ret } } else { aiur_fn_342(__args, record, io_buffer, __cu)? } }; let __v_6: G = __r_arr[0]; match __v_6.as_canonical_u64() { 1u64 => { let __v_7: G = G::from_u64(4294967295); - let __ret: [G; OUT_356] = [__v_7]; - if let Some(result) = record.function_queries[356].get_mut(&inp[..]) { debug_assert_eq!(result.output, &__ret[..]); if !unconstrained { *result.multiplicity += G::ONE; } } else { record.function_queries[356].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained)); }; + let __ret: [G; OUT_352] = [__v_7]; + if let Some(result) = record.function_queries[352].get_mut(&inp[..]) { debug_assert_eq!(result.output, &__ret[..]); if !unconstrained { *result.multiplicity += G::ONE; } } else { record.function_queries[352].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained)); }; return Ok(__ret); }, 0u64 => { let __v_7: G = (__v_3 - __v_1); - let __ret: [G; OUT_356] = [__v_7]; - if let Some(result) = record.function_queries[356].get_mut(&inp[..]) { debug_assert_eq!(result.output, &__ret[..]); if !unconstrained { *result.multiplicity += G::ONE; } } else { record.function_queries[356].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained)); }; + let __ret: [G; OUT_352] = [__v_7]; + if let Some(result) = record.function_queries[352].get_mut(&inp[..]) { debug_assert_eq!(result.output, &__ret[..]); if !unconstrained { *result.multiplicity += G::ONE; } } else { record.function_queries[352].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained)); }; return Ok(__ret); }, _ => { @@ -32499,59 +32225,59 @@ fn aiur_fn_356( }, 1u64 => { let __v_6: G = G::from_u64(4294967295); - let __ret: [G; OUT_356] = [__v_6]; - if let Some(result) = record.function_queries[356].get_mut(&inp[..]) { debug_assert_eq!(result.output, &__ret[..]); if !unconstrained { *result.multiplicity += G::ONE; } } else { record.function_queries[356].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained)); }; + let __ret: [G; OUT_352] = [__v_6]; + if let Some(result) = record.function_queries[352].get_mut(&inp[..]) { debug_assert_eq!(result.output, &__ret[..]); if !unconstrained { *result.multiplicity += G::ONE; } } else { record.function_queries[352].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained)); }; return Ok(__ret); }, 2u64 => { let __v_6: G = G::from_u64(4294967295); - let __ret: [G; OUT_356] = [__v_6]; - if let Some(result) = record.function_queries[356].get_mut(&inp[..]) { debug_assert_eq!(result.output, &__ret[..]); if !unconstrained { *result.multiplicity += G::ONE; } } else { record.function_queries[356].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained)); }; + let __ret: [G; OUT_352] = [__v_6]; + if let Some(result) = record.function_queries[352].get_mut(&inp[..]) { debug_assert_eq!(result.output, &__ret[..]); if !unconstrained { *result.multiplicity += G::ONE; } } else { record.function_queries[352].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained)); }; return Ok(__ret); }, 7u64 => { let __v_6: G = G::from_u64(4294967295); - let __ret: [G; OUT_356] = [__v_6]; - if let Some(result) = record.function_queries[356].get_mut(&inp[..]) { debug_assert_eq!(result.output, &__ret[..]); if !unconstrained { *result.multiplicity += G::ONE; } } else { record.function_queries[356].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained)); }; + let __ret: [G; OUT_352] = [__v_6]; + if let Some(result) = record.function_queries[352].get_mut(&inp[..]) { debug_assert_eq!(result.output, &__ret[..]); if !unconstrained { *result.multiplicity += G::ONE; } } else { record.function_queries[352].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained)); }; return Ok(__ret); }, 3u64 => { - let __r_arr: [G; OUT_355] = { let __args: [G; IN_355] = [__v_3, __v_1]; let __cu = unconstrained; if let Some(result) = record.function_queries[355].get_mut(&__args[..]) { if !__cu && *result.multiplicity == G::ZERO { aiur_fn_355(__args, record, io_buffer, false)? } else { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_355] = unsafe { *(result.output.as_ptr() as *const [G; OUT_355]) }; __ret } } else { aiur_fn_355(__args, record, io_buffer, __cu)? } }; + let __r_arr: [G; OUT_351] = { let __args: [G; IN_351] = [__v_3, __v_1]; let __cu = unconstrained; if let Some(result) = record.function_queries[351].get_mut(&__args[..]) { if !__cu && *result.multiplicity == G::ZERO { aiur_fn_351(__args, record, io_buffer, false)? } else { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_351] = unsafe { *(result.output.as_ptr() as *const [G; OUT_351]) }; __ret } } else { aiur_fn_351(__args, record, io_buffer, __cu)? } }; let __v_6: G = __r_arr[0]; - let __r_arr: [G; OUT_355] = { let __args: [G; IN_355] = [__v_4, __v_1]; let __cu = unconstrained; if let Some(result) = record.function_queries[355].get_mut(&__args[..]) { if !__cu && *result.multiplicity == G::ZERO { aiur_fn_355(__args, record, io_buffer, false)? } else { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_355] = unsafe { *(result.output.as_ptr() as *const [G; OUT_355]) }; __ret } } else { aiur_fn_355(__args, record, io_buffer, __cu)? } }; + let __r_arr: [G; OUT_351] = { let __args: [G; IN_351] = [__v_4, __v_1]; let __cu = unconstrained; if let Some(result) = record.function_queries[351].get_mut(&__args[..]) { if !__cu && *result.multiplicity == G::ZERO { aiur_fn_351(__args, record, io_buffer, false)? } else { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_351] = unsafe { *(result.output.as_ptr() as *const [G; OUT_351]) }; __ret } } else { aiur_fn_351(__args, record, io_buffer, __cu)? } }; let __v_7: G = __r_arr[0]; - let __r_arr: [G; OUT_345] = { let __args: [G; IN_345] = [__v_6, __v_7]; let __cu = unconstrained; if let Some(result) = record.function_queries[345].get_mut(&__args[..]) { if !__cu && *result.multiplicity == G::ZERO { aiur_fn_345(__args, record, io_buffer, false)? } else { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_345] = unsafe { *(result.output.as_ptr() as *const [G; OUT_345]) }; __ret } } else { aiur_fn_345(__args, record, io_buffer, __cu)? } }; + let __r_arr: [G; OUT_341] = { let __args: [G; IN_341] = [__v_6, __v_7]; let __cu = unconstrained; if let Some(result) = record.function_queries[341].get_mut(&__args[..]) { if !__cu && *result.multiplicity == G::ZERO { aiur_fn_341(__args, record, io_buffer, false)? } else { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_341] = unsafe { *(result.output.as_ptr() as *const [G; OUT_341]) }; __ret } } else { aiur_fn_341(__args, record, io_buffer, __cu)? } }; let __v_8: G = __r_arr[0]; - let __ret: [G; OUT_356] = [__v_8]; - if let Some(result) = record.function_queries[356].get_mut(&inp[..]) { debug_assert_eq!(result.output, &__ret[..]); if !unconstrained { *result.multiplicity += G::ONE; } } else { record.function_queries[356].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained)); }; + let __ret: [G; OUT_352] = [__v_8]; + if let Some(result) = record.function_queries[352].get_mut(&inp[..]) { debug_assert_eq!(result.output, &__ret[..]); if !unconstrained { *result.multiplicity += G::ONE; } } else { record.function_queries[352].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained)); }; return Ok(__ret); }, 4u64 => { - let __r_arr: [G; OUT_357] = { let __args: [G; IN_357] = [__v_3, __v_4, __v_1]; let __cu = unconstrained; if let Some(result) = record.function_queries[357].get_mut(&__args[..]) { if !__cu && *result.multiplicity == G::ZERO { aiur_fn_357(__args, record, io_buffer, false)? } else { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_357] = unsafe { *(result.output.as_ptr() as *const [G; OUT_357]) }; __ret } } else { aiur_fn_357(__args, record, io_buffer, __cu)? } }; + let __r_arr: [G; OUT_353] = { let __args: [G; IN_353] = [__v_3, __v_4, __v_1]; let __cu = unconstrained; if let Some(result) = record.function_queries[353].get_mut(&__args[..]) { if !__cu && *result.multiplicity == G::ZERO { aiur_fn_353(__args, record, io_buffer, false)? } else { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_353] = unsafe { *(result.output.as_ptr() as *const [G; OUT_353]) }; __ret } } else { aiur_fn_353(__args, record, io_buffer, __cu)? } }; let __v_6: G = __r_arr[0]; - let __ret: [G; OUT_356] = [__v_6]; - if let Some(result) = record.function_queries[356].get_mut(&inp[..]) { debug_assert_eq!(result.output, &__ret[..]); if !unconstrained { *result.multiplicity += G::ONE; } } else { record.function_queries[356].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained)); }; + let __ret: [G; OUT_352] = [__v_6]; + if let Some(result) = record.function_queries[352].get_mut(&inp[..]) { debug_assert_eq!(result.output, &__ret[..]); if !unconstrained { *result.multiplicity += G::ONE; } } else { record.function_queries[352].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained)); }; return Ok(__ret); }, 5u64 => { - let __r_arr: [G; OUT_357] = { let __args: [G; IN_357] = [__v_3, __v_4, __v_1]; let __cu = unconstrained; if let Some(result) = record.function_queries[357].get_mut(&__args[..]) { if !__cu && *result.multiplicity == G::ZERO { aiur_fn_357(__args, record, io_buffer, false)? } else { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_357] = unsafe { *(result.output.as_ptr() as *const [G; OUT_357]) }; __ret } } else { aiur_fn_357(__args, record, io_buffer, __cu)? } }; + let __r_arr: [G; OUT_353] = { let __args: [G; IN_353] = [__v_3, __v_4, __v_1]; let __cu = unconstrained; if let Some(result) = record.function_queries[353].get_mut(&__args[..]) { if !__cu && *result.multiplicity == G::ZERO { aiur_fn_353(__args, record, io_buffer, false)? } else { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_353] = unsafe { *(result.output.as_ptr() as *const [G; OUT_353]) }; __ret } } else { aiur_fn_353(__args, record, io_buffer, __cu)? } }; let __v_6: G = __r_arr[0]; - let __ret: [G; OUT_356] = [__v_6]; - if let Some(result) = record.function_queries[356].get_mut(&inp[..]) { debug_assert_eq!(result.output, &__ret[..]); if !unconstrained { *result.multiplicity += G::ONE; } } else { record.function_queries[356].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained)); }; + let __ret: [G; OUT_352] = [__v_6]; + if let Some(result) = record.function_queries[352].get_mut(&inp[..]) { debug_assert_eq!(result.output, &__ret[..]); if !unconstrained { *result.multiplicity += G::ONE; } } else { record.function_queries[352].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained)); }; return Ok(__ret); }, 6u64 => { - let __r_arr: [G; OUT_358] = { let __args: [G; IN_358] = [__v_3, __v_4, __v_5, __v_1]; let __cu = unconstrained; if let Some(result) = record.function_queries[358].get_mut(&__args[..]) { if !__cu && *result.multiplicity == G::ZERO { aiur_fn_358(__args, record, io_buffer, false)? } else { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_358] = unsafe { *(result.output.as_ptr() as *const [G; OUT_358]) }; __ret } } else { aiur_fn_358(__args, record, io_buffer, __cu)? } }; + let __r_arr: [G; OUT_354] = { let __args: [G; IN_354] = [__v_3, __v_4, __v_5, __v_1]; let __cu = unconstrained; if let Some(result) = record.function_queries[354].get_mut(&__args[..]) { if !__cu && *result.multiplicity == G::ZERO { aiur_fn_354(__args, record, io_buffer, false)? } else { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_354] = unsafe { *(result.output.as_ptr() as *const [G; OUT_354]) }; __ret } } else { aiur_fn_354(__args, record, io_buffer, __cu)? } }; let __v_6: G = __r_arr[0]; - let __ret: [G; OUT_356] = [__v_6]; - if let Some(result) = record.function_queries[356].get_mut(&inp[..]) { debug_assert_eq!(result.output, &__ret[..]); if !unconstrained { *result.multiplicity += G::ONE; } } else { record.function_queries[356].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained)); }; + let __ret: [G; OUT_352] = [__v_6]; + if let Some(result) = record.function_queries[352].get_mut(&inp[..]) { debug_assert_eq!(result.output, &__ret[..]); if !unconstrained { *result.multiplicity += G::ONE; } } else { record.function_queries[352].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained)); }; return Ok(__ret); }, 8u64 => { - let __r_arr: [G; OUT_355] = { let __args: [G; IN_355] = [__v_5, __v_1]; let __cu = unconstrained; if let Some(result) = record.function_queries[355].get_mut(&__args[..]) { if !__cu && *result.multiplicity == G::ZERO { aiur_fn_355(__args, record, io_buffer, false)? } else { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_355] = unsafe { *(result.output.as_ptr() as *const [G; OUT_355]) }; __ret } } else { aiur_fn_355(__args, record, io_buffer, __cu)? } }; + let __r_arr: [G; OUT_351] = { let __args: [G; IN_351] = [__v_5, __v_1]; let __cu = unconstrained; if let Some(result) = record.function_queries[351].get_mut(&__args[..]) { if !__cu && *result.multiplicity == G::ZERO { aiur_fn_351(__args, record, io_buffer, false)? } else { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_351] = unsafe { *(result.output.as_ptr() as *const [G; OUT_351]) }; __ret } } else { aiur_fn_351(__args, record, io_buffer, __cu)? } }; let __v_6: G = __r_arr[0]; - let __ret: [G; OUT_356] = [__v_6]; - if let Some(result) = record.function_queries[356].get_mut(&inp[..]) { debug_assert_eq!(result.output, &__ret[..]); if !unconstrained { *result.multiplicity += G::ONE; } } else { record.function_queries[356].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained)); }; + let __ret: [G; OUT_352] = [__v_6]; + if let Some(result) = record.function_queries[352].get_mut(&inp[..]) { debug_assert_eq!(result.output, &__ret[..]); if !unconstrained { *result.multiplicity += G::ONE; } } else { record.function_queries[352].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained)); }; return Ok(__ret); }, _ => { @@ -32561,100 +32287,100 @@ fn aiur_fn_356( }) } -const INPUT_SIZE_357: usize = 3; -const IN_357: usize = 3; -const OUT_357: usize = 1; -fn aiur_fn_357( - inp: [G; IN_357], +const INPUT_SIZE_353: usize = 3; +const IN_353: usize = 3; +const OUT_353: usize = 1; +fn aiur_fn_353( + inp: [G; IN_353], record: &mut QueryRecord, io_buffer: &mut IOBuffer, unconstrained: bool, -) -> Result<[G; OUT_357], ExecError> { +) -> Result<[G; OUT_353], ExecError> { stacker::maybe_grow(64 * 1024, 4 * 1024 * 1024, || { let __v_0: G = inp[0]; let __v_1: G = inp[1]; let __v_2: G = inp[2]; - let __r_arr: [G; OUT_355] = { let __args: [G; IN_355] = [__v_0, __v_2]; let __cu = unconstrained; if let Some(result) = record.function_queries[355].get_mut(&__args[..]) { if !__cu && *result.multiplicity == G::ZERO { aiur_fn_355(__args, record, io_buffer, false)? } else { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_355] = unsafe { *(result.output.as_ptr() as *const [G; OUT_355]) }; __ret } } else { aiur_fn_355(__args, record, io_buffer, __cu)? } }; + let __r_arr: [G; OUT_351] = { let __args: [G; IN_351] = [__v_0, __v_2]; let __cu = unconstrained; if let Some(result) = record.function_queries[351].get_mut(&__args[..]) { if !__cu && *result.multiplicity == G::ZERO { aiur_fn_351(__args, record, io_buffer, false)? } else { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_351] = unsafe { *(result.output.as_ptr() as *const [G; OUT_351]) }; __ret } } else { aiur_fn_351(__args, record, io_buffer, __cu)? } }; let __v_3: G = __r_arr[0]; let __v_4: G = G::from_u64(1); let __v_5: G = (__v_2 + __v_4); - let __r_arr: [G; OUT_355] = { let __args: [G; IN_355] = [__v_1, __v_5]; let __cu = unconstrained; if let Some(result) = record.function_queries[355].get_mut(&__args[..]) { if !__cu && *result.multiplicity == G::ZERO { aiur_fn_355(__args, record, io_buffer, false)? } else { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_355] = unsafe { *(result.output.as_ptr() as *const [G; OUT_355]) }; __ret } } else { aiur_fn_355(__args, record, io_buffer, __cu)? } }; + let __r_arr: [G; OUT_351] = { let __args: [G; IN_351] = [__v_1, __v_5]; let __cu = unconstrained; if let Some(result) = record.function_queries[351].get_mut(&__args[..]) { if !__cu && *result.multiplicity == G::ZERO { aiur_fn_351(__args, record, io_buffer, false)? } else { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_351] = unsafe { *(result.output.as_ptr() as *const [G; OUT_351]) }; __ret } } else { aiur_fn_351(__args, record, io_buffer, __cu)? } }; let __v_6: G = __r_arr[0]; - let __r_arr: [G; OUT_345] = { let __args: [G; IN_345] = [__v_3, __v_6]; let __cu = unconstrained; if let Some(result) = record.function_queries[345].get_mut(&__args[..]) { if !__cu && *result.multiplicity == G::ZERO { aiur_fn_345(__args, record, io_buffer, false)? } else { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_345] = unsafe { *(result.output.as_ptr() as *const [G; OUT_345]) }; __ret } } else { aiur_fn_345(__args, record, io_buffer, __cu)? } }; + let __r_arr: [G; OUT_341] = { let __args: [G; IN_341] = [__v_3, __v_6]; let __cu = unconstrained; if let Some(result) = record.function_queries[341].get_mut(&__args[..]) { if !__cu && *result.multiplicity == G::ZERO { aiur_fn_341(__args, record, io_buffer, false)? } else { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_341] = unsafe { *(result.output.as_ptr() as *const [G; OUT_341]) }; __ret } } else { aiur_fn_341(__args, record, io_buffer, __cu)? } }; let __v_7: G = __r_arr[0]; - let __ret: [G; OUT_357] = [__v_7]; - if let Some(result) = record.function_queries[357].get_mut(&inp[..]) { debug_assert_eq!(result.output, &__ret[..]); if !unconstrained { *result.multiplicity += G::ONE; } } else { record.function_queries[357].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained)); }; + let __ret: [G; OUT_353] = [__v_7]; + if let Some(result) = record.function_queries[353].get_mut(&inp[..]) { debug_assert_eq!(result.output, &__ret[..]); if !unconstrained { *result.multiplicity += G::ONE; } } else { record.function_queries[353].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained)); }; return Ok(__ret); }) } -const INPUT_SIZE_358: usize = 4; -const IN_358: usize = 4; -const OUT_358: usize = 1; -fn aiur_fn_358( - inp: [G; IN_358], +const INPUT_SIZE_354: usize = 4; +const IN_354: usize = 4; +const OUT_354: usize = 1; +fn aiur_fn_354( + inp: [G; IN_354], record: &mut QueryRecord, io_buffer: &mut IOBuffer, unconstrained: bool, -) -> Result<[G; OUT_358], ExecError> { +) -> Result<[G; OUT_354], ExecError> { stacker::maybe_grow(64 * 1024, 4 * 1024 * 1024, || { let __v_0: G = inp[0]; let __v_1: G = inp[1]; let __v_2: G = inp[2]; let __v_3: G = inp[3]; - let __r_arr: [G; OUT_355] = { let __args: [G; IN_355] = [__v_0, __v_3]; let __cu = unconstrained; if let Some(result) = record.function_queries[355].get_mut(&__args[..]) { if !__cu && *result.multiplicity == G::ZERO { aiur_fn_355(__args, record, io_buffer, false)? } else { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_355] = unsafe { *(result.output.as_ptr() as *const [G; OUT_355]) }; __ret } } else { aiur_fn_355(__args, record, io_buffer, __cu)? } }; + let __r_arr: [G; OUT_351] = { let __args: [G; IN_351] = [__v_0, __v_3]; let __cu = unconstrained; if let Some(result) = record.function_queries[351].get_mut(&__args[..]) { if !__cu && *result.multiplicity == G::ZERO { aiur_fn_351(__args, record, io_buffer, false)? } else { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_351] = unsafe { *(result.output.as_ptr() as *const [G; OUT_351]) }; __ret } } else { aiur_fn_351(__args, record, io_buffer, __cu)? } }; let __v_4: G = __r_arr[0]; - let __r_arr: [G; OUT_355] = { let __args: [G; IN_355] = [__v_1, __v_3]; let __cu = unconstrained; if let Some(result) = record.function_queries[355].get_mut(&__args[..]) { if !__cu && *result.multiplicity == G::ZERO { aiur_fn_355(__args, record, io_buffer, false)? } else { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_355] = unsafe { *(result.output.as_ptr() as *const [G; OUT_355]) }; __ret } } else { aiur_fn_355(__args, record, io_buffer, __cu)? } }; + let __r_arr: [G; OUT_351] = { let __args: [G; IN_351] = [__v_1, __v_3]; let __cu = unconstrained; if let Some(result) = record.function_queries[351].get_mut(&__args[..]) { if !__cu && *result.multiplicity == G::ZERO { aiur_fn_351(__args, record, io_buffer, false)? } else { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_351] = unsafe { *(result.output.as_ptr() as *const [G; OUT_351]) }; __ret } } else { aiur_fn_351(__args, record, io_buffer, __cu)? } }; let __v_5: G = __r_arr[0]; - let __r_arr: [G; OUT_345] = { let __args: [G; IN_345] = [__v_4, __v_5]; let __cu = unconstrained; if let Some(result) = record.function_queries[345].get_mut(&__args[..]) { if !__cu && *result.multiplicity == G::ZERO { aiur_fn_345(__args, record, io_buffer, false)? } else { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_345] = unsafe { *(result.output.as_ptr() as *const [G; OUT_345]) }; __ret } } else { aiur_fn_345(__args, record, io_buffer, __cu)? } }; + let __r_arr: [G; OUT_341] = { let __args: [G; IN_341] = [__v_4, __v_5]; let __cu = unconstrained; if let Some(result) = record.function_queries[341].get_mut(&__args[..]) { if !__cu && *result.multiplicity == G::ZERO { aiur_fn_341(__args, record, io_buffer, false)? } else { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_341] = unsafe { *(result.output.as_ptr() as *const [G; OUT_341]) }; __ret } } else { aiur_fn_341(__args, record, io_buffer, __cu)? } }; let __v_6: G = __r_arr[0]; let __v_7: G = G::from_u64(1); let __v_8: G = (__v_3 + __v_7); - let __r_arr: [G; OUT_355] = { let __args: [G; IN_355] = [__v_2, __v_8]; let __cu = unconstrained; if let Some(result) = record.function_queries[355].get_mut(&__args[..]) { if !__cu && *result.multiplicity == G::ZERO { aiur_fn_355(__args, record, io_buffer, false)? } else { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_355] = unsafe { *(result.output.as_ptr() as *const [G; OUT_355]) }; __ret } } else { aiur_fn_355(__args, record, io_buffer, __cu)? } }; + let __r_arr: [G; OUT_351] = { let __args: [G; IN_351] = [__v_2, __v_8]; let __cu = unconstrained; if let Some(result) = record.function_queries[351].get_mut(&__args[..]) { if !__cu && *result.multiplicity == G::ZERO { aiur_fn_351(__args, record, io_buffer, false)? } else { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_351] = unsafe { *(result.output.as_ptr() as *const [G; OUT_351]) }; __ret } } else { aiur_fn_351(__args, record, io_buffer, __cu)? } }; let __v_9: G = __r_arr[0]; - let __r_arr: [G; OUT_345] = { let __args: [G; IN_345] = [__v_6, __v_9]; let __cu = unconstrained; if let Some(result) = record.function_queries[345].get_mut(&__args[..]) { if !__cu && *result.multiplicity == G::ZERO { aiur_fn_345(__args, record, io_buffer, false)? } else { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_345] = unsafe { *(result.output.as_ptr() as *const [G; OUT_345]) }; __ret } } else { aiur_fn_345(__args, record, io_buffer, __cu)? } }; + let __r_arr: [G; OUT_341] = { let __args: [G; IN_341] = [__v_6, __v_9]; let __cu = unconstrained; if let Some(result) = record.function_queries[341].get_mut(&__args[..]) { if !__cu && *result.multiplicity == G::ZERO { aiur_fn_341(__args, record, io_buffer, false)? } else { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_341] = unsafe { *(result.output.as_ptr() as *const [G; OUT_341]) }; __ret } } else { aiur_fn_341(__args, record, io_buffer, __cu)? } }; let __v_10: G = __r_arr[0]; - let __ret: [G; OUT_358] = [__v_10]; - if let Some(result) = record.function_queries[358].get_mut(&inp[..]) { debug_assert_eq!(result.output, &__ret[..]); if !unconstrained { *result.multiplicity += G::ONE; } } else { record.function_queries[358].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained)); }; + let __ret: [G; OUT_354] = [__v_10]; + if let Some(result) = record.function_queries[354].get_mut(&inp[..]) { debug_assert_eq!(result.output, &__ret[..]); if !unconstrained { *result.multiplicity += G::ONE; } } else { record.function_queries[354].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained)); }; return Ok(__ret); }) } -const INPUT_SIZE_359: usize = 3; -const IN_359: usize = 3; -const OUT_359: usize = 1; -fn aiur_fn_359( - inp: [G; IN_359], +const INPUT_SIZE_355: usize = 3; +const IN_355: usize = 3; +const OUT_355: usize = 1; +fn aiur_fn_355( + inp: [G; IN_355], record: &mut QueryRecord, io_buffer: &mut IOBuffer, unconstrained: bool, -) -> Result<[G; OUT_359], ExecError> { +) -> Result<[G; OUT_355], ExecError> { stacker::maybe_grow(64 * 1024, 4 * 1024 * 1024, || { let __v_0: G = inp[0]; let __v_1: G = inp[1]; let __v_2: G = inp[2]; match __v_1.as_canonical_u64() { 0u64 => { - let __ret: [G; OUT_359] = [__v_0]; - if let Some(result) = record.function_queries[359].get_mut(&inp[..]) { debug_assert_eq!(result.output, &__ret[..]); if !unconstrained { *result.multiplicity += G::ONE; } } else { record.function_queries[359].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained)); }; + let __ret: [G; OUT_355] = [__v_0]; + if let Some(result) = record.function_queries[355].get_mut(&inp[..]) { debug_assert_eq!(result.output, &__ret[..]); if !unconstrained { *result.multiplicity += G::ONE; } } else { record.function_queries[355].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained)); }; return Ok(__ret); }, _ => { - let __r_arr: [G; OUT_341] = { let __args: [G; IN_341] = [__v_0]; let __cu = unconstrained; if let Some(result) = record.function_queries[341].get_mut(&__args[..]) { if !__cu && *result.multiplicity == G::ZERO { aiur_fn_341(__args, record, io_buffer, false)? } else { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_341] = unsafe { *(result.output.as_ptr() as *const [G; OUT_341]) }; __ret } } else { aiur_fn_341(__args, record, io_buffer, __cu)? } }; + let __r_arr: [G; OUT_337] = { let __args: [G; IN_337] = [__v_0]; let __cu = unconstrained; if let Some(result) = record.function_queries[337].get_mut(&__args[..]) { if !__cu && *result.multiplicity == G::ZERO { aiur_fn_337(__args, record, io_buffer, false)? } else { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_337] = unsafe { *(result.output.as_ptr() as *const [G; OUT_337]) }; __ret } } else { aiur_fn_337(__args, record, io_buffer, __cu)? } }; let __v_3: G = __r_arr[0]; - let __r_arr: [G; OUT_346] = { let __args: [G; IN_346] = [__v_2, __v_3]; let __cu = unconstrained; if let Some(result) = record.function_queries[346].get_mut(&__args[..]) { if !__cu && *result.multiplicity == G::ZERO { aiur_fn_346(__args, record, io_buffer, false)? } else { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_346] = unsafe { *(result.output.as_ptr() as *const [G; OUT_346]) }; __ret } } else { aiur_fn_346(__args, record, io_buffer, __cu)? } }; + let __r_arr: [G; OUT_342] = { let __args: [G; IN_342] = [__v_2, __v_3]; let __cu = unconstrained; if let Some(result) = record.function_queries[342].get_mut(&__args[..]) { if !__cu && *result.multiplicity == G::ZERO { aiur_fn_342(__args, record, io_buffer, false)? } else { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_342] = unsafe { *(result.output.as_ptr() as *const [G; OUT_342]) }; __ret } } else { aiur_fn_342(__args, record, io_buffer, __cu)? } }; let __v_4: G = __r_arr[0]; match __v_4.as_canonical_u64() { 0u64 => { - let __ret: [G; OUT_359] = [__v_0]; - if let Some(result) = record.function_queries[359].get_mut(&inp[..]) { debug_assert_eq!(result.output, &__ret[..]); if !unconstrained { *result.multiplicity += G::ONE; } } else { record.function_queries[359].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained)); }; + let __ret: [G; OUT_355] = [__v_0]; + if let Some(result) = record.function_queries[355].get_mut(&inp[..]) { debug_assert_eq!(result.output, &__ret[..]); if !unconstrained { *result.multiplicity += G::ONE; } } else { record.function_queries[355].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained)); }; return Ok(__ret); }, 1u64 => { - let __r_arr: [G; OUT_360] = { let __args: [G; IN_360] = [__v_0, __v_1, __v_2]; let __cu = unconstrained; if let Some(result) = record.function_queries[360].get_mut(&__args[..]) { if !__cu && *result.multiplicity == G::ZERO { aiur_fn_360(__args, record, io_buffer, false)? } else { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_360] = unsafe { *(result.output.as_ptr() as *const [G; OUT_360]) }; __ret } } else { aiur_fn_360(__args, record, io_buffer, __cu)? } }; + let __r_arr: [G; OUT_356] = { let __args: [G; IN_356] = [__v_0, __v_1, __v_2]; let __cu = unconstrained; if let Some(result) = record.function_queries[356].get_mut(&__args[..]) { if !__cu && *result.multiplicity == G::ZERO { aiur_fn_356(__args, record, io_buffer, false)? } else { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_356] = unsafe { *(result.output.as_ptr() as *const [G; OUT_356]) }; __ret } } else { aiur_fn_356(__args, record, io_buffer, __cu)? } }; let __v_5: G = __r_arr[0]; - let __ret: [G; OUT_359] = [__v_5]; - if let Some(result) = record.function_queries[359].get_mut(&inp[..]) { debug_assert_eq!(result.output, &__ret[..]); if !unconstrained { *result.multiplicity += G::ONE; } } else { record.function_queries[359].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained)); }; + let __ret: [G; OUT_355] = [__v_5]; + if let Some(result) = record.function_queries[355].get_mut(&inp[..]) { debug_assert_eq!(result.output, &__ret[..]); if !unconstrained { *result.multiplicity += G::ONE; } } else { record.function_queries[355].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained)); }; return Ok(__ret); }, _ => { @@ -32666,15 +32392,15 @@ fn aiur_fn_359( }) } -const INPUT_SIZE_360: usize = 3; -const IN_360: usize = 3; -const OUT_360: usize = 1; -fn aiur_fn_360( - inp: [G; IN_360], +const INPUT_SIZE_356: usize = 3; +const IN_356: usize = 3; +const OUT_356: usize = 1; +fn aiur_fn_356( + inp: [G; IN_356], record: &mut QueryRecord, io_buffer: &mut IOBuffer, unconstrained: bool, -) -> Result<[G; OUT_360], ExecError> { +) -> Result<[G; OUT_356], ExecError> { stacker::maybe_grow(64 * 1024, 4 * 1024 * 1024, || { let __v_0: G = inp[0]; let __v_1: G = inp[1]; @@ -32686,90 +32412,90 @@ fn aiur_fn_360( let __v_6: G = __loaded[3]; match __v_3.as_canonical_u64() { 0u64 => { - let __r_arr: [G; OUT_361] = { let __args: [G; IN_361] = [__v_4, __v_1, __v_2]; let __cu = unconstrained; if let Some(result) = record.function_queries[361].get_mut(&__args[..]) { if !__cu && *result.multiplicity == G::ZERO { aiur_fn_361(__args, record, io_buffer, false)? } else { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_361] = unsafe { *(result.output.as_ptr() as *const [G; OUT_361]) }; __ret } } else { aiur_fn_361(__args, record, io_buffer, __cu)? } }; + let __r_arr: [G; OUT_357] = { let __args: [G; IN_357] = [__v_4, __v_1, __v_2]; let __cu = unconstrained; if let Some(result) = record.function_queries[357].get_mut(&__args[..]) { if !__cu && *result.multiplicity == G::ZERO { aiur_fn_357(__args, record, io_buffer, false)? } else { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_357] = unsafe { *(result.output.as_ptr() as *const [G; OUT_357]) }; __ret } } else { aiur_fn_357(__args, record, io_buffer, __cu)? } }; let __v_7: G = __r_arr[0]; - let __ret: [G; OUT_360] = [__v_7]; - if let Some(result) = record.function_queries[360].get_mut(&inp[..]) { debug_assert_eq!(result.output, &__ret[..]); if !unconstrained { *result.multiplicity += G::ONE; } } else { record.function_queries[360].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained)); }; + let __ret: [G; OUT_356] = [__v_7]; + if let Some(result) = record.function_queries[356].get_mut(&inp[..]) { debug_assert_eq!(result.output, &__ret[..]); if !unconstrained { *result.multiplicity += G::ONE; } } else { record.function_queries[356].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained)); }; return Ok(__ret); }, 1u64 => { let __v_7: G = G::from_u64(1); let __v_8: G = G::from_u64(0); let __v_9: G = { let __values: [G; 4] = [__v_7, __v_4, __v_8, __v_8]; let __mq = record.memory_queries.get_mut(&4).ok_or(ExecError::InvalidMemorySize(4))?; if let Some(result) = __mq.get_mut(&__values[..]) { if !unconstrained { *result.multiplicity += G::ONE; } result.output[0] } else { let __ptr = G::from_usize(__mq.len()); __mq.insert(&__values[..], &[__ptr], G::from_bool(!unconstrained)); __ptr } }; - let __ret: [G; OUT_360] = [__v_9]; - if let Some(result) = record.function_queries[360].get_mut(&inp[..]) { debug_assert_eq!(result.output, &__ret[..]); if !unconstrained { *result.multiplicity += G::ONE; } } else { record.function_queries[360].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained)); }; + let __ret: [G; OUT_356] = [__v_9]; + if let Some(result) = record.function_queries[356].get_mut(&inp[..]) { debug_assert_eq!(result.output, &__ret[..]); if !unconstrained { *result.multiplicity += G::ONE; } } else { record.function_queries[356].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained)); }; return Ok(__ret); }, 2u64 => { let __v_7: G = G::from_u64(2); let __v_8: G = G::from_u64(0); let __v_9: G = { let __values: [G; 4] = [__v_7, __v_4, __v_5, __v_8]; let __mq = record.memory_queries.get_mut(&4).ok_or(ExecError::InvalidMemorySize(4))?; if let Some(result) = __mq.get_mut(&__values[..]) { if !unconstrained { *result.multiplicity += G::ONE; } result.output[0] } else { let __ptr = G::from_usize(__mq.len()); __mq.insert(&__values[..], &[__ptr], G::from_bool(!unconstrained)); __ptr } }; - let __ret: [G; OUT_360] = [__v_9]; - if let Some(result) = record.function_queries[360].get_mut(&inp[..]) { debug_assert_eq!(result.output, &__ret[..]); if !unconstrained { *result.multiplicity += G::ONE; } } else { record.function_queries[360].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained)); }; + let __ret: [G; OUT_356] = [__v_9]; + if let Some(result) = record.function_queries[356].get_mut(&inp[..]) { debug_assert_eq!(result.output, &__ret[..]); if !unconstrained { *result.multiplicity += G::ONE; } } else { record.function_queries[356].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained)); }; return Ok(__ret); }, 3u64 => { let __v_7: G = G::from_u64(3); - let __r_arr: [G; OUT_359] = { let __args: [G; IN_359] = [__v_4, __v_1, __v_2]; let __cu = unconstrained; if let Some(result) = record.function_queries[359].get_mut(&__args[..]) { if !__cu && *result.multiplicity == G::ZERO { aiur_fn_359(__args, record, io_buffer, false)? } else { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_359] = unsafe { *(result.output.as_ptr() as *const [G; OUT_359]) }; __ret } } else { aiur_fn_359(__args, record, io_buffer, __cu)? } }; + let __r_arr: [G; OUT_355] = { let __args: [G; IN_355] = [__v_4, __v_1, __v_2]; let __cu = unconstrained; if let Some(result) = record.function_queries[355].get_mut(&__args[..]) { if !__cu && *result.multiplicity == G::ZERO { aiur_fn_355(__args, record, io_buffer, false)? } else { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_355] = unsafe { *(result.output.as_ptr() as *const [G; OUT_355]) }; __ret } } else { aiur_fn_355(__args, record, io_buffer, __cu)? } }; let __v_8: G = __r_arr[0]; - let __r_arr: [G; OUT_359] = { let __args: [G; IN_359] = [__v_5, __v_1, __v_2]; let __cu = unconstrained; if let Some(result) = record.function_queries[359].get_mut(&__args[..]) { if !__cu && *result.multiplicity == G::ZERO { aiur_fn_359(__args, record, io_buffer, false)? } else { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_359] = unsafe { *(result.output.as_ptr() as *const [G; OUT_359]) }; __ret } } else { aiur_fn_359(__args, record, io_buffer, __cu)? } }; + let __r_arr: [G; OUT_355] = { let __args: [G; IN_355] = [__v_5, __v_1, __v_2]; let __cu = unconstrained; if let Some(result) = record.function_queries[355].get_mut(&__args[..]) { if !__cu && *result.multiplicity == G::ZERO { aiur_fn_355(__args, record, io_buffer, false)? } else { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_355] = unsafe { *(result.output.as_ptr() as *const [G; OUT_355]) }; __ret } } else { aiur_fn_355(__args, record, io_buffer, __cu)? } }; let __v_9: G = __r_arr[0]; let __v_10: G = G::from_u64(0); let __v_11: G = { let __values: [G; 4] = [__v_7, __v_8, __v_9, __v_10]; let __mq = record.memory_queries.get_mut(&4).ok_or(ExecError::InvalidMemorySize(4))?; if let Some(result) = __mq.get_mut(&__values[..]) { if !unconstrained { *result.multiplicity += G::ONE; } result.output[0] } else { let __ptr = G::from_usize(__mq.len()); __mq.insert(&__values[..], &[__ptr], G::from_bool(!unconstrained)); __ptr } }; - let __ret: [G; OUT_360] = [__v_11]; - if let Some(result) = record.function_queries[360].get_mut(&inp[..]) { debug_assert_eq!(result.output, &__ret[..]); if !unconstrained { *result.multiplicity += G::ONE; } } else { record.function_queries[360].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained)); }; + let __ret: [G; OUT_356] = [__v_11]; + if let Some(result) = record.function_queries[356].get_mut(&inp[..]) { debug_assert_eq!(result.output, &__ret[..]); if !unconstrained { *result.multiplicity += G::ONE; } } else { record.function_queries[356].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained)); }; return Ok(__ret); }, 4u64 => { let __v_7: G = G::from_u64(4); - let __r_arr: [G; OUT_359] = { let __args: [G; IN_359] = [__v_4, __v_1, __v_2]; let __cu = unconstrained; if let Some(result) = record.function_queries[359].get_mut(&__args[..]) { if !__cu && *result.multiplicity == G::ZERO { aiur_fn_359(__args, record, io_buffer, false)? } else { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_359] = unsafe { *(result.output.as_ptr() as *const [G; OUT_359]) }; __ret } } else { aiur_fn_359(__args, record, io_buffer, __cu)? } }; + let __r_arr: [G; OUT_355] = { let __args: [G; IN_355] = [__v_4, __v_1, __v_2]; let __cu = unconstrained; if let Some(result) = record.function_queries[355].get_mut(&__args[..]) { if !__cu && *result.multiplicity == G::ZERO { aiur_fn_355(__args, record, io_buffer, false)? } else { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_355] = unsafe { *(result.output.as_ptr() as *const [G; OUT_355]) }; __ret } } else { aiur_fn_355(__args, record, io_buffer, __cu)? } }; let __v_8: G = __r_arr[0]; let __v_9: G = G::from_u64(1); let __v_10: G = (__v_2 + __v_9); - let __r_arr: [G; OUT_359] = { let __args: [G; IN_359] = [__v_5, __v_1, __v_10]; let __cu = unconstrained; if let Some(result) = record.function_queries[359].get_mut(&__args[..]) { if !__cu && *result.multiplicity == G::ZERO { aiur_fn_359(__args, record, io_buffer, false)? } else { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_359] = unsafe { *(result.output.as_ptr() as *const [G; OUT_359]) }; __ret } } else { aiur_fn_359(__args, record, io_buffer, __cu)? } }; + let __r_arr: [G; OUT_355] = { let __args: [G; IN_355] = [__v_5, __v_1, __v_10]; let __cu = unconstrained; if let Some(result) = record.function_queries[355].get_mut(&__args[..]) { if !__cu && *result.multiplicity == G::ZERO { aiur_fn_355(__args, record, io_buffer, false)? } else { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_355] = unsafe { *(result.output.as_ptr() as *const [G; OUT_355]) }; __ret } } else { aiur_fn_355(__args, record, io_buffer, __cu)? } }; let __v_11: G = __r_arr[0]; let __v_12: G = G::from_u64(0); let __v_13: G = { let __values: [G; 4] = [__v_7, __v_8, __v_11, __v_12]; let __mq = record.memory_queries.get_mut(&4).ok_or(ExecError::InvalidMemorySize(4))?; if let Some(result) = __mq.get_mut(&__values[..]) { if !unconstrained { *result.multiplicity += G::ONE; } result.output[0] } else { let __ptr = G::from_usize(__mq.len()); __mq.insert(&__values[..], &[__ptr], G::from_bool(!unconstrained)); __ptr } }; - let __ret: [G; OUT_360] = [__v_13]; - if let Some(result) = record.function_queries[360].get_mut(&inp[..]) { debug_assert_eq!(result.output, &__ret[..]); if !unconstrained { *result.multiplicity += G::ONE; } } else { record.function_queries[360].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained)); }; + let __ret: [G; OUT_356] = [__v_13]; + if let Some(result) = record.function_queries[356].get_mut(&inp[..]) { debug_assert_eq!(result.output, &__ret[..]); if !unconstrained { *result.multiplicity += G::ONE; } } else { record.function_queries[356].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained)); }; return Ok(__ret); }, 5u64 => { let __v_7: G = G::from_u64(5); - let __r_arr: [G; OUT_359] = { let __args: [G; IN_359] = [__v_4, __v_1, __v_2]; let __cu = unconstrained; if let Some(result) = record.function_queries[359].get_mut(&__args[..]) { if !__cu && *result.multiplicity == G::ZERO { aiur_fn_359(__args, record, io_buffer, false)? } else { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_359] = unsafe { *(result.output.as_ptr() as *const [G; OUT_359]) }; __ret } } else { aiur_fn_359(__args, record, io_buffer, __cu)? } }; + let __r_arr: [G; OUT_355] = { let __args: [G; IN_355] = [__v_4, __v_1, __v_2]; let __cu = unconstrained; if let Some(result) = record.function_queries[355].get_mut(&__args[..]) { if !__cu && *result.multiplicity == G::ZERO { aiur_fn_355(__args, record, io_buffer, false)? } else { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_355] = unsafe { *(result.output.as_ptr() as *const [G; OUT_355]) }; __ret } } else { aiur_fn_355(__args, record, io_buffer, __cu)? } }; let __v_8: G = __r_arr[0]; let __v_9: G = G::from_u64(1); let __v_10: G = (__v_2 + __v_9); - let __r_arr: [G; OUT_359] = { let __args: [G; IN_359] = [__v_5, __v_1, __v_10]; let __cu = unconstrained; if let Some(result) = record.function_queries[359].get_mut(&__args[..]) { if !__cu && *result.multiplicity == G::ZERO { aiur_fn_359(__args, record, io_buffer, false)? } else { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_359] = unsafe { *(result.output.as_ptr() as *const [G; OUT_359]) }; __ret } } else { aiur_fn_359(__args, record, io_buffer, __cu)? } }; + let __r_arr: [G; OUT_355] = { let __args: [G; IN_355] = [__v_5, __v_1, __v_10]; let __cu = unconstrained; if let Some(result) = record.function_queries[355].get_mut(&__args[..]) { if !__cu && *result.multiplicity == G::ZERO { aiur_fn_355(__args, record, io_buffer, false)? } else { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_355] = unsafe { *(result.output.as_ptr() as *const [G; OUT_355]) }; __ret } } else { aiur_fn_355(__args, record, io_buffer, __cu)? } }; let __v_11: G = __r_arr[0]; let __v_12: G = G::from_u64(0); let __v_13: G = { let __values: [G; 4] = [__v_7, __v_8, __v_11, __v_12]; let __mq = record.memory_queries.get_mut(&4).ok_or(ExecError::InvalidMemorySize(4))?; if let Some(result) = __mq.get_mut(&__values[..]) { if !unconstrained { *result.multiplicity += G::ONE; } result.output[0] } else { let __ptr = G::from_usize(__mq.len()); __mq.insert(&__values[..], &[__ptr], G::from_bool(!unconstrained)); __ptr } }; - let __ret: [G; OUT_360] = [__v_13]; - if let Some(result) = record.function_queries[360].get_mut(&inp[..]) { debug_assert_eq!(result.output, &__ret[..]); if !unconstrained { *result.multiplicity += G::ONE; } } else { record.function_queries[360].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained)); }; + let __ret: [G; OUT_356] = [__v_13]; + if let Some(result) = record.function_queries[356].get_mut(&inp[..]) { debug_assert_eq!(result.output, &__ret[..]); if !unconstrained { *result.multiplicity += G::ONE; } } else { record.function_queries[356].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained)); }; return Ok(__ret); }, 6u64 => { - let __r_arr: [G; OUT_362] = { let __args: [G; IN_362] = [__v_4, __v_5, __v_6, __v_1, __v_2]; let __cu = unconstrained; if let Some(result) = record.function_queries[362].get_mut(&__args[..]) { if !__cu && *result.multiplicity == G::ZERO { aiur_fn_362(__args, record, io_buffer, false)? } else { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_362] = unsafe { *(result.output.as_ptr() as *const [G; OUT_362]) }; __ret } } else { aiur_fn_362(__args, record, io_buffer, __cu)? } }; + let __r_arr: [G; OUT_358] = { let __args: [G; IN_358] = [__v_4, __v_5, __v_6, __v_1, __v_2]; let __cu = unconstrained; if let Some(result) = record.function_queries[358].get_mut(&__args[..]) { if !__cu && *result.multiplicity == G::ZERO { aiur_fn_358(__args, record, io_buffer, false)? } else { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_358] = unsafe { *(result.output.as_ptr() as *const [G; OUT_358]) }; __ret } } else { aiur_fn_358(__args, record, io_buffer, __cu)? } }; let __v_7: G = __r_arr[0]; - let __ret: [G; OUT_360] = [__v_7]; - if let Some(result) = record.function_queries[360].get_mut(&inp[..]) { debug_assert_eq!(result.output, &__ret[..]); if !unconstrained { *result.multiplicity += G::ONE; } } else { record.function_queries[360].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained)); }; + let __ret: [G; OUT_356] = [__v_7]; + if let Some(result) = record.function_queries[356].get_mut(&inp[..]) { debug_assert_eq!(result.output, &__ret[..]); if !unconstrained { *result.multiplicity += G::ONE; } } else { record.function_queries[356].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained)); }; return Ok(__ret); }, 7u64 => { let __v_7: G = G::from_u64(7); let __v_8: G = G::from_u64(0); let __v_9: G = { let __values: [G; 4] = [__v_7, __v_4, __v_5, __v_8]; let __mq = record.memory_queries.get_mut(&4).ok_or(ExecError::InvalidMemorySize(4))?; if let Some(result) = __mq.get_mut(&__values[..]) { if !unconstrained { *result.multiplicity += G::ONE; } result.output[0] } else { let __ptr = G::from_usize(__mq.len()); __mq.insert(&__values[..], &[__ptr], G::from_bool(!unconstrained)); __ptr } }; - let __ret: [G; OUT_360] = [__v_9]; - if let Some(result) = record.function_queries[360].get_mut(&inp[..]) { debug_assert_eq!(result.output, &__ret[..]); if !unconstrained { *result.multiplicity += G::ONE; } } else { record.function_queries[360].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained)); }; + let __ret: [G; OUT_356] = [__v_9]; + if let Some(result) = record.function_queries[356].get_mut(&inp[..]) { debug_assert_eq!(result.output, &__ret[..]); if !unconstrained { *result.multiplicity += G::ONE; } } else { record.function_queries[356].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained)); }; return Ok(__ret); }, 8u64 => { let __v_7: G = G::from_u64(8); - let __r_arr: [G; OUT_359] = { let __args: [G; IN_359] = [__v_6, __v_1, __v_2]; let __cu = unconstrained; if let Some(result) = record.function_queries[359].get_mut(&__args[..]) { if !__cu && *result.multiplicity == G::ZERO { aiur_fn_359(__args, record, io_buffer, false)? } else { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_359] = unsafe { *(result.output.as_ptr() as *const [G; OUT_359]) }; __ret } } else { aiur_fn_359(__args, record, io_buffer, __cu)? } }; + let __r_arr: [G; OUT_355] = { let __args: [G; IN_355] = [__v_6, __v_1, __v_2]; let __cu = unconstrained; if let Some(result) = record.function_queries[355].get_mut(&__args[..]) { if !__cu && *result.multiplicity == G::ZERO { aiur_fn_355(__args, record, io_buffer, false)? } else { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_355] = unsafe { *(result.output.as_ptr() as *const [G; OUT_355]) }; __ret } } else { aiur_fn_355(__args, record, io_buffer, __cu)? } }; let __v_8: G = __r_arr[0]; let __v_9: G = { let __values: [G; 4] = [__v_7, __v_4, __v_5, __v_8]; let __mq = record.memory_queries.get_mut(&4).ok_or(ExecError::InvalidMemorySize(4))?; if let Some(result) = __mq.get_mut(&__values[..]) { if !unconstrained { *result.multiplicity += G::ONE; } result.output[0] } else { let __ptr = G::from_usize(__mq.len()); __mq.insert(&__values[..], &[__ptr], G::from_bool(!unconstrained)); __ptr } }; - let __ret: [G; OUT_360] = [__v_9]; - if let Some(result) = record.function_queries[360].get_mut(&inp[..]) { debug_assert_eq!(result.output, &__ret[..]); if !unconstrained { *result.multiplicity += G::ONE; } } else { record.function_queries[360].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained)); }; + let __ret: [G; OUT_356] = [__v_9]; + if let Some(result) = record.function_queries[356].get_mut(&inp[..]) { debug_assert_eq!(result.output, &__ret[..]); if !unconstrained { *result.multiplicity += G::ONE; } } else { record.function_queries[356].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained)); }; return Ok(__ret); }, _ => { @@ -32779,15 +32505,15 @@ fn aiur_fn_360( }) } -const INPUT_SIZE_361: usize = 3; -const IN_361: usize = 3; -const OUT_361: usize = 1; -fn aiur_fn_361( - inp: [G; IN_361], +const INPUT_SIZE_357: usize = 3; +const IN_357: usize = 3; +const OUT_357: usize = 1; +fn aiur_fn_357( + inp: [G; IN_357], record: &mut QueryRecord, io_buffer: &mut IOBuffer, unconstrained: bool, -) -> Result<[G; OUT_361], ExecError> { +) -> Result<[G; OUT_357], ExecError> { stacker::maybe_grow(64 * 1024, 4 * 1024 * 1024, || { let __v_0: G = inp[0]; let __v_1: G = inp[1]; @@ -32798,8 +32524,8 @@ fn aiur_fn_361( let __v_4: G = G::from_u64(0); let __v_5: G = G::from_u64(0); let __v_6: G = { let __values: [G; 4] = [__v_4, __v_0, __v_5, __v_5]; let __mq = record.memory_queries.get_mut(&4).ok_or(ExecError::InvalidMemorySize(4))?; if let Some(result) = __mq.get_mut(&__values[..]) { if !unconstrained { *result.multiplicity += G::ONE; } result.output[0] } else { let __ptr = G::from_usize(__mq.len()); __mq.insert(&__values[..], &[__ptr], G::from_bool(!unconstrained)); __ptr } }; - let __ret: [G; OUT_361] = [__v_6]; - if let Some(result) = record.function_queries[361].get_mut(&inp[..]) { debug_assert_eq!(result.output, &__ret[..]); if !unconstrained { *result.multiplicity += G::ONE; } } else { record.function_queries[361].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained)); }; + let __ret: [G; OUT_357] = [__v_6]; + if let Some(result) = record.function_queries[357].get_mut(&inp[..]) { debug_assert_eq!(result.output, &__ret[..]); if !unconstrained { *result.multiplicity += G::ONE; } } else { record.function_queries[357].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained)); }; return Ok(__ret); }, 0u64 => { @@ -32807,8 +32533,8 @@ fn aiur_fn_361( let __v_5: G = (__v_0 + __v_1); let __v_6: G = G::from_u64(0); let __v_7: G = { let __values: [G; 4] = [__v_4, __v_5, __v_6, __v_6]; let __mq = record.memory_queries.get_mut(&4).ok_or(ExecError::InvalidMemorySize(4))?; if let Some(result) = __mq.get_mut(&__values[..]) { if !unconstrained { *result.multiplicity += G::ONE; } result.output[0] } else { let __ptr = G::from_usize(__mq.len()); __mq.insert(&__values[..], &[__ptr], G::from_bool(!unconstrained)); __ptr } }; - let __ret: [G; OUT_361] = [__v_7]; - if let Some(result) = record.function_queries[361].get_mut(&inp[..]) { debug_assert_eq!(result.output, &__ret[..]); if !unconstrained { *result.multiplicity += G::ONE; } } else { record.function_queries[361].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained)); }; + let __ret: [G; OUT_357] = [__v_7]; + if let Some(result) = record.function_queries[357].get_mut(&inp[..]) { debug_assert_eq!(result.output, &__ret[..]); if !unconstrained { *result.multiplicity += G::ONE; } } else { record.function_queries[357].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained)); }; return Ok(__ret); }, _ => { @@ -32818,15 +32544,15 @@ fn aiur_fn_361( }) } -const INPUT_SIZE_362: usize = 5; -const IN_362: usize = 5; -const OUT_362: usize = 1; -fn aiur_fn_362( - inp: [G; IN_362], +const INPUT_SIZE_358: usize = 5; +const IN_358: usize = 5; +const OUT_358: usize = 1; +fn aiur_fn_358( + inp: [G; IN_358], record: &mut QueryRecord, io_buffer: &mut IOBuffer, unconstrained: bool, -) -> Result<[G; OUT_362], ExecError> { +) -> Result<[G; OUT_358], ExecError> { stacker::maybe_grow(64 * 1024, 4 * 1024 * 1024, || { let __v_0: G = inp[0]; let __v_1: G = inp[1]; @@ -32834,56 +32560,56 @@ fn aiur_fn_362( let __v_3: G = inp[3]; let __v_4: G = inp[4]; let __v_5: G = G::from_u64(6); - let __r_arr: [G; OUT_359] = { let __args: [G; IN_359] = [__v_0, __v_3, __v_4]; let __cu = unconstrained; if let Some(result) = record.function_queries[359].get_mut(&__args[..]) { if !__cu && *result.multiplicity == G::ZERO { aiur_fn_359(__args, record, io_buffer, false)? } else { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_359] = unsafe { *(result.output.as_ptr() as *const [G; OUT_359]) }; __ret } } else { aiur_fn_359(__args, record, io_buffer, __cu)? } }; + let __r_arr: [G; OUT_355] = { let __args: [G; IN_355] = [__v_0, __v_3, __v_4]; let __cu = unconstrained; if let Some(result) = record.function_queries[355].get_mut(&__args[..]) { if !__cu && *result.multiplicity == G::ZERO { aiur_fn_355(__args, record, io_buffer, false)? } else { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_355] = unsafe { *(result.output.as_ptr() as *const [G; OUT_355]) }; __ret } } else { aiur_fn_355(__args, record, io_buffer, __cu)? } }; let __v_6: G = __r_arr[0]; - let __r_arr: [G; OUT_359] = { let __args: [G; IN_359] = [__v_1, __v_3, __v_4]; let __cu = unconstrained; if let Some(result) = record.function_queries[359].get_mut(&__args[..]) { if !__cu && *result.multiplicity == G::ZERO { aiur_fn_359(__args, record, io_buffer, false)? } else { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_359] = unsafe { *(result.output.as_ptr() as *const [G; OUT_359]) }; __ret } } else { aiur_fn_359(__args, record, io_buffer, __cu)? } }; + let __r_arr: [G; OUT_355] = { let __args: [G; IN_355] = [__v_1, __v_3, __v_4]; let __cu = unconstrained; if let Some(result) = record.function_queries[355].get_mut(&__args[..]) { if !__cu && *result.multiplicity == G::ZERO { aiur_fn_355(__args, record, io_buffer, false)? } else { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_355] = unsafe { *(result.output.as_ptr() as *const [G; OUT_355]) }; __ret } } else { aiur_fn_355(__args, record, io_buffer, __cu)? } }; let __v_7: G = __r_arr[0]; let __v_8: G = G::from_u64(1); let __v_9: G = (__v_4 + __v_8); - let __r_arr: [G; OUT_359] = { let __args: [G; IN_359] = [__v_2, __v_3, __v_9]; let __cu = unconstrained; if let Some(result) = record.function_queries[359].get_mut(&__args[..]) { if !__cu && *result.multiplicity == G::ZERO { aiur_fn_359(__args, record, io_buffer, false)? } else { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_359] = unsafe { *(result.output.as_ptr() as *const [G; OUT_359]) }; __ret } } else { aiur_fn_359(__args, record, io_buffer, __cu)? } }; + let __r_arr: [G; OUT_355] = { let __args: [G; IN_355] = [__v_2, __v_3, __v_9]; let __cu = unconstrained; if let Some(result) = record.function_queries[355].get_mut(&__args[..]) { if !__cu && *result.multiplicity == G::ZERO { aiur_fn_355(__args, record, io_buffer, false)? } else { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_355] = unsafe { *(result.output.as_ptr() as *const [G; OUT_355]) }; __ret } } else { aiur_fn_355(__args, record, io_buffer, __cu)? } }; let __v_10: G = __r_arr[0]; let __v_11: G = { let __values: [G; 4] = [__v_5, __v_6, __v_7, __v_10]; let __mq = record.memory_queries.get_mut(&4).ok_or(ExecError::InvalidMemorySize(4))?; if let Some(result) = __mq.get_mut(&__values[..]) { if !unconstrained { *result.multiplicity += G::ONE; } result.output[0] } else { let __ptr = G::from_usize(__mq.len()); __mq.insert(&__values[..], &[__ptr], G::from_bool(!unconstrained)); __ptr } }; - let __ret: [G; OUT_362] = [__v_11]; - if let Some(result) = record.function_queries[362].get_mut(&inp[..]) { debug_assert_eq!(result.output, &__ret[..]); if !unconstrained { *result.multiplicity += G::ONE; } } else { record.function_queries[362].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained)); }; + let __ret: [G; OUT_358] = [__v_11]; + if let Some(result) = record.function_queries[358].get_mut(&inp[..]) { debug_assert_eq!(result.output, &__ret[..]); if !unconstrained { *result.multiplicity += G::ONE; } } else { record.function_queries[358].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained)); }; return Ok(__ret); }) } -const INPUT_SIZE_363: usize = 3; -const IN_363: usize = 3; -const OUT_363: usize = 1; -fn aiur_fn_363( - inp: [G; IN_363], +const INPUT_SIZE_359: usize = 3; +const IN_359: usize = 3; +const OUT_359: usize = 1; +fn aiur_fn_359( + inp: [G; IN_359], record: &mut QueryRecord, io_buffer: &mut IOBuffer, unconstrained: bool, -) -> Result<[G; OUT_363], ExecError> { +) -> Result<[G; OUT_359], ExecError> { stacker::maybe_grow(64 * 1024, 4 * 1024 * 1024, || { let __v_0: G = inp[0]; let __v_1: G = inp[1]; let __v_2: G = inp[2]; match __v_1.as_canonical_u64() { 0u64 => { - let __ret: [G; OUT_363] = [__v_0]; - if let Some(result) = record.function_queries[363].get_mut(&inp[..]) { debug_assert_eq!(result.output, &__ret[..]); if !unconstrained { *result.multiplicity += G::ONE; } } else { record.function_queries[363].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained)); }; + let __ret: [G; OUT_359] = [__v_0]; + if let Some(result) = record.function_queries[359].get_mut(&inp[..]) { debug_assert_eq!(result.output, &__ret[..]); if !unconstrained { *result.multiplicity += G::ONE; } } else { record.function_queries[359].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained)); }; return Ok(__ret); }, _ => { - let __r_arr: [G; OUT_341] = { let __args: [G; IN_341] = [__v_0]; let __cu = unconstrained; if let Some(result) = record.function_queries[341].get_mut(&__args[..]) { if !__cu && *result.multiplicity == G::ZERO { aiur_fn_341(__args, record, io_buffer, false)? } else { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_341] = unsafe { *(result.output.as_ptr() as *const [G; OUT_341]) }; __ret } } else { aiur_fn_341(__args, record, io_buffer, __cu)? } }; + let __r_arr: [G; OUT_337] = { let __args: [G; IN_337] = [__v_0]; let __cu = unconstrained; if let Some(result) = record.function_queries[337].get_mut(&__args[..]) { if !__cu && *result.multiplicity == G::ZERO { aiur_fn_337(__args, record, io_buffer, false)? } else { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_337] = unsafe { *(result.output.as_ptr() as *const [G; OUT_337]) }; __ret } } else { aiur_fn_337(__args, record, io_buffer, __cu)? } }; let __v_3: G = __r_arr[0]; - let __r_arr: [G; OUT_346] = { let __args: [G; IN_346] = [__v_2, __v_3]; let __cu = unconstrained; if let Some(result) = record.function_queries[346].get_mut(&__args[..]) { if !__cu && *result.multiplicity == G::ZERO { aiur_fn_346(__args, record, io_buffer, false)? } else { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_346] = unsafe { *(result.output.as_ptr() as *const [G; OUT_346]) }; __ret } } else { aiur_fn_346(__args, record, io_buffer, __cu)? } }; + let __r_arr: [G; OUT_342] = { let __args: [G; IN_342] = [__v_2, __v_3]; let __cu = unconstrained; if let Some(result) = record.function_queries[342].get_mut(&__args[..]) { if !__cu && *result.multiplicity == G::ZERO { aiur_fn_342(__args, record, io_buffer, false)? } else { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_342] = unsafe { *(result.output.as_ptr() as *const [G; OUT_342]) }; __ret } } else { aiur_fn_342(__args, record, io_buffer, __cu)? } }; let __v_4: G = __r_arr[0]; match __v_4.as_canonical_u64() { 0u64 => { - let __ret: [G; OUT_363] = [__v_0]; - if let Some(result) = record.function_queries[363].get_mut(&inp[..]) { debug_assert_eq!(result.output, &__ret[..]); if !unconstrained { *result.multiplicity += G::ONE; } } else { record.function_queries[363].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained)); }; + let __ret: [G; OUT_359] = [__v_0]; + if let Some(result) = record.function_queries[359].get_mut(&inp[..]) { debug_assert_eq!(result.output, &__ret[..]); if !unconstrained { *result.multiplicity += G::ONE; } } else { record.function_queries[359].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained)); }; return Ok(__ret); }, 1u64 => { - let __r_arr: [G; OUT_364] = { let __args: [G; IN_364] = [__v_0, __v_1, __v_2]; let __cu = unconstrained; if let Some(result) = record.function_queries[364].get_mut(&__args[..]) { if !__cu && *result.multiplicity == G::ZERO { aiur_fn_364(__args, record, io_buffer, false)? } else { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_364] = unsafe { *(result.output.as_ptr() as *const [G; OUT_364]) }; __ret } } else { aiur_fn_364(__args, record, io_buffer, __cu)? } }; + let __r_arr: [G; OUT_360] = { let __args: [G; IN_360] = [__v_0, __v_1, __v_2]; let __cu = unconstrained; if let Some(result) = record.function_queries[360].get_mut(&__args[..]) { if !__cu && *result.multiplicity == G::ZERO { aiur_fn_360(__args, record, io_buffer, false)? } else { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_360] = unsafe { *(result.output.as_ptr() as *const [G; OUT_360]) }; __ret } } else { aiur_fn_360(__args, record, io_buffer, __cu)? } }; let __v_5: G = __r_arr[0]; - let __ret: [G; OUT_363] = [__v_5]; - if let Some(result) = record.function_queries[363].get_mut(&inp[..]) { debug_assert_eq!(result.output, &__ret[..]); if !unconstrained { *result.multiplicity += G::ONE; } } else { record.function_queries[363].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained)); }; + let __ret: [G; OUT_359] = [__v_5]; + if let Some(result) = record.function_queries[359].get_mut(&inp[..]) { debug_assert_eq!(result.output, &__ret[..]); if !unconstrained { *result.multiplicity += G::ONE; } } else { record.function_queries[359].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained)); }; return Ok(__ret); }, _ => { @@ -32895,15 +32621,15 @@ fn aiur_fn_363( }) } -const INPUT_SIZE_364: usize = 3; -const IN_364: usize = 3; -const OUT_364: usize = 1; -fn aiur_fn_364( - inp: [G; IN_364], +const INPUT_SIZE_360: usize = 3; +const IN_360: usize = 3; +const OUT_360: usize = 1; +fn aiur_fn_360( + inp: [G; IN_360], record: &mut QueryRecord, io_buffer: &mut IOBuffer, unconstrained: bool, -) -> Result<[G; OUT_364], ExecError> { +) -> Result<[G; OUT_360], ExecError> { stacker::maybe_grow(64 * 1024, 4 * 1024 * 1024, || { let __v_0: G = inp[0]; let __v_1: G = inp[1]; @@ -32918,8 +32644,8 @@ fn aiur_fn_364( let __v_7: G = { let __a_val = __v_4.as_canonical_u64(); let __b_val = __v_2.as_canonical_u64(); let __a_u32 = u32::try_from(__a_val).ok().ok_or(ExecError::U32OutOfRange(__a_val))?; let __b_u32 = u32::try_from(__b_val).ok().ok_or(ExecError::U32OutOfRange(__b_val))?; let __result = G::from_bool(__a_u32 < __b_u32); if !unconstrained { let __x_bytes = __a_u32.to_le_bytes(); let __z_bytes = __b_u32.to_le_bytes(); let __c_u32 = __b_u32.wrapping_sub(__a_u32).wrapping_sub(1); let __y_bytes = __c_u32.to_le_bytes(); record.bytes2_queries.bump_range_check(&G::from_u8(__x_bytes[0]), &G::from_u8(__x_bytes[1])); record.bytes2_queries.bump_range_check(&G::from_u8(__x_bytes[2]), &G::from_u8(__x_bytes[3])); record.bytes2_queries.bump_range_check(&G::from_u8(__y_bytes[0]), &G::from_u8(__y_bytes[1])); record.bytes2_queries.bump_range_check(&G::from_u8(__y_bytes[2]), &G::from_u8(__y_bytes[3])); record.bytes2_queries.bump_range_check(&G::from_u8(__z_bytes[0]), &G::from_u8(__z_bytes[1])); record.bytes2_queries.bump_range_check(&G::from_u8(__z_bytes[2]), &G::from_u8(__z_bytes[3])); } __result }; match __v_7.as_canonical_u64() { 1u64 => { - let __ret: [G; OUT_364] = [__v_0]; - if let Some(result) = record.function_queries[364].get_mut(&inp[..]) { debug_assert_eq!(result.output, &__ret[..]); if !unconstrained { *result.multiplicity += G::ONE; } } else { record.function_queries[364].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained)); }; + let __ret: [G; OUT_360] = [__v_0]; + if let Some(result) = record.function_queries[360].get_mut(&inp[..]) { debug_assert_eq!(result.output, &__ret[..]); if !unconstrained { *result.multiplicity += G::ONE; } } else { record.function_queries[360].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained)); }; return Ok(__ret); }, 0u64 => { @@ -32927,8 +32653,8 @@ fn aiur_fn_364( let __v_9: G = (__v_4 - __v_1); let __v_10: G = G::from_u64(0); let __v_11: G = { let __values: [G; 4] = [__v_8, __v_9, __v_10, __v_10]; let __mq = record.memory_queries.get_mut(&4).ok_or(ExecError::InvalidMemorySize(4))?; if let Some(result) = __mq.get_mut(&__values[..]) { if !unconstrained { *result.multiplicity += G::ONE; } result.output[0] } else { let __ptr = G::from_usize(__mq.len()); __mq.insert(&__values[..], &[__ptr], G::from_bool(!unconstrained)); __ptr } }; - let __ret: [G; OUT_364] = [__v_11]; - if let Some(result) = record.function_queries[364].get_mut(&inp[..]) { debug_assert_eq!(result.output, &__ret[..]); if !unconstrained { *result.multiplicity += G::ONE; } } else { record.function_queries[364].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained)); }; + let __ret: [G; OUT_360] = [__v_11]; + if let Some(result) = record.function_queries[360].get_mut(&inp[..]) { debug_assert_eq!(result.output, &__ret[..]); if !unconstrained { *result.multiplicity += G::ONE; } } else { record.function_queries[360].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained)); }; return Ok(__ret); }, _ => { @@ -32940,88 +32666,88 @@ fn aiur_fn_364( let __v_7: G = G::from_u64(1); let __v_8: G = G::from_u64(0); let __v_9: G = { let __values: [G; 4] = [__v_7, __v_4, __v_8, __v_8]; let __mq = record.memory_queries.get_mut(&4).ok_or(ExecError::InvalidMemorySize(4))?; if let Some(result) = __mq.get_mut(&__values[..]) { if !unconstrained { *result.multiplicity += G::ONE; } result.output[0] } else { let __ptr = G::from_usize(__mq.len()); __mq.insert(&__values[..], &[__ptr], G::from_bool(!unconstrained)); __ptr } }; - let __ret: [G; OUT_364] = [__v_9]; - if let Some(result) = record.function_queries[364].get_mut(&inp[..]) { debug_assert_eq!(result.output, &__ret[..]); if !unconstrained { *result.multiplicity += G::ONE; } } else { record.function_queries[364].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained)); }; + let __ret: [G; OUT_360] = [__v_9]; + if let Some(result) = record.function_queries[360].get_mut(&inp[..]) { debug_assert_eq!(result.output, &__ret[..]); if !unconstrained { *result.multiplicity += G::ONE; } } else { record.function_queries[360].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained)); }; return Ok(__ret); }, 2u64 => { let __v_7: G = G::from_u64(2); let __v_8: G = G::from_u64(0); let __v_9: G = { let __values: [G; 4] = [__v_7, __v_4, __v_5, __v_8]; let __mq = record.memory_queries.get_mut(&4).ok_or(ExecError::InvalidMemorySize(4))?; if let Some(result) = __mq.get_mut(&__values[..]) { if !unconstrained { *result.multiplicity += G::ONE; } result.output[0] } else { let __ptr = G::from_usize(__mq.len()); __mq.insert(&__values[..], &[__ptr], G::from_bool(!unconstrained)); __ptr } }; - let __ret: [G; OUT_364] = [__v_9]; - if let Some(result) = record.function_queries[364].get_mut(&inp[..]) { debug_assert_eq!(result.output, &__ret[..]); if !unconstrained { *result.multiplicity += G::ONE; } } else { record.function_queries[364].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained)); }; + let __ret: [G; OUT_360] = [__v_9]; + if let Some(result) = record.function_queries[360].get_mut(&inp[..]) { debug_assert_eq!(result.output, &__ret[..]); if !unconstrained { *result.multiplicity += G::ONE; } } else { record.function_queries[360].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained)); }; return Ok(__ret); }, 3u64 => { let __v_7: G = G::from_u64(3); - let __r_arr: [G; OUT_363] = { let __args: [G; IN_363] = [__v_4, __v_1, __v_2]; let __cu = unconstrained; if let Some(result) = record.function_queries[363].get_mut(&__args[..]) { if !__cu && *result.multiplicity == G::ZERO { aiur_fn_363(__args, record, io_buffer, false)? } else { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_363] = unsafe { *(result.output.as_ptr() as *const [G; OUT_363]) }; __ret } } else { aiur_fn_363(__args, record, io_buffer, __cu)? } }; + let __r_arr: [G; OUT_359] = { let __args: [G; IN_359] = [__v_4, __v_1, __v_2]; let __cu = unconstrained; if let Some(result) = record.function_queries[359].get_mut(&__args[..]) { if !__cu && *result.multiplicity == G::ZERO { aiur_fn_359(__args, record, io_buffer, false)? } else { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_359] = unsafe { *(result.output.as_ptr() as *const [G; OUT_359]) }; __ret } } else { aiur_fn_359(__args, record, io_buffer, __cu)? } }; let __v_8: G = __r_arr[0]; - let __r_arr: [G; OUT_363] = { let __args: [G; IN_363] = [__v_5, __v_1, __v_2]; let __cu = unconstrained; if let Some(result) = record.function_queries[363].get_mut(&__args[..]) { if !__cu && *result.multiplicity == G::ZERO { aiur_fn_363(__args, record, io_buffer, false)? } else { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_363] = unsafe { *(result.output.as_ptr() as *const [G; OUT_363]) }; __ret } } else { aiur_fn_363(__args, record, io_buffer, __cu)? } }; + let __r_arr: [G; OUT_359] = { let __args: [G; IN_359] = [__v_5, __v_1, __v_2]; let __cu = unconstrained; if let Some(result) = record.function_queries[359].get_mut(&__args[..]) { if !__cu && *result.multiplicity == G::ZERO { aiur_fn_359(__args, record, io_buffer, false)? } else { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_359] = unsafe { *(result.output.as_ptr() as *const [G; OUT_359]) }; __ret } } else { aiur_fn_359(__args, record, io_buffer, __cu)? } }; let __v_9: G = __r_arr[0]; let __v_10: G = G::from_u64(0); let __v_11: G = { let __values: [G; 4] = [__v_7, __v_8, __v_9, __v_10]; let __mq = record.memory_queries.get_mut(&4).ok_or(ExecError::InvalidMemorySize(4))?; if let Some(result) = __mq.get_mut(&__values[..]) { if !unconstrained { *result.multiplicity += G::ONE; } result.output[0] } else { let __ptr = G::from_usize(__mq.len()); __mq.insert(&__values[..], &[__ptr], G::from_bool(!unconstrained)); __ptr } }; - let __ret: [G; OUT_364] = [__v_11]; - if let Some(result) = record.function_queries[364].get_mut(&inp[..]) { debug_assert_eq!(result.output, &__ret[..]); if !unconstrained { *result.multiplicity += G::ONE; } } else { record.function_queries[364].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained)); }; + let __ret: [G; OUT_360] = [__v_11]; + if let Some(result) = record.function_queries[360].get_mut(&inp[..]) { debug_assert_eq!(result.output, &__ret[..]); if !unconstrained { *result.multiplicity += G::ONE; } } else { record.function_queries[360].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained)); }; return Ok(__ret); }, 4u64 => { let __v_7: G = G::from_u64(4); - let __r_arr: [G; OUT_363] = { let __args: [G; IN_363] = [__v_4, __v_1, __v_2]; let __cu = unconstrained; if let Some(result) = record.function_queries[363].get_mut(&__args[..]) { if !__cu && *result.multiplicity == G::ZERO { aiur_fn_363(__args, record, io_buffer, false)? } else { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_363] = unsafe { *(result.output.as_ptr() as *const [G; OUT_363]) }; __ret } } else { aiur_fn_363(__args, record, io_buffer, __cu)? } }; + let __r_arr: [G; OUT_359] = { let __args: [G; IN_359] = [__v_4, __v_1, __v_2]; let __cu = unconstrained; if let Some(result) = record.function_queries[359].get_mut(&__args[..]) { if !__cu && *result.multiplicity == G::ZERO { aiur_fn_359(__args, record, io_buffer, false)? } else { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_359] = unsafe { *(result.output.as_ptr() as *const [G; OUT_359]) }; __ret } } else { aiur_fn_359(__args, record, io_buffer, __cu)? } }; let __v_8: G = __r_arr[0]; let __v_9: G = G::from_u64(1); let __v_10: G = (__v_2 + __v_9); - let __r_arr: [G; OUT_363] = { let __args: [G; IN_363] = [__v_5, __v_1, __v_10]; let __cu = unconstrained; if let Some(result) = record.function_queries[363].get_mut(&__args[..]) { if !__cu && *result.multiplicity == G::ZERO { aiur_fn_363(__args, record, io_buffer, false)? } else { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_363] = unsafe { *(result.output.as_ptr() as *const [G; OUT_363]) }; __ret } } else { aiur_fn_363(__args, record, io_buffer, __cu)? } }; + let __r_arr: [G; OUT_359] = { let __args: [G; IN_359] = [__v_5, __v_1, __v_10]; let __cu = unconstrained; if let Some(result) = record.function_queries[359].get_mut(&__args[..]) { if !__cu && *result.multiplicity == G::ZERO { aiur_fn_359(__args, record, io_buffer, false)? } else { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_359] = unsafe { *(result.output.as_ptr() as *const [G; OUT_359]) }; __ret } } else { aiur_fn_359(__args, record, io_buffer, __cu)? } }; let __v_11: G = __r_arr[0]; let __v_12: G = G::from_u64(0); let __v_13: G = { let __values: [G; 4] = [__v_7, __v_8, __v_11, __v_12]; let __mq = record.memory_queries.get_mut(&4).ok_or(ExecError::InvalidMemorySize(4))?; if let Some(result) = __mq.get_mut(&__values[..]) { if !unconstrained { *result.multiplicity += G::ONE; } result.output[0] } else { let __ptr = G::from_usize(__mq.len()); __mq.insert(&__values[..], &[__ptr], G::from_bool(!unconstrained)); __ptr } }; - let __ret: [G; OUT_364] = [__v_13]; - if let Some(result) = record.function_queries[364].get_mut(&inp[..]) { debug_assert_eq!(result.output, &__ret[..]); if !unconstrained { *result.multiplicity += G::ONE; } } else { record.function_queries[364].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained)); }; + let __ret: [G; OUT_360] = [__v_13]; + if let Some(result) = record.function_queries[360].get_mut(&inp[..]) { debug_assert_eq!(result.output, &__ret[..]); if !unconstrained { *result.multiplicity += G::ONE; } } else { record.function_queries[360].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained)); }; return Ok(__ret); }, 5u64 => { let __v_7: G = G::from_u64(5); - let __r_arr: [G; OUT_363] = { let __args: [G; IN_363] = [__v_4, __v_1, __v_2]; let __cu = unconstrained; if let Some(result) = record.function_queries[363].get_mut(&__args[..]) { if !__cu && *result.multiplicity == G::ZERO { aiur_fn_363(__args, record, io_buffer, false)? } else { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_363] = unsafe { *(result.output.as_ptr() as *const [G; OUT_363]) }; __ret } } else { aiur_fn_363(__args, record, io_buffer, __cu)? } }; + let __r_arr: [G; OUT_359] = { let __args: [G; IN_359] = [__v_4, __v_1, __v_2]; let __cu = unconstrained; if let Some(result) = record.function_queries[359].get_mut(&__args[..]) { if !__cu && *result.multiplicity == G::ZERO { aiur_fn_359(__args, record, io_buffer, false)? } else { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_359] = unsafe { *(result.output.as_ptr() as *const [G; OUT_359]) }; __ret } } else { aiur_fn_359(__args, record, io_buffer, __cu)? } }; let __v_8: G = __r_arr[0]; let __v_9: G = G::from_u64(1); let __v_10: G = (__v_2 + __v_9); - let __r_arr: [G; OUT_363] = { let __args: [G; IN_363] = [__v_5, __v_1, __v_10]; let __cu = unconstrained; if let Some(result) = record.function_queries[363].get_mut(&__args[..]) { if !__cu && *result.multiplicity == G::ZERO { aiur_fn_363(__args, record, io_buffer, false)? } else { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_363] = unsafe { *(result.output.as_ptr() as *const [G; OUT_363]) }; __ret } } else { aiur_fn_363(__args, record, io_buffer, __cu)? } }; + let __r_arr: [G; OUT_359] = { let __args: [G; IN_359] = [__v_5, __v_1, __v_10]; let __cu = unconstrained; if let Some(result) = record.function_queries[359].get_mut(&__args[..]) { if !__cu && *result.multiplicity == G::ZERO { aiur_fn_359(__args, record, io_buffer, false)? } else { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_359] = unsafe { *(result.output.as_ptr() as *const [G; OUT_359]) }; __ret } } else { aiur_fn_359(__args, record, io_buffer, __cu)? } }; let __v_11: G = __r_arr[0]; let __v_12: G = G::from_u64(0); let __v_13: G = { let __values: [G; 4] = [__v_7, __v_8, __v_11, __v_12]; let __mq = record.memory_queries.get_mut(&4).ok_or(ExecError::InvalidMemorySize(4))?; if let Some(result) = __mq.get_mut(&__values[..]) { if !unconstrained { *result.multiplicity += G::ONE; } result.output[0] } else { let __ptr = G::from_usize(__mq.len()); __mq.insert(&__values[..], &[__ptr], G::from_bool(!unconstrained)); __ptr } }; - let __ret: [G; OUT_364] = [__v_13]; - if let Some(result) = record.function_queries[364].get_mut(&inp[..]) { debug_assert_eq!(result.output, &__ret[..]); if !unconstrained { *result.multiplicity += G::ONE; } } else { record.function_queries[364].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained)); }; + let __ret: [G; OUT_360] = [__v_13]; + if let Some(result) = record.function_queries[360].get_mut(&inp[..]) { debug_assert_eq!(result.output, &__ret[..]); if !unconstrained { *result.multiplicity += G::ONE; } } else { record.function_queries[360].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained)); }; return Ok(__ret); }, 6u64 => { let __v_7: G = G::from_u64(6); - let __r_arr: [G; OUT_363] = { let __args: [G; IN_363] = [__v_4, __v_1, __v_2]; let __cu = unconstrained; if let Some(result) = record.function_queries[363].get_mut(&__args[..]) { if !__cu && *result.multiplicity == G::ZERO { aiur_fn_363(__args, record, io_buffer, false)? } else { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_363] = unsafe { *(result.output.as_ptr() as *const [G; OUT_363]) }; __ret } } else { aiur_fn_363(__args, record, io_buffer, __cu)? } }; + let __r_arr: [G; OUT_359] = { let __args: [G; IN_359] = [__v_4, __v_1, __v_2]; let __cu = unconstrained; if let Some(result) = record.function_queries[359].get_mut(&__args[..]) { if !__cu && *result.multiplicity == G::ZERO { aiur_fn_359(__args, record, io_buffer, false)? } else { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_359] = unsafe { *(result.output.as_ptr() as *const [G; OUT_359]) }; __ret } } else { aiur_fn_359(__args, record, io_buffer, __cu)? } }; let __v_8: G = __r_arr[0]; - let __r_arr: [G; OUT_363] = { let __args: [G; IN_363] = [__v_5, __v_1, __v_2]; let __cu = unconstrained; if let Some(result) = record.function_queries[363].get_mut(&__args[..]) { if !__cu && *result.multiplicity == G::ZERO { aiur_fn_363(__args, record, io_buffer, false)? } else { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_363] = unsafe { *(result.output.as_ptr() as *const [G; OUT_363]) }; __ret } } else { aiur_fn_363(__args, record, io_buffer, __cu)? } }; + let __r_arr: [G; OUT_359] = { let __args: [G; IN_359] = [__v_5, __v_1, __v_2]; let __cu = unconstrained; if let Some(result) = record.function_queries[359].get_mut(&__args[..]) { if !__cu && *result.multiplicity == G::ZERO { aiur_fn_359(__args, record, io_buffer, false)? } else { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_359] = unsafe { *(result.output.as_ptr() as *const [G; OUT_359]) }; __ret } } else { aiur_fn_359(__args, record, io_buffer, __cu)? } }; let __v_9: G = __r_arr[0]; let __v_10: G = G::from_u64(1); let __v_11: G = (__v_2 + __v_10); - let __r_arr: [G; OUT_363] = { let __args: [G; IN_363] = [__v_6, __v_1, __v_11]; let __cu = unconstrained; if let Some(result) = record.function_queries[363].get_mut(&__args[..]) { if !__cu && *result.multiplicity == G::ZERO { aiur_fn_363(__args, record, io_buffer, false)? } else { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_363] = unsafe { *(result.output.as_ptr() as *const [G; OUT_363]) }; __ret } } else { aiur_fn_363(__args, record, io_buffer, __cu)? } }; + let __r_arr: [G; OUT_359] = { let __args: [G; IN_359] = [__v_6, __v_1, __v_11]; let __cu = unconstrained; if let Some(result) = record.function_queries[359].get_mut(&__args[..]) { if !__cu && *result.multiplicity == G::ZERO { aiur_fn_359(__args, record, io_buffer, false)? } else { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_359] = unsafe { *(result.output.as_ptr() as *const [G; OUT_359]) }; __ret } } else { aiur_fn_359(__args, record, io_buffer, __cu)? } }; let __v_12: G = __r_arr[0]; let __v_13: G = { let __values: [G; 4] = [__v_7, __v_8, __v_9, __v_12]; let __mq = record.memory_queries.get_mut(&4).ok_or(ExecError::InvalidMemorySize(4))?; if let Some(result) = __mq.get_mut(&__values[..]) { if !unconstrained { *result.multiplicity += G::ONE; } result.output[0] } else { let __ptr = G::from_usize(__mq.len()); __mq.insert(&__values[..], &[__ptr], G::from_bool(!unconstrained)); __ptr } }; - let __ret: [G; OUT_364] = [__v_13]; - if let Some(result) = record.function_queries[364].get_mut(&inp[..]) { debug_assert_eq!(result.output, &__ret[..]); if !unconstrained { *result.multiplicity += G::ONE; } } else { record.function_queries[364].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained)); }; + let __ret: [G; OUT_360] = [__v_13]; + if let Some(result) = record.function_queries[360].get_mut(&inp[..]) { debug_assert_eq!(result.output, &__ret[..]); if !unconstrained { *result.multiplicity += G::ONE; } } else { record.function_queries[360].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained)); }; return Ok(__ret); }, 7u64 => { let __v_7: G = G::from_u64(7); let __v_8: G = G::from_u64(0); let __v_9: G = { let __values: [G; 4] = [__v_7, __v_4, __v_5, __v_8]; let __mq = record.memory_queries.get_mut(&4).ok_or(ExecError::InvalidMemorySize(4))?; if let Some(result) = __mq.get_mut(&__values[..]) { if !unconstrained { *result.multiplicity += G::ONE; } result.output[0] } else { let __ptr = G::from_usize(__mq.len()); __mq.insert(&__values[..], &[__ptr], G::from_bool(!unconstrained)); __ptr } }; - let __ret: [G; OUT_364] = [__v_9]; - if let Some(result) = record.function_queries[364].get_mut(&inp[..]) { debug_assert_eq!(result.output, &__ret[..]); if !unconstrained { *result.multiplicity += G::ONE; } } else { record.function_queries[364].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained)); }; + let __ret: [G; OUT_360] = [__v_9]; + if let Some(result) = record.function_queries[360].get_mut(&inp[..]) { debug_assert_eq!(result.output, &__ret[..]); if !unconstrained { *result.multiplicity += G::ONE; } } else { record.function_queries[360].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained)); }; return Ok(__ret); }, 8u64 => { let __v_7: G = G::from_u64(8); - let __r_arr: [G; OUT_363] = { let __args: [G; IN_363] = [__v_6, __v_1, __v_2]; let __cu = unconstrained; if let Some(result) = record.function_queries[363].get_mut(&__args[..]) { if !__cu && *result.multiplicity == G::ZERO { aiur_fn_363(__args, record, io_buffer, false)? } else { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_363] = unsafe { *(result.output.as_ptr() as *const [G; OUT_363]) }; __ret } } else { aiur_fn_363(__args, record, io_buffer, __cu)? } }; + let __r_arr: [G; OUT_359] = { let __args: [G; IN_359] = [__v_6, __v_1, __v_2]; let __cu = unconstrained; if let Some(result) = record.function_queries[359].get_mut(&__args[..]) { if !__cu && *result.multiplicity == G::ZERO { aiur_fn_359(__args, record, io_buffer, false)? } else { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_359] = unsafe { *(result.output.as_ptr() as *const [G; OUT_359]) }; __ret } } else { aiur_fn_359(__args, record, io_buffer, __cu)? } }; let __v_8: G = __r_arr[0]; let __v_9: G = { let __values: [G; 4] = [__v_7, __v_4, __v_5, __v_8]; let __mq = record.memory_queries.get_mut(&4).ok_or(ExecError::InvalidMemorySize(4))?; if let Some(result) = __mq.get_mut(&__values[..]) { if !unconstrained { *result.multiplicity += G::ONE; } result.output[0] } else { let __ptr = G::from_usize(__mq.len()); __mq.insert(&__values[..], &[__ptr], G::from_bool(!unconstrained)); __ptr } }; - let __ret: [G; OUT_364] = [__v_9]; - if let Some(result) = record.function_queries[364].get_mut(&inp[..]) { debug_assert_eq!(result.output, &__ret[..]); if !unconstrained { *result.multiplicity += G::ONE; } } else { record.function_queries[364].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained)); }; + let __ret: [G; OUT_360] = [__v_9]; + if let Some(result) = record.function_queries[360].get_mut(&inp[..]) { debug_assert_eq!(result.output, &__ret[..]); if !unconstrained { *result.multiplicity += G::ONE; } } else { record.function_queries[360].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained)); }; return Ok(__ret); }, _ => { @@ -33031,15 +32757,15 @@ fn aiur_fn_364( }) } -const INPUT_SIZE_365: usize = 2; -const IN_365: usize = 2; -const OUT_365: usize = 1; -fn aiur_fn_365( - inp: [G; IN_365], +const INPUT_SIZE_361: usize = 2; +const IN_361: usize = 2; +const OUT_361: usize = 1; +fn aiur_fn_361( + inp: [G; IN_361], record: &mut QueryRecord, io_buffer: &mut IOBuffer, unconstrained: bool, -) -> Result<[G; OUT_365], ExecError> { +) -> Result<[G; OUT_361], ExecError> { stacker::maybe_grow(64 * 1024, 4 * 1024 * 1024, || { let __v_0: G = inp[0]; let __v_1: G = inp[1]; @@ -33054,150 +32780,150 @@ fn aiur_fn_365( match __v_6.as_canonical_u64() { 0u64 => { let __v_7: G = G::from_u64(1); - let __ret: [G; OUT_365] = [__v_7]; - if let Some(result) = record.function_queries[365].get_mut(&inp[..]) { debug_assert_eq!(result.output, &__ret[..]); if !unconstrained { *result.multiplicity += G::ONE; } } else { record.function_queries[365].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained)); }; + let __ret: [G; OUT_361] = [__v_7]; + if let Some(result) = record.function_queries[361].get_mut(&inp[..]) { debug_assert_eq!(result.output, &__ret[..]); if !unconstrained { *result.multiplicity += G::ONE; } } else { record.function_queries[361].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained)); }; return Ok(__ret); }, _ => { let __v_7: G = G::from_u64(0); - let __ret: [G; OUT_365] = [__v_7]; - if let Some(result) = record.function_queries[365].get_mut(&inp[..]) { debug_assert_eq!(result.output, &__ret[..]); if !unconstrained { *result.multiplicity += G::ONE; } } else { record.function_queries[365].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained)); }; + let __ret: [G; OUT_361] = [__v_7]; + if let Some(result) = record.function_queries[361].get_mut(&inp[..]) { debug_assert_eq!(result.output, &__ret[..]); if !unconstrained { *result.multiplicity += G::ONE; } } else { record.function_queries[361].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained)); }; return Ok(__ret); }, } }, 3u64 => { - let __r_arr: [G; OUT_365] = { let __args: [G; IN_365] = [__v_3, __v_1]; let __cu = unconstrained; if let Some(result) = record.function_queries[365].get_mut(&__args[..]) { if !__cu && *result.multiplicity == G::ZERO { aiur_fn_365(__args, record, io_buffer, false)? } else { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_365] = unsafe { *(result.output.as_ptr() as *const [G; OUT_365]) }; __ret } } else { aiur_fn_365(__args, record, io_buffer, __cu)? } }; + let __r_arr: [G; OUT_361] = { let __args: [G; IN_361] = [__v_3, __v_1]; let __cu = unconstrained; if let Some(result) = record.function_queries[361].get_mut(&__args[..]) { if !__cu && *result.multiplicity == G::ZERO { aiur_fn_361(__args, record, io_buffer, false)? } else { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_361] = unsafe { *(result.output.as_ptr() as *const [G; OUT_361]) }; __ret } } else { aiur_fn_361(__args, record, io_buffer, __cu)? } }; let __v_6: G = __r_arr[0]; match __v_6.as_canonical_u64() { 1u64 => { let __v_7: G = G::from_u64(1); - let __ret: [G; OUT_365] = [__v_7]; - if let Some(result) = record.function_queries[365].get_mut(&inp[..]) { debug_assert_eq!(result.output, &__ret[..]); if !unconstrained { *result.multiplicity += G::ONE; } } else { record.function_queries[365].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained)); }; + let __ret: [G; OUT_361] = [__v_7]; + if let Some(result) = record.function_queries[361].get_mut(&inp[..]) { debug_assert_eq!(result.output, &__ret[..]); if !unconstrained { *result.multiplicity += G::ONE; } } else { record.function_queries[361].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained)); }; return Ok(__ret); }, _ => { - let __r_arr: [G; OUT_365] = { let __args: [G; IN_365] = [__v_4, __v_1]; let __cu = unconstrained; if let Some(result) = record.function_queries[365].get_mut(&__args[..]) { if !__cu && *result.multiplicity == G::ZERO { aiur_fn_365(__args, record, io_buffer, false)? } else { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_365] = unsafe { *(result.output.as_ptr() as *const [G; OUT_365]) }; __ret } } else { aiur_fn_365(__args, record, io_buffer, __cu)? } }; + let __r_arr: [G; OUT_361] = { let __args: [G; IN_361] = [__v_4, __v_1]; let __cu = unconstrained; if let Some(result) = record.function_queries[361].get_mut(&__args[..]) { if !__cu && *result.multiplicity == G::ZERO { aiur_fn_361(__args, record, io_buffer, false)? } else { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_361] = unsafe { *(result.output.as_ptr() as *const [G; OUT_361]) }; __ret } } else { aiur_fn_361(__args, record, io_buffer, __cu)? } }; let __v_7: G = __r_arr[0]; - let __ret: [G; OUT_365] = [__v_7]; - if let Some(result) = record.function_queries[365].get_mut(&inp[..]) { debug_assert_eq!(result.output, &__ret[..]); if !unconstrained { *result.multiplicity += G::ONE; } } else { record.function_queries[365].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained)); }; + let __ret: [G; OUT_361] = [__v_7]; + if let Some(result) = record.function_queries[361].get_mut(&inp[..]) { debug_assert_eq!(result.output, &__ret[..]); if !unconstrained { *result.multiplicity += G::ONE; } } else { record.function_queries[361].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained)); }; return Ok(__ret); }, } }, 4u64 => { - let __r_arr: [G; OUT_366] = { let __args: [G; IN_366] = [__v_3, __v_4, __v_1]; let __cu = unconstrained; if let Some(result) = record.function_queries[366].get_mut(&__args[..]) { if !__cu && *result.multiplicity == G::ZERO { aiur_fn_366(__args, record, io_buffer, false)? } else { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_366] = unsafe { *(result.output.as_ptr() as *const [G; OUT_366]) }; __ret } } else { aiur_fn_366(__args, record, io_buffer, __cu)? } }; + let __r_arr: [G; OUT_362] = { let __args: [G; IN_362] = [__v_3, __v_4, __v_1]; let __cu = unconstrained; if let Some(result) = record.function_queries[362].get_mut(&__args[..]) { if !__cu && *result.multiplicity == G::ZERO { aiur_fn_362(__args, record, io_buffer, false)? } else { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_362] = unsafe { *(result.output.as_ptr() as *const [G; OUT_362]) }; __ret } } else { aiur_fn_362(__args, record, io_buffer, __cu)? } }; let __v_6: G = __r_arr[0]; - let __ret: [G; OUT_365] = [__v_6]; - if let Some(result) = record.function_queries[365].get_mut(&inp[..]) { debug_assert_eq!(result.output, &__ret[..]); if !unconstrained { *result.multiplicity += G::ONE; } } else { record.function_queries[365].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained)); }; + let __ret: [G; OUT_361] = [__v_6]; + if let Some(result) = record.function_queries[361].get_mut(&inp[..]) { debug_assert_eq!(result.output, &__ret[..]); if !unconstrained { *result.multiplicity += G::ONE; } } else { record.function_queries[361].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained)); }; return Ok(__ret); }, 5u64 => { - let __r_arr: [G; OUT_366] = { let __args: [G; IN_366] = [__v_3, __v_4, __v_1]; let __cu = unconstrained; if let Some(result) = record.function_queries[366].get_mut(&__args[..]) { if !__cu && *result.multiplicity == G::ZERO { aiur_fn_366(__args, record, io_buffer, false)? } else { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_366] = unsafe { *(result.output.as_ptr() as *const [G; OUT_366]) }; __ret } } else { aiur_fn_366(__args, record, io_buffer, __cu)? } }; + let __r_arr: [G; OUT_362] = { let __args: [G; IN_362] = [__v_3, __v_4, __v_1]; let __cu = unconstrained; if let Some(result) = record.function_queries[362].get_mut(&__args[..]) { if !__cu && *result.multiplicity == G::ZERO { aiur_fn_362(__args, record, io_buffer, false)? } else { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_362] = unsafe { *(result.output.as_ptr() as *const [G; OUT_362]) }; __ret } } else { aiur_fn_362(__args, record, io_buffer, __cu)? } }; let __v_6: G = __r_arr[0]; - let __ret: [G; OUT_365] = [__v_6]; - if let Some(result) = record.function_queries[365].get_mut(&inp[..]) { debug_assert_eq!(result.output, &__ret[..]); if !unconstrained { *result.multiplicity += G::ONE; } } else { record.function_queries[365].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained)); }; + let __ret: [G; OUT_361] = [__v_6]; + if let Some(result) = record.function_queries[361].get_mut(&inp[..]) { debug_assert_eq!(result.output, &__ret[..]); if !unconstrained { *result.multiplicity += G::ONE; } } else { record.function_queries[361].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained)); }; return Ok(__ret); }, 6u64 => { - let __r_arr: [G; OUT_367] = { let __args: [G; IN_367] = [__v_3, __v_4, __v_5, __v_1]; let __cu = unconstrained; if let Some(result) = record.function_queries[367].get_mut(&__args[..]) { if !__cu && *result.multiplicity == G::ZERO { aiur_fn_367(__args, record, io_buffer, false)? } else { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_367] = unsafe { *(result.output.as_ptr() as *const [G; OUT_367]) }; __ret } } else { aiur_fn_367(__args, record, io_buffer, __cu)? } }; + let __r_arr: [G; OUT_363] = { let __args: [G; IN_363] = [__v_3, __v_4, __v_5, __v_1]; let __cu = unconstrained; if let Some(result) = record.function_queries[363].get_mut(&__args[..]) { if !__cu && *result.multiplicity == G::ZERO { aiur_fn_363(__args, record, io_buffer, false)? } else { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_363] = unsafe { *(result.output.as_ptr() as *const [G; OUT_363]) }; __ret } } else { aiur_fn_363(__args, record, io_buffer, __cu)? } }; let __v_6: G = __r_arr[0]; - let __ret: [G; OUT_365] = [__v_6]; - if let Some(result) = record.function_queries[365].get_mut(&inp[..]) { debug_assert_eq!(result.output, &__ret[..]); if !unconstrained { *result.multiplicity += G::ONE; } } else { record.function_queries[365].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained)); }; + let __ret: [G; OUT_361] = [__v_6]; + if let Some(result) = record.function_queries[361].get_mut(&inp[..]) { debug_assert_eq!(result.output, &__ret[..]); if !unconstrained { *result.multiplicity += G::ONE; } } else { record.function_queries[361].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained)); }; return Ok(__ret); }, 8u64 => { - let __r_arr: [G; OUT_365] = { let __args: [G; IN_365] = [__v_5, __v_1]; let __cu = unconstrained; if let Some(result) = record.function_queries[365].get_mut(&__args[..]) { if !__cu && *result.multiplicity == G::ZERO { aiur_fn_365(__args, record, io_buffer, false)? } else { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_365] = unsafe { *(result.output.as_ptr() as *const [G; OUT_365]) }; __ret } } else { aiur_fn_365(__args, record, io_buffer, __cu)? } }; + let __r_arr: [G; OUT_361] = { let __args: [G; IN_361] = [__v_5, __v_1]; let __cu = unconstrained; if let Some(result) = record.function_queries[361].get_mut(&__args[..]) { if !__cu && *result.multiplicity == G::ZERO { aiur_fn_361(__args, record, io_buffer, false)? } else { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_361] = unsafe { *(result.output.as_ptr() as *const [G; OUT_361]) }; __ret } } else { aiur_fn_361(__args, record, io_buffer, __cu)? } }; let __v_6: G = __r_arr[0]; - let __ret: [G; OUT_365] = [__v_6]; - if let Some(result) = record.function_queries[365].get_mut(&inp[..]) { debug_assert_eq!(result.output, &__ret[..]); if !unconstrained { *result.multiplicity += G::ONE; } } else { record.function_queries[365].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained)); }; + let __ret: [G; OUT_361] = [__v_6]; + if let Some(result) = record.function_queries[361].get_mut(&inp[..]) { debug_assert_eq!(result.output, &__ret[..]); if !unconstrained { *result.multiplicity += G::ONE; } } else { record.function_queries[361].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained)); }; return Ok(__ret); }, _ => { let __v_6: G = G::from_u64(0); - let __ret: [G; OUT_365] = [__v_6]; - if let Some(result) = record.function_queries[365].get_mut(&inp[..]) { debug_assert_eq!(result.output, &__ret[..]); if !unconstrained { *result.multiplicity += G::ONE; } } else { record.function_queries[365].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained)); }; + let __ret: [G; OUT_361] = [__v_6]; + if let Some(result) = record.function_queries[361].get_mut(&inp[..]) { debug_assert_eq!(result.output, &__ret[..]); if !unconstrained { *result.multiplicity += G::ONE; } } else { record.function_queries[361].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained)); }; return Ok(__ret); }, } }) } -const INPUT_SIZE_366: usize = 3; -const IN_366: usize = 3; -const OUT_366: usize = 1; -fn aiur_fn_366( - inp: [G; IN_366], +const INPUT_SIZE_362: usize = 3; +const IN_362: usize = 3; +const OUT_362: usize = 1; +fn aiur_fn_362( + inp: [G; IN_362], record: &mut QueryRecord, io_buffer: &mut IOBuffer, unconstrained: bool, -) -> Result<[G; OUT_366], ExecError> { +) -> Result<[G; OUT_362], ExecError> { stacker::maybe_grow(64 * 1024, 4 * 1024 * 1024, || { let __v_0: G = inp[0]; let __v_1: G = inp[1]; let __v_2: G = inp[2]; - let __r_arr: [G; OUT_365] = { let __args: [G; IN_365] = [__v_0, __v_2]; let __cu = unconstrained; if let Some(result) = record.function_queries[365].get_mut(&__args[..]) { if !__cu && *result.multiplicity == G::ZERO { aiur_fn_365(__args, record, io_buffer, false)? } else { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_365] = unsafe { *(result.output.as_ptr() as *const [G; OUT_365]) }; __ret } } else { aiur_fn_365(__args, record, io_buffer, __cu)? } }; + let __r_arr: [G; OUT_361] = { let __args: [G; IN_361] = [__v_0, __v_2]; let __cu = unconstrained; if let Some(result) = record.function_queries[361].get_mut(&__args[..]) { if !__cu && *result.multiplicity == G::ZERO { aiur_fn_361(__args, record, io_buffer, false)? } else { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_361] = unsafe { *(result.output.as_ptr() as *const [G; OUT_361]) }; __ret } } else { aiur_fn_361(__args, record, io_buffer, __cu)? } }; let __v_3: G = __r_arr[0]; match __v_3.as_canonical_u64() { 1u64 => { let __v_4: G = G::from_u64(1); - let __ret: [G; OUT_366] = [__v_4]; - if let Some(result) = record.function_queries[366].get_mut(&inp[..]) { debug_assert_eq!(result.output, &__ret[..]); if !unconstrained { *result.multiplicity += G::ONE; } } else { record.function_queries[366].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained)); }; + let __ret: [G; OUT_362] = [__v_4]; + if let Some(result) = record.function_queries[362].get_mut(&inp[..]) { debug_assert_eq!(result.output, &__ret[..]); if !unconstrained { *result.multiplicity += G::ONE; } } else { record.function_queries[362].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained)); }; return Ok(__ret); }, _ => { let __v_4: G = G::from_u64(1); let __v_5: G = (__v_2 + __v_4); - let __r_arr: [G; OUT_365] = { let __args: [G; IN_365] = [__v_1, __v_5]; let __cu = unconstrained; if let Some(result) = record.function_queries[365].get_mut(&__args[..]) { if !__cu && *result.multiplicity == G::ZERO { aiur_fn_365(__args, record, io_buffer, false)? } else { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_365] = unsafe { *(result.output.as_ptr() as *const [G; OUT_365]) }; __ret } } else { aiur_fn_365(__args, record, io_buffer, __cu)? } }; + let __r_arr: [G; OUT_361] = { let __args: [G; IN_361] = [__v_1, __v_5]; let __cu = unconstrained; if let Some(result) = record.function_queries[361].get_mut(&__args[..]) { if !__cu && *result.multiplicity == G::ZERO { aiur_fn_361(__args, record, io_buffer, false)? } else { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_361] = unsafe { *(result.output.as_ptr() as *const [G; OUT_361]) }; __ret } } else { aiur_fn_361(__args, record, io_buffer, __cu)? } }; let __v_6: G = __r_arr[0]; - let __ret: [G; OUT_366] = [__v_6]; - if let Some(result) = record.function_queries[366].get_mut(&inp[..]) { debug_assert_eq!(result.output, &__ret[..]); if !unconstrained { *result.multiplicity += G::ONE; } } else { record.function_queries[366].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained)); }; + let __ret: [G; OUT_362] = [__v_6]; + if let Some(result) = record.function_queries[362].get_mut(&inp[..]) { debug_assert_eq!(result.output, &__ret[..]); if !unconstrained { *result.multiplicity += G::ONE; } } else { record.function_queries[362].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained)); }; return Ok(__ret); }, } }) } -const INPUT_SIZE_367: usize = 4; -const IN_367: usize = 4; -const OUT_367: usize = 1; -fn aiur_fn_367( - inp: [G; IN_367], +const INPUT_SIZE_363: usize = 4; +const IN_363: usize = 4; +const OUT_363: usize = 1; +fn aiur_fn_363( + inp: [G; IN_363], record: &mut QueryRecord, io_buffer: &mut IOBuffer, unconstrained: bool, -) -> Result<[G; OUT_367], ExecError> { +) -> Result<[G; OUT_363], ExecError> { stacker::maybe_grow(64 * 1024, 4 * 1024 * 1024, || { let __v_0: G = inp[0]; let __v_1: G = inp[1]; let __v_2: G = inp[2]; let __v_3: G = inp[3]; - let __r_arr: [G; OUT_365] = { let __args: [G; IN_365] = [__v_0, __v_3]; let __cu = unconstrained; if let Some(result) = record.function_queries[365].get_mut(&__args[..]) { if !__cu && *result.multiplicity == G::ZERO { aiur_fn_365(__args, record, io_buffer, false)? } else { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_365] = unsafe { *(result.output.as_ptr() as *const [G; OUT_365]) }; __ret } } else { aiur_fn_365(__args, record, io_buffer, __cu)? } }; + let __r_arr: [G; OUT_361] = { let __args: [G; IN_361] = [__v_0, __v_3]; let __cu = unconstrained; if let Some(result) = record.function_queries[361].get_mut(&__args[..]) { if !__cu && *result.multiplicity == G::ZERO { aiur_fn_361(__args, record, io_buffer, false)? } else { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_361] = unsafe { *(result.output.as_ptr() as *const [G; OUT_361]) }; __ret } } else { aiur_fn_361(__args, record, io_buffer, __cu)? } }; let __v_4: G = __r_arr[0]; match __v_4.as_canonical_u64() { 1u64 => { let __v_5: G = G::from_u64(1); - let __ret: [G; OUT_367] = [__v_5]; - if let Some(result) = record.function_queries[367].get_mut(&inp[..]) { debug_assert_eq!(result.output, &__ret[..]); if !unconstrained { *result.multiplicity += G::ONE; } } else { record.function_queries[367].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained)); }; + let __ret: [G; OUT_363] = [__v_5]; + if let Some(result) = record.function_queries[363].get_mut(&inp[..]) { debug_assert_eq!(result.output, &__ret[..]); if !unconstrained { *result.multiplicity += G::ONE; } } else { record.function_queries[363].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained)); }; return Ok(__ret); }, _ => { - let __r_arr: [G; OUT_365] = { let __args: [G; IN_365] = [__v_1, __v_3]; let __cu = unconstrained; if let Some(result) = record.function_queries[365].get_mut(&__args[..]) { if !__cu && *result.multiplicity == G::ZERO { aiur_fn_365(__args, record, io_buffer, false)? } else { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_365] = unsafe { *(result.output.as_ptr() as *const [G; OUT_365]) }; __ret } } else { aiur_fn_365(__args, record, io_buffer, __cu)? } }; + let __r_arr: [G; OUT_361] = { let __args: [G; IN_361] = [__v_1, __v_3]; let __cu = unconstrained; if let Some(result) = record.function_queries[361].get_mut(&__args[..]) { if !__cu && *result.multiplicity == G::ZERO { aiur_fn_361(__args, record, io_buffer, false)? } else { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_361] = unsafe { *(result.output.as_ptr() as *const [G; OUT_361]) }; __ret } } else { aiur_fn_361(__args, record, io_buffer, __cu)? } }; let __v_5: G = __r_arr[0]; match __v_5.as_canonical_u64() { 1u64 => { let __v_6: G = G::from_u64(1); - let __ret: [G; OUT_367] = [__v_6]; - if let Some(result) = record.function_queries[367].get_mut(&inp[..]) { debug_assert_eq!(result.output, &__ret[..]); if !unconstrained { *result.multiplicity += G::ONE; } } else { record.function_queries[367].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained)); }; + let __ret: [G; OUT_363] = [__v_6]; + if let Some(result) = record.function_queries[363].get_mut(&inp[..]) { debug_assert_eq!(result.output, &__ret[..]); if !unconstrained { *result.multiplicity += G::ONE; } } else { record.function_queries[363].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained)); }; return Ok(__ret); }, _ => { let __v_6: G = G::from_u64(1); let __v_7: G = (__v_3 + __v_6); - let __r_arr: [G; OUT_365] = { let __args: [G; IN_365] = [__v_2, __v_7]; let __cu = unconstrained; if let Some(result) = record.function_queries[365].get_mut(&__args[..]) { if !__cu && *result.multiplicity == G::ZERO { aiur_fn_365(__args, record, io_buffer, false)? } else { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_365] = unsafe { *(result.output.as_ptr() as *const [G; OUT_365]) }; __ret } } else { aiur_fn_365(__args, record, io_buffer, __cu)? } }; + let __r_arr: [G; OUT_361] = { let __args: [G; IN_361] = [__v_2, __v_7]; let __cu = unconstrained; if let Some(result) = record.function_queries[361].get_mut(&__args[..]) { if !__cu && *result.multiplicity == G::ZERO { aiur_fn_361(__args, record, io_buffer, false)? } else { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_361] = unsafe { *(result.output.as_ptr() as *const [G; OUT_361]) }; __ret } } else { aiur_fn_361(__args, record, io_buffer, __cu)? } }; let __v_8: G = __r_arr[0]; - let __ret: [G; OUT_367] = [__v_8]; - if let Some(result) = record.function_queries[367].get_mut(&inp[..]) { debug_assert_eq!(result.output, &__ret[..]); if !unconstrained { *result.multiplicity += G::ONE; } } else { record.function_queries[367].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained)); }; + let __ret: [G; OUT_363] = [__v_8]; + if let Some(result) = record.function_queries[363].get_mut(&inp[..]) { debug_assert_eq!(result.output, &__ret[..]); if !unconstrained { *result.multiplicity += G::ONE; } } else { record.function_queries[363].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained)); }; return Ok(__ret); }, } @@ -33206,48 +32932,48 @@ fn aiur_fn_367( }) } -const INPUT_SIZE_368: usize = 3; -const IN_368: usize = 3; -const OUT_368: usize = 1; -fn aiur_fn_368( - inp: [G; IN_368], +const INPUT_SIZE_364: usize = 3; +const IN_364: usize = 3; +const OUT_364: usize = 1; +fn aiur_fn_364( + inp: [G; IN_364], record: &mut QueryRecord, io_buffer: &mut IOBuffer, unconstrained: bool, -) -> Result<[G; OUT_368], ExecError> { +) -> Result<[G; OUT_364], ExecError> { stacker::maybe_grow(64 * 1024, 4 * 1024 * 1024, || { let __v_0: G = inp[0]; let __v_1: G = inp[1]; let __v_2: G = inp[2]; - let __r_arr: [G; OUT_341] = { let __args: [G; IN_341] = [__v_0]; let __cu = unconstrained; if let Some(result) = record.function_queries[341].get_mut(&__args[..]) { if !__cu && *result.multiplicity == G::ZERO { aiur_fn_341(__args, record, io_buffer, false)? } else { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_341] = unsafe { *(result.output.as_ptr() as *const [G; OUT_341]) }; __ret } } else { aiur_fn_341(__args, record, io_buffer, __cu)? } }; + let __r_arr: [G; OUT_337] = { let __args: [G; IN_337] = [__v_0]; let __cu = unconstrained; if let Some(result) = record.function_queries[337].get_mut(&__args[..]) { if !__cu && *result.multiplicity == G::ZERO { aiur_fn_337(__args, record, io_buffer, false)? } else { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_337] = unsafe { *(result.output.as_ptr() as *const [G; OUT_337]) }; __ret } } else { aiur_fn_337(__args, record, io_buffer, __cu)? } }; let __v_3: G = __r_arr[0]; - let __r_arr: [G; OUT_346] = { let __args: [G; IN_346] = [__v_2, __v_3]; let __cu = unconstrained; if let Some(result) = record.function_queries[346].get_mut(&__args[..]) { if !__cu && *result.multiplicity == G::ZERO { aiur_fn_346(__args, record, io_buffer, false)? } else { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_346] = unsafe { *(result.output.as_ptr() as *const [G; OUT_346]) }; __ret } } else { aiur_fn_346(__args, record, io_buffer, __cu)? } }; + let __r_arr: [G; OUT_342] = { let __args: [G; IN_342] = [__v_2, __v_3]; let __cu = unconstrained; if let Some(result) = record.function_queries[342].get_mut(&__args[..]) { if !__cu && *result.multiplicity == G::ZERO { aiur_fn_342(__args, record, io_buffer, false)? } else { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_342] = unsafe { *(result.output.as_ptr() as *const [G; OUT_342]) }; __ret } } else { aiur_fn_342(__args, record, io_buffer, __cu)? } }; let __v_4: G = __r_arr[0]; match __v_4.as_canonical_u64() { 0u64 => { - let __ret: [G; OUT_368] = [__v_0]; - if let Some(result) = record.function_queries[368].get_mut(&inp[..]) { debug_assert_eq!(result.output, &__ret[..]); if !unconstrained { *result.multiplicity += G::ONE; } } else { record.function_queries[368].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained)); }; + let __ret: [G; OUT_364] = [__v_0]; + if let Some(result) = record.function_queries[364].get_mut(&inp[..]) { debug_assert_eq!(result.output, &__ret[..]); if !unconstrained { *result.multiplicity += G::ONE; } } else { record.function_queries[364].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained)); }; return Ok(__ret); }, 1u64 => { - let __r_arr: [G; OUT_365] = { let __args: [G; IN_365] = [__v_0, __v_2]; let __cu = unconstrained; if let Some(result) = record.function_queries[365].get_mut(&__args[..]) { if !__cu && *result.multiplicity == G::ZERO { aiur_fn_365(__args, record, io_buffer, false)? } else { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_365] = unsafe { *(result.output.as_ptr() as *const [G; OUT_365]) }; __ret } } else { aiur_fn_365(__args, record, io_buffer, __cu)? } }; + let __r_arr: [G; OUT_361] = { let __args: [G; IN_361] = [__v_0, __v_2]; let __cu = unconstrained; if let Some(result) = record.function_queries[361].get_mut(&__args[..]) { if !__cu && *result.multiplicity == G::ZERO { aiur_fn_361(__args, record, io_buffer, false)? } else { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_361] = unsafe { *(result.output.as_ptr() as *const [G; OUT_361]) }; __ret } } else { aiur_fn_361(__args, record, io_buffer, __cu)? } }; let __v_5: G = __r_arr[0]; match __v_5.as_canonical_u64() { 1u64 => { - let __r_arr: [G; OUT_369] = { let __args: [G; IN_369] = [__v_0, __v_1, __v_2]; let __cu = unconstrained; if let Some(result) = record.function_queries[369].get_mut(&__args[..]) { if !__cu && *result.multiplicity == G::ZERO { aiur_fn_369(__args, record, io_buffer, false)? } else { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_369] = unsafe { *(result.output.as_ptr() as *const [G; OUT_369]) }; __ret } } else { aiur_fn_369(__args, record, io_buffer, __cu)? } }; + let __r_arr: [G; OUT_365] = { let __args: [G; IN_365] = [__v_0, __v_1, __v_2]; let __cu = unconstrained; if let Some(result) = record.function_queries[365].get_mut(&__args[..]) { if !__cu && *result.multiplicity == G::ZERO { aiur_fn_365(__args, record, io_buffer, false)? } else { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_365] = unsafe { *(result.output.as_ptr() as *const [G; OUT_365]) }; __ret } } else { aiur_fn_365(__args, record, io_buffer, __cu)? } }; let __v_6: G = __r_arr[0]; - let __ret: [G; OUT_368] = [__v_6]; - if let Some(result) = record.function_queries[368].get_mut(&inp[..]) { debug_assert_eq!(result.output, &__ret[..]); if !unconstrained { *result.multiplicity += G::ONE; } } else { record.function_queries[368].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained)); }; + let __ret: [G; OUT_364] = [__v_6]; + if let Some(result) = record.function_queries[364].get_mut(&inp[..]) { debug_assert_eq!(result.output, &__ret[..]); if !unconstrained { *result.multiplicity += G::ONE; } } else { record.function_queries[364].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained)); }; return Ok(__ret); }, _ => { let __v_6: G = G::from_u64(1); let __v_7: G = G::from_u64(1); let __v_8: G = (__v_2 + __v_7); - let __r_arr: [G; OUT_363] = { let __args: [G; IN_363] = [__v_0, __v_6, __v_8]; let __cu = unconstrained; if let Some(result) = record.function_queries[363].get_mut(&__args[..]) { if !__cu && *result.multiplicity == G::ZERO { aiur_fn_363(__args, record, io_buffer, false)? } else { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_363] = unsafe { *(result.output.as_ptr() as *const [G; OUT_363]) }; __ret } } else { aiur_fn_363(__args, record, io_buffer, __cu)? } }; + let __r_arr: [G; OUT_359] = { let __args: [G; IN_359] = [__v_0, __v_6, __v_8]; let __cu = unconstrained; if let Some(result) = record.function_queries[359].get_mut(&__args[..]) { if !__cu && *result.multiplicity == G::ZERO { aiur_fn_359(__args, record, io_buffer, false)? } else { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_359] = unsafe { *(result.output.as_ptr() as *const [G; OUT_359]) }; __ret } } else { aiur_fn_359(__args, record, io_buffer, __cu)? } }; let __v_9: G = __r_arr[0]; - let __ret: [G; OUT_368] = [__v_9]; - if let Some(result) = record.function_queries[368].get_mut(&inp[..]) { debug_assert_eq!(result.output, &__ret[..]); if !unconstrained { *result.multiplicity += G::ONE; } } else { record.function_queries[368].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained)); }; + let __ret: [G; OUT_364] = [__v_9]; + if let Some(result) = record.function_queries[364].get_mut(&inp[..]) { debug_assert_eq!(result.output, &__ret[..]); if !unconstrained { *result.multiplicity += G::ONE; } } else { record.function_queries[364].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained)); }; return Ok(__ret); }, } @@ -33259,15 +32985,15 @@ fn aiur_fn_368( }) } -const INPUT_SIZE_369: usize = 3; -const IN_369: usize = 3; -const OUT_369: usize = 1; -fn aiur_fn_369( - inp: [G; IN_369], +const INPUT_SIZE_365: usize = 3; +const IN_365: usize = 3; +const OUT_365: usize = 1; +fn aiur_fn_365( + inp: [G; IN_365], record: &mut QueryRecord, io_buffer: &mut IOBuffer, unconstrained: bool, -) -> Result<[G; OUT_369], ExecError> { +) -> Result<[G; OUT_365], ExecError> { stacker::maybe_grow(64 * 1024, 4 * 1024 * 1024, || { let __v_0: G = inp[0]; let __v_1: G = inp[1]; @@ -33279,90 +33005,90 @@ fn aiur_fn_369( let __v_6: G = __loaded[3]; match __v_3.as_canonical_u64() { 0u64 => { - let __r_arr: [G; OUT_370] = { let __args: [G; IN_370] = [__v_4, __v_1, __v_2]; let __cu = unconstrained; if let Some(result) = record.function_queries[370].get_mut(&__args[..]) { if !__cu && *result.multiplicity == G::ZERO { aiur_fn_370(__args, record, io_buffer, false)? } else { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_370] = unsafe { *(result.output.as_ptr() as *const [G; OUT_370]) }; __ret } } else { aiur_fn_370(__args, record, io_buffer, __cu)? } }; + let __r_arr: [G; OUT_366] = { let __args: [G; IN_366] = [__v_4, __v_1, __v_2]; let __cu = unconstrained; if let Some(result) = record.function_queries[366].get_mut(&__args[..]) { if !__cu && *result.multiplicity == G::ZERO { aiur_fn_366(__args, record, io_buffer, false)? } else { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_366] = unsafe { *(result.output.as_ptr() as *const [G; OUT_366]) }; __ret } } else { aiur_fn_366(__args, record, io_buffer, __cu)? } }; let __v_7: G = __r_arr[0]; - let __ret: [G; OUT_369] = [__v_7]; - if let Some(result) = record.function_queries[369].get_mut(&inp[..]) { debug_assert_eq!(result.output, &__ret[..]); if !unconstrained { *result.multiplicity += G::ONE; } } else { record.function_queries[369].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained)); }; + let __ret: [G; OUT_365] = [__v_7]; + if let Some(result) = record.function_queries[365].get_mut(&inp[..]) { debug_assert_eq!(result.output, &__ret[..]); if !unconstrained { *result.multiplicity += G::ONE; } } else { record.function_queries[365].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained)); }; return Ok(__ret); }, 1u64 => { let __v_7: G = G::from_u64(1); let __v_8: G = G::from_u64(0); let __v_9: G = { let __values: [G; 4] = [__v_7, __v_4, __v_8, __v_8]; let __mq = record.memory_queries.get_mut(&4).ok_or(ExecError::InvalidMemorySize(4))?; if let Some(result) = __mq.get_mut(&__values[..]) { if !unconstrained { *result.multiplicity += G::ONE; } result.output[0] } else { let __ptr = G::from_usize(__mq.len()); __mq.insert(&__values[..], &[__ptr], G::from_bool(!unconstrained)); __ptr } }; - let __ret: [G; OUT_369] = [__v_9]; - if let Some(result) = record.function_queries[369].get_mut(&inp[..]) { debug_assert_eq!(result.output, &__ret[..]); if !unconstrained { *result.multiplicity += G::ONE; } } else { record.function_queries[369].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained)); }; + let __ret: [G; OUT_365] = [__v_9]; + if let Some(result) = record.function_queries[365].get_mut(&inp[..]) { debug_assert_eq!(result.output, &__ret[..]); if !unconstrained { *result.multiplicity += G::ONE; } } else { record.function_queries[365].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained)); }; return Ok(__ret); }, 2u64 => { let __v_7: G = G::from_u64(2); let __v_8: G = G::from_u64(0); let __v_9: G = { let __values: [G; 4] = [__v_7, __v_4, __v_5, __v_8]; let __mq = record.memory_queries.get_mut(&4).ok_or(ExecError::InvalidMemorySize(4))?; if let Some(result) = __mq.get_mut(&__values[..]) { if !unconstrained { *result.multiplicity += G::ONE; } result.output[0] } else { let __ptr = G::from_usize(__mq.len()); __mq.insert(&__values[..], &[__ptr], G::from_bool(!unconstrained)); __ptr } }; - let __ret: [G; OUT_369] = [__v_9]; - if let Some(result) = record.function_queries[369].get_mut(&inp[..]) { debug_assert_eq!(result.output, &__ret[..]); if !unconstrained { *result.multiplicity += G::ONE; } } else { record.function_queries[369].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained)); }; + let __ret: [G; OUT_365] = [__v_9]; + if let Some(result) = record.function_queries[365].get_mut(&inp[..]) { debug_assert_eq!(result.output, &__ret[..]); if !unconstrained { *result.multiplicity += G::ONE; } } else { record.function_queries[365].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained)); }; return Ok(__ret); }, 3u64 => { let __v_7: G = G::from_u64(3); - let __r_arr: [G; OUT_368] = { let __args: [G; IN_368] = [__v_4, __v_1, __v_2]; let __cu = unconstrained; if let Some(result) = record.function_queries[368].get_mut(&__args[..]) { if !__cu && *result.multiplicity == G::ZERO { aiur_fn_368(__args, record, io_buffer, false)? } else { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_368] = unsafe { *(result.output.as_ptr() as *const [G; OUT_368]) }; __ret } } else { aiur_fn_368(__args, record, io_buffer, __cu)? } }; + let __r_arr: [G; OUT_364] = { let __args: [G; IN_364] = [__v_4, __v_1, __v_2]; let __cu = unconstrained; if let Some(result) = record.function_queries[364].get_mut(&__args[..]) { if !__cu && *result.multiplicity == G::ZERO { aiur_fn_364(__args, record, io_buffer, false)? } else { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_364] = unsafe { *(result.output.as_ptr() as *const [G; OUT_364]) }; __ret } } else { aiur_fn_364(__args, record, io_buffer, __cu)? } }; let __v_8: G = __r_arr[0]; - let __r_arr: [G; OUT_368] = { let __args: [G; IN_368] = [__v_5, __v_1, __v_2]; let __cu = unconstrained; if let Some(result) = record.function_queries[368].get_mut(&__args[..]) { if !__cu && *result.multiplicity == G::ZERO { aiur_fn_368(__args, record, io_buffer, false)? } else { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_368] = unsafe { *(result.output.as_ptr() as *const [G; OUT_368]) }; __ret } } else { aiur_fn_368(__args, record, io_buffer, __cu)? } }; + let __r_arr: [G; OUT_364] = { let __args: [G; IN_364] = [__v_5, __v_1, __v_2]; let __cu = unconstrained; if let Some(result) = record.function_queries[364].get_mut(&__args[..]) { if !__cu && *result.multiplicity == G::ZERO { aiur_fn_364(__args, record, io_buffer, false)? } else { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_364] = unsafe { *(result.output.as_ptr() as *const [G; OUT_364]) }; __ret } } else { aiur_fn_364(__args, record, io_buffer, __cu)? } }; let __v_9: G = __r_arr[0]; let __v_10: G = G::from_u64(0); let __v_11: G = { let __values: [G; 4] = [__v_7, __v_8, __v_9, __v_10]; let __mq = record.memory_queries.get_mut(&4).ok_or(ExecError::InvalidMemorySize(4))?; if let Some(result) = __mq.get_mut(&__values[..]) { if !unconstrained { *result.multiplicity += G::ONE; } result.output[0] } else { let __ptr = G::from_usize(__mq.len()); __mq.insert(&__values[..], &[__ptr], G::from_bool(!unconstrained)); __ptr } }; - let __ret: [G; OUT_369] = [__v_11]; - if let Some(result) = record.function_queries[369].get_mut(&inp[..]) { debug_assert_eq!(result.output, &__ret[..]); if !unconstrained { *result.multiplicity += G::ONE; } } else { record.function_queries[369].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained)); }; + let __ret: [G; OUT_365] = [__v_11]; + if let Some(result) = record.function_queries[365].get_mut(&inp[..]) { debug_assert_eq!(result.output, &__ret[..]); if !unconstrained { *result.multiplicity += G::ONE; } } else { record.function_queries[365].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained)); }; return Ok(__ret); }, 4u64 => { let __v_7: G = G::from_u64(4); - let __r_arr: [G; OUT_368] = { let __args: [G; IN_368] = [__v_4, __v_1, __v_2]; let __cu = unconstrained; if let Some(result) = record.function_queries[368].get_mut(&__args[..]) { if !__cu && *result.multiplicity == G::ZERO { aiur_fn_368(__args, record, io_buffer, false)? } else { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_368] = unsafe { *(result.output.as_ptr() as *const [G; OUT_368]) }; __ret } } else { aiur_fn_368(__args, record, io_buffer, __cu)? } }; + let __r_arr: [G; OUT_364] = { let __args: [G; IN_364] = [__v_4, __v_1, __v_2]; let __cu = unconstrained; if let Some(result) = record.function_queries[364].get_mut(&__args[..]) { if !__cu && *result.multiplicity == G::ZERO { aiur_fn_364(__args, record, io_buffer, false)? } else { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_364] = unsafe { *(result.output.as_ptr() as *const [G; OUT_364]) }; __ret } } else { aiur_fn_364(__args, record, io_buffer, __cu)? } }; let __v_8: G = __r_arr[0]; let __v_9: G = G::from_u64(1); let __v_10: G = (__v_2 + __v_9); - let __r_arr: [G; OUT_368] = { let __args: [G; IN_368] = [__v_5, __v_1, __v_10]; let __cu = unconstrained; if let Some(result) = record.function_queries[368].get_mut(&__args[..]) { if !__cu && *result.multiplicity == G::ZERO { aiur_fn_368(__args, record, io_buffer, false)? } else { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_368] = unsafe { *(result.output.as_ptr() as *const [G; OUT_368]) }; __ret } } else { aiur_fn_368(__args, record, io_buffer, __cu)? } }; + let __r_arr: [G; OUT_364] = { let __args: [G; IN_364] = [__v_5, __v_1, __v_10]; let __cu = unconstrained; if let Some(result) = record.function_queries[364].get_mut(&__args[..]) { if !__cu && *result.multiplicity == G::ZERO { aiur_fn_364(__args, record, io_buffer, false)? } else { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_364] = unsafe { *(result.output.as_ptr() as *const [G; OUT_364]) }; __ret } } else { aiur_fn_364(__args, record, io_buffer, __cu)? } }; let __v_11: G = __r_arr[0]; let __v_12: G = G::from_u64(0); let __v_13: G = { let __values: [G; 4] = [__v_7, __v_8, __v_11, __v_12]; let __mq = record.memory_queries.get_mut(&4).ok_or(ExecError::InvalidMemorySize(4))?; if let Some(result) = __mq.get_mut(&__values[..]) { if !unconstrained { *result.multiplicity += G::ONE; } result.output[0] } else { let __ptr = G::from_usize(__mq.len()); __mq.insert(&__values[..], &[__ptr], G::from_bool(!unconstrained)); __ptr } }; - let __ret: [G; OUT_369] = [__v_13]; - if let Some(result) = record.function_queries[369].get_mut(&inp[..]) { debug_assert_eq!(result.output, &__ret[..]); if !unconstrained { *result.multiplicity += G::ONE; } } else { record.function_queries[369].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained)); }; + let __ret: [G; OUT_365] = [__v_13]; + if let Some(result) = record.function_queries[365].get_mut(&inp[..]) { debug_assert_eq!(result.output, &__ret[..]); if !unconstrained { *result.multiplicity += G::ONE; } } else { record.function_queries[365].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained)); }; return Ok(__ret); }, 5u64 => { let __v_7: G = G::from_u64(5); - let __r_arr: [G; OUT_368] = { let __args: [G; IN_368] = [__v_4, __v_1, __v_2]; let __cu = unconstrained; if let Some(result) = record.function_queries[368].get_mut(&__args[..]) { if !__cu && *result.multiplicity == G::ZERO { aiur_fn_368(__args, record, io_buffer, false)? } else { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_368] = unsafe { *(result.output.as_ptr() as *const [G; OUT_368]) }; __ret } } else { aiur_fn_368(__args, record, io_buffer, __cu)? } }; + let __r_arr: [G; OUT_364] = { let __args: [G; IN_364] = [__v_4, __v_1, __v_2]; let __cu = unconstrained; if let Some(result) = record.function_queries[364].get_mut(&__args[..]) { if !__cu && *result.multiplicity == G::ZERO { aiur_fn_364(__args, record, io_buffer, false)? } else { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_364] = unsafe { *(result.output.as_ptr() as *const [G; OUT_364]) }; __ret } } else { aiur_fn_364(__args, record, io_buffer, __cu)? } }; let __v_8: G = __r_arr[0]; let __v_9: G = G::from_u64(1); let __v_10: G = (__v_2 + __v_9); - let __r_arr: [G; OUT_368] = { let __args: [G; IN_368] = [__v_5, __v_1, __v_10]; let __cu = unconstrained; if let Some(result) = record.function_queries[368].get_mut(&__args[..]) { if !__cu && *result.multiplicity == G::ZERO { aiur_fn_368(__args, record, io_buffer, false)? } else { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_368] = unsafe { *(result.output.as_ptr() as *const [G; OUT_368]) }; __ret } } else { aiur_fn_368(__args, record, io_buffer, __cu)? } }; + let __r_arr: [G; OUT_364] = { let __args: [G; IN_364] = [__v_5, __v_1, __v_10]; let __cu = unconstrained; if let Some(result) = record.function_queries[364].get_mut(&__args[..]) { if !__cu && *result.multiplicity == G::ZERO { aiur_fn_364(__args, record, io_buffer, false)? } else { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_364] = unsafe { *(result.output.as_ptr() as *const [G; OUT_364]) }; __ret } } else { aiur_fn_364(__args, record, io_buffer, __cu)? } }; let __v_11: G = __r_arr[0]; let __v_12: G = G::from_u64(0); let __v_13: G = { let __values: [G; 4] = [__v_7, __v_8, __v_11, __v_12]; let __mq = record.memory_queries.get_mut(&4).ok_or(ExecError::InvalidMemorySize(4))?; if let Some(result) = __mq.get_mut(&__values[..]) { if !unconstrained { *result.multiplicity += G::ONE; } result.output[0] } else { let __ptr = G::from_usize(__mq.len()); __mq.insert(&__values[..], &[__ptr], G::from_bool(!unconstrained)); __ptr } }; - let __ret: [G; OUT_369] = [__v_13]; - if let Some(result) = record.function_queries[369].get_mut(&inp[..]) { debug_assert_eq!(result.output, &__ret[..]); if !unconstrained { *result.multiplicity += G::ONE; } } else { record.function_queries[369].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained)); }; + let __ret: [G; OUT_365] = [__v_13]; + if let Some(result) = record.function_queries[365].get_mut(&inp[..]) { debug_assert_eq!(result.output, &__ret[..]); if !unconstrained { *result.multiplicity += G::ONE; } } else { record.function_queries[365].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained)); }; return Ok(__ret); }, 6u64 => { - let __r_arr: [G; OUT_371] = { let __args: [G; IN_371] = [__v_4, __v_5, __v_6, __v_1, __v_2]; let __cu = unconstrained; if let Some(result) = record.function_queries[371].get_mut(&__args[..]) { if !__cu && *result.multiplicity == G::ZERO { aiur_fn_371(__args, record, io_buffer, false)? } else { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_371] = unsafe { *(result.output.as_ptr() as *const [G; OUT_371]) }; __ret } } else { aiur_fn_371(__args, record, io_buffer, __cu)? } }; + let __r_arr: [G; OUT_367] = { let __args: [G; IN_367] = [__v_4, __v_5, __v_6, __v_1, __v_2]; let __cu = unconstrained; if let Some(result) = record.function_queries[367].get_mut(&__args[..]) { if !__cu && *result.multiplicity == G::ZERO { aiur_fn_367(__args, record, io_buffer, false)? } else { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_367] = unsafe { *(result.output.as_ptr() as *const [G; OUT_367]) }; __ret } } else { aiur_fn_367(__args, record, io_buffer, __cu)? } }; let __v_7: G = __r_arr[0]; - let __ret: [G; OUT_369] = [__v_7]; - if let Some(result) = record.function_queries[369].get_mut(&inp[..]) { debug_assert_eq!(result.output, &__ret[..]); if !unconstrained { *result.multiplicity += G::ONE; } } else { record.function_queries[369].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained)); }; + let __ret: [G; OUT_365] = [__v_7]; + if let Some(result) = record.function_queries[365].get_mut(&inp[..]) { debug_assert_eq!(result.output, &__ret[..]); if !unconstrained { *result.multiplicity += G::ONE; } } else { record.function_queries[365].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained)); }; return Ok(__ret); }, 7u64 => { let __v_7: G = G::from_u64(7); let __v_8: G = G::from_u64(0); let __v_9: G = { let __values: [G; 4] = [__v_7, __v_4, __v_5, __v_8]; let __mq = record.memory_queries.get_mut(&4).ok_or(ExecError::InvalidMemorySize(4))?; if let Some(result) = __mq.get_mut(&__values[..]) { if !unconstrained { *result.multiplicity += G::ONE; } result.output[0] } else { let __ptr = G::from_usize(__mq.len()); __mq.insert(&__values[..], &[__ptr], G::from_bool(!unconstrained)); __ptr } }; - let __ret: [G; OUT_369] = [__v_9]; - if let Some(result) = record.function_queries[369].get_mut(&inp[..]) { debug_assert_eq!(result.output, &__ret[..]); if !unconstrained { *result.multiplicity += G::ONE; } } else { record.function_queries[369].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained)); }; + let __ret: [G; OUT_365] = [__v_9]; + if let Some(result) = record.function_queries[365].get_mut(&inp[..]) { debug_assert_eq!(result.output, &__ret[..]); if !unconstrained { *result.multiplicity += G::ONE; } } else { record.function_queries[365].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained)); }; return Ok(__ret); }, 8u64 => { let __v_7: G = G::from_u64(8); - let __r_arr: [G; OUT_368] = { let __args: [G; IN_368] = [__v_6, __v_1, __v_2]; let __cu = unconstrained; if let Some(result) = record.function_queries[368].get_mut(&__args[..]) { if !__cu && *result.multiplicity == G::ZERO { aiur_fn_368(__args, record, io_buffer, false)? } else { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_368] = unsafe { *(result.output.as_ptr() as *const [G; OUT_368]) }; __ret } } else { aiur_fn_368(__args, record, io_buffer, __cu)? } }; + let __r_arr: [G; OUT_364] = { let __args: [G; IN_364] = [__v_6, __v_1, __v_2]; let __cu = unconstrained; if let Some(result) = record.function_queries[364].get_mut(&__args[..]) { if !__cu && *result.multiplicity == G::ZERO { aiur_fn_364(__args, record, io_buffer, false)? } else { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_364] = unsafe { *(result.output.as_ptr() as *const [G; OUT_364]) }; __ret } } else { aiur_fn_364(__args, record, io_buffer, __cu)? } }; let __v_8: G = __r_arr[0]; let __v_9: G = { let __values: [G; 4] = [__v_7, __v_4, __v_5, __v_8]; let __mq = record.memory_queries.get_mut(&4).ok_or(ExecError::InvalidMemorySize(4))?; if let Some(result) = __mq.get_mut(&__values[..]) { if !unconstrained { *result.multiplicity += G::ONE; } result.output[0] } else { let __ptr = G::from_usize(__mq.len()); __mq.insert(&__values[..], &[__ptr], G::from_bool(!unconstrained)); __ptr } }; - let __ret: [G; OUT_369] = [__v_9]; - if let Some(result) = record.function_queries[369].get_mut(&inp[..]) { debug_assert_eq!(result.output, &__ret[..]); if !unconstrained { *result.multiplicity += G::ONE; } } else { record.function_queries[369].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained)); }; + let __ret: [G; OUT_365] = [__v_9]; + if let Some(result) = record.function_queries[365].get_mut(&inp[..]) { debug_assert_eq!(result.output, &__ret[..]); if !unconstrained { *result.multiplicity += G::ONE; } } else { record.function_queries[365].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained)); }; return Ok(__ret); }, _ => { @@ -33372,28 +33098,28 @@ fn aiur_fn_369( }) } -const INPUT_SIZE_370: usize = 3; -const IN_370: usize = 3; -const OUT_370: usize = 1; -fn aiur_fn_370( - inp: [G; IN_370], +const INPUT_SIZE_366: usize = 3; +const IN_366: usize = 3; +const OUT_366: usize = 1; +fn aiur_fn_366( + inp: [G; IN_366], record: &mut QueryRecord, io_buffer: &mut IOBuffer, unconstrained: bool, -) -> Result<[G; OUT_370], ExecError> { +) -> Result<[G; OUT_366], ExecError> { stacker::maybe_grow(64 * 1024, 4 * 1024 * 1024, || { let __v_0: G = inp[0]; let __v_1: G = inp[1]; let __v_2: G = inp[2]; - let __r_arr: [G; OUT_346] = { let __args: [G; IN_346] = [__v_0, __v_2]; let __cu = unconstrained; if let Some(result) = record.function_queries[346].get_mut(&__args[..]) { if !__cu && *result.multiplicity == G::ZERO { aiur_fn_346(__args, record, io_buffer, false)? } else { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_346] = unsafe { *(result.output.as_ptr() as *const [G; OUT_346]) }; __ret } } else { aiur_fn_346(__args, record, io_buffer, __cu)? } }; + let __r_arr: [G; OUT_342] = { let __args: [G; IN_342] = [__v_0, __v_2]; let __cu = unconstrained; if let Some(result) = record.function_queries[342].get_mut(&__args[..]) { if !__cu && *result.multiplicity == G::ZERO { aiur_fn_342(__args, record, io_buffer, false)? } else { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_342] = unsafe { *(result.output.as_ptr() as *const [G; OUT_342]) }; __ret } } else { aiur_fn_342(__args, record, io_buffer, __cu)? } }; let __v_3: G = __r_arr[0]; match __v_3.as_canonical_u64() { 1u64 => { let __v_4: G = G::from_u64(0); let __v_5: G = G::from_u64(0); let __v_6: G = { let __values: [G; 4] = [__v_4, __v_0, __v_5, __v_5]; let __mq = record.memory_queries.get_mut(&4).ok_or(ExecError::InvalidMemorySize(4))?; if let Some(result) = __mq.get_mut(&__values[..]) { if !unconstrained { *result.multiplicity += G::ONE; } result.output[0] } else { let __ptr = G::from_usize(__mq.len()); __mq.insert(&__values[..], &[__ptr], G::from_bool(!unconstrained)); __ptr } }; - let __ret: [G; OUT_370] = [__v_6]; - if let Some(result) = record.function_queries[370].get_mut(&inp[..]) { debug_assert_eq!(result.output, &__ret[..]); if !unconstrained { *result.multiplicity += G::ONE; } } else { record.function_queries[370].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained)); }; + let __ret: [G; OUT_366] = [__v_6]; + if let Some(result) = record.function_queries[366].get_mut(&inp[..]) { debug_assert_eq!(result.output, &__ret[..]); if !unconstrained { *result.multiplicity += G::ONE; } } else { record.function_queries[366].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained)); }; return Ok(__ret); }, 0u64 => { @@ -33401,10 +33127,10 @@ fn aiur_fn_370( match __v_4.as_canonical_u64() { 0u64 => { let __v_5: G = G::from_u64(0); - let __r_arr: [G; OUT_359] = { let __args: [G; IN_359] = [__v_1, __v_2, __v_5]; let __cu = unconstrained; if let Some(result) = record.function_queries[359].get_mut(&__args[..]) { if !__cu && *result.multiplicity == G::ZERO { aiur_fn_359(__args, record, io_buffer, false)? } else { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_359] = unsafe { *(result.output.as_ptr() as *const [G; OUT_359]) }; __ret } } else { aiur_fn_359(__args, record, io_buffer, __cu)? } }; + let __r_arr: [G; OUT_355] = { let __args: [G; IN_355] = [__v_1, __v_2, __v_5]; let __cu = unconstrained; if let Some(result) = record.function_queries[355].get_mut(&__args[..]) { if !__cu && *result.multiplicity == G::ZERO { aiur_fn_355(__args, record, io_buffer, false)? } else { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_355] = unsafe { *(result.output.as_ptr() as *const [G; OUT_355]) }; __ret } } else { aiur_fn_355(__args, record, io_buffer, __cu)? } }; let __v_6: G = __r_arr[0]; - let __ret: [G; OUT_370] = [__v_6]; - if let Some(result) = record.function_queries[370].get_mut(&inp[..]) { debug_assert_eq!(result.output, &__ret[..]); if !unconstrained { *result.multiplicity += G::ONE; } } else { record.function_queries[370].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained)); }; + let __ret: [G; OUT_366] = [__v_6]; + if let Some(result) = record.function_queries[366].get_mut(&inp[..]) { debug_assert_eq!(result.output, &__ret[..]); if !unconstrained { *result.multiplicity += G::ONE; } } else { record.function_queries[366].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained)); }; return Ok(__ret); }, _ => { @@ -33413,8 +33139,8 @@ fn aiur_fn_370( let __v_7: G = (__v_0 - __v_6); let __v_8: G = G::from_u64(0); let __v_9: G = { let __values: [G; 4] = [__v_5, __v_7, __v_8, __v_8]; let __mq = record.memory_queries.get_mut(&4).ok_or(ExecError::InvalidMemorySize(4))?; if let Some(result) = __mq.get_mut(&__values[..]) { if !unconstrained { *result.multiplicity += G::ONE; } result.output[0] } else { let __ptr = G::from_usize(__mq.len()); __mq.insert(&__values[..], &[__ptr], G::from_bool(!unconstrained)); __ptr } }; - let __ret: [G; OUT_370] = [__v_9]; - if let Some(result) = record.function_queries[370].get_mut(&inp[..]) { debug_assert_eq!(result.output, &__ret[..]); if !unconstrained { *result.multiplicity += G::ONE; } } else { record.function_queries[370].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained)); }; + let __ret: [G; OUT_366] = [__v_9]; + if let Some(result) = record.function_queries[366].get_mut(&inp[..]) { debug_assert_eq!(result.output, &__ret[..]); if !unconstrained { *result.multiplicity += G::ONE; } } else { record.function_queries[366].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained)); }; return Ok(__ret); }, } @@ -33426,15 +33152,15 @@ fn aiur_fn_370( }) } -const INPUT_SIZE_371: usize = 5; -const IN_371: usize = 5; -const OUT_371: usize = 1; -fn aiur_fn_371( - inp: [G; IN_371], +const INPUT_SIZE_367: usize = 5; +const IN_367: usize = 5; +const OUT_367: usize = 1; +fn aiur_fn_367( + inp: [G; IN_367], record: &mut QueryRecord, io_buffer: &mut IOBuffer, unconstrained: bool, -) -> Result<[G; OUT_371], ExecError> { +) -> Result<[G; OUT_367], ExecError> { stacker::maybe_grow(64 * 1024, 4 * 1024 * 1024, || { let __v_0: G = inp[0]; let __v_1: G = inp[1]; @@ -33442,71 +33168,71 @@ fn aiur_fn_371( let __v_3: G = inp[3]; let __v_4: G = inp[4]; let __v_5: G = G::from_u64(6); - let __r_arr: [G; OUT_368] = { let __args: [G; IN_368] = [__v_0, __v_3, __v_4]; let __cu = unconstrained; if let Some(result) = record.function_queries[368].get_mut(&__args[..]) { if !__cu && *result.multiplicity == G::ZERO { aiur_fn_368(__args, record, io_buffer, false)? } else { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_368] = unsafe { *(result.output.as_ptr() as *const [G; OUT_368]) }; __ret } } else { aiur_fn_368(__args, record, io_buffer, __cu)? } }; + let __r_arr: [G; OUT_364] = { let __args: [G; IN_364] = [__v_0, __v_3, __v_4]; let __cu = unconstrained; if let Some(result) = record.function_queries[364].get_mut(&__args[..]) { if !__cu && *result.multiplicity == G::ZERO { aiur_fn_364(__args, record, io_buffer, false)? } else { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_364] = unsafe { *(result.output.as_ptr() as *const [G; OUT_364]) }; __ret } } else { aiur_fn_364(__args, record, io_buffer, __cu)? } }; let __v_6: G = __r_arr[0]; - let __r_arr: [G; OUT_368] = { let __args: [G; IN_368] = [__v_1, __v_3, __v_4]; let __cu = unconstrained; if let Some(result) = record.function_queries[368].get_mut(&__args[..]) { if !__cu && *result.multiplicity == G::ZERO { aiur_fn_368(__args, record, io_buffer, false)? } else { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_368] = unsafe { *(result.output.as_ptr() as *const [G; OUT_368]) }; __ret } } else { aiur_fn_368(__args, record, io_buffer, __cu)? } }; + let __r_arr: [G; OUT_364] = { let __args: [G; IN_364] = [__v_1, __v_3, __v_4]; let __cu = unconstrained; if let Some(result) = record.function_queries[364].get_mut(&__args[..]) { if !__cu && *result.multiplicity == G::ZERO { aiur_fn_364(__args, record, io_buffer, false)? } else { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_364] = unsafe { *(result.output.as_ptr() as *const [G; OUT_364]) }; __ret } } else { aiur_fn_364(__args, record, io_buffer, __cu)? } }; let __v_7: G = __r_arr[0]; let __v_8: G = G::from_u64(1); let __v_9: G = (__v_4 + __v_8); - let __r_arr: [G; OUT_368] = { let __args: [G; IN_368] = [__v_2, __v_3, __v_9]; let __cu = unconstrained; if let Some(result) = record.function_queries[368].get_mut(&__args[..]) { if !__cu && *result.multiplicity == G::ZERO { aiur_fn_368(__args, record, io_buffer, false)? } else { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_368] = unsafe { *(result.output.as_ptr() as *const [G; OUT_368]) }; __ret } } else { aiur_fn_368(__args, record, io_buffer, __cu)? } }; + let __r_arr: [G; OUT_364] = { let __args: [G; IN_364] = [__v_2, __v_3, __v_9]; let __cu = unconstrained; if let Some(result) = record.function_queries[364].get_mut(&__args[..]) { if !__cu && *result.multiplicity == G::ZERO { aiur_fn_364(__args, record, io_buffer, false)? } else { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_364] = unsafe { *(result.output.as_ptr() as *const [G; OUT_364]) }; __ret } } else { aiur_fn_364(__args, record, io_buffer, __cu)? } }; let __v_10: G = __r_arr[0]; let __v_11: G = { let __values: [G; 4] = [__v_5, __v_6, __v_7, __v_10]; let __mq = record.memory_queries.get_mut(&4).ok_or(ExecError::InvalidMemorySize(4))?; if let Some(result) = __mq.get_mut(&__values[..]) { if !unconstrained { *result.multiplicity += G::ONE; } result.output[0] } else { let __ptr = G::from_usize(__mq.len()); __mq.insert(&__values[..], &[__ptr], G::from_bool(!unconstrained)); __ptr } }; - let __ret: [G; OUT_371] = [__v_11]; - if let Some(result) = record.function_queries[371].get_mut(&inp[..]) { debug_assert_eq!(result.output, &__ret[..]); if !unconstrained { *result.multiplicity += G::ONE; } } else { record.function_queries[371].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained)); }; + let __ret: [G; OUT_367] = [__v_11]; + if let Some(result) = record.function_queries[367].get_mut(&inp[..]) { debug_assert_eq!(result.output, &__ret[..]); if !unconstrained { *result.multiplicity += G::ONE; } } else { record.function_queries[367].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained)); }; return Ok(__ret); }) } -const INPUT_SIZE_372: usize = 3; -const IN_372: usize = 3; -const OUT_372: usize = 1; -fn aiur_fn_372( - inp: [G; IN_372], +const INPUT_SIZE_368: usize = 3; +const IN_368: usize = 3; +const OUT_368: usize = 1; +fn aiur_fn_368( + inp: [G; IN_368], record: &mut QueryRecord, io_buffer: &mut IOBuffer, unconstrained: bool, -) -> Result<[G; OUT_372], ExecError> { +) -> Result<[G; OUT_368], ExecError> { stacker::maybe_grow(64 * 1024, 4 * 1024 * 1024, || { let __v_0: G = inp[0]; let __v_1: G = inp[1]; let __v_2: G = inp[2]; - let __r_arr: [G; OUT_764] = { let __args: [G; IN_764] = [__v_1]; let __cu = unconstrained; if let Some(result) = record.function_queries[764].get_mut(&__args[..]) { if !__cu && *result.multiplicity == G::ZERO { aiur_fn_764(__args, record, io_buffer, false)? } else { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_764] = unsafe { *(result.output.as_ptr() as *const [G; OUT_764]) }; __ret } } else { aiur_fn_764(__args, record, io_buffer, __cu)? } }; + let __r_arr: [G; OUT_760] = { let __args: [G; IN_760] = [__v_1]; let __cu = unconstrained; if let Some(result) = record.function_queries[760].get_mut(&__args[..]) { if !__cu && *result.multiplicity == G::ZERO { aiur_fn_760(__args, record, io_buffer, false)? } else { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_760] = unsafe { *(result.output.as_ptr() as *const [G; OUT_760]) }; __ret } } else { aiur_fn_760(__args, record, io_buffer, __cu)? } }; let __v_3: G = __r_arr[0]; match __v_3.as_canonical_u64() { 0u64 => { - let __ret: [G; OUT_372] = [__v_0]; - if let Some(result) = record.function_queries[372].get_mut(&inp[..]) { debug_assert_eq!(result.output, &__ret[..]); if !unconstrained { *result.multiplicity += G::ONE; } } else { record.function_queries[372].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained)); }; + let __ret: [G; OUT_368] = [__v_0]; + if let Some(result) = record.function_queries[368].get_mut(&inp[..]) { debug_assert_eq!(result.output, &__ret[..]); if !unconstrained { *result.multiplicity += G::ONE; } } else { record.function_queries[368].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained)); }; return Ok(__ret); }, _ => { - let __r_arr: [G; OUT_341] = { let __args: [G; IN_341] = [__v_0]; let __cu = unconstrained; if let Some(result) = record.function_queries[341].get_mut(&__args[..]) { if !__cu && *result.multiplicity == G::ZERO { aiur_fn_341(__args, record, io_buffer, false)? } else { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_341] = unsafe { *(result.output.as_ptr() as *const [G; OUT_341]) }; __ret } } else { aiur_fn_341(__args, record, io_buffer, __cu)? } }; + let __r_arr: [G; OUT_337] = { let __args: [G; IN_337] = [__v_0]; let __cu = unconstrained; if let Some(result) = record.function_queries[337].get_mut(&__args[..]) { if !__cu && *result.multiplicity == G::ZERO { aiur_fn_337(__args, record, io_buffer, false)? } else { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_337] = unsafe { *(result.output.as_ptr() as *const [G; OUT_337]) }; __ret } } else { aiur_fn_337(__args, record, io_buffer, __cu)? } }; let __v_4: G = __r_arr[0]; - let __r_arr: [G; OUT_346] = { let __args: [G; IN_346] = [__v_2, __v_4]; let __cu = unconstrained; if let Some(result) = record.function_queries[346].get_mut(&__args[..]) { if !__cu && *result.multiplicity == G::ZERO { aiur_fn_346(__args, record, io_buffer, false)? } else { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_346] = unsafe { *(result.output.as_ptr() as *const [G; OUT_346]) }; __ret } } else { aiur_fn_346(__args, record, io_buffer, __cu)? } }; + let __r_arr: [G; OUT_342] = { let __args: [G; IN_342] = [__v_2, __v_4]; let __cu = unconstrained; if let Some(result) = record.function_queries[342].get_mut(&__args[..]) { if !__cu && *result.multiplicity == G::ZERO { aiur_fn_342(__args, record, io_buffer, false)? } else { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_342] = unsafe { *(result.output.as_ptr() as *const [G; OUT_342]) }; __ret } } else { aiur_fn_342(__args, record, io_buffer, __cu)? } }; let __v_5: G = __r_arr[0]; match __v_5.as_canonical_u64() { 0u64 => { - let __ret: [G; OUT_372] = [__v_0]; - if let Some(result) = record.function_queries[372].get_mut(&inp[..]) { debug_assert_eq!(result.output, &__ret[..]); if !unconstrained { *result.multiplicity += G::ONE; } } else { record.function_queries[372].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained)); }; + let __ret: [G; OUT_368] = [__v_0]; + if let Some(result) = record.function_queries[368].get_mut(&inp[..]) { debug_assert_eq!(result.output, &__ret[..]); if !unconstrained { *result.multiplicity += G::ONE; } } else { record.function_queries[368].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained)); }; return Ok(__ret); }, 1u64 => { let __v_6: G = (__v_2 + __v_3); - let __r_arr: [G; OUT_347] = { let __args: [G; IN_347] = [__v_0, __v_2, __v_6]; let __cu = unconstrained; if let Some(result) = record.function_queries[347].get_mut(&__args[..]) { if !__cu && *result.multiplicity == G::ZERO { aiur_fn_347(__args, record, io_buffer, false)? } else { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_347] = unsafe { *(result.output.as_ptr() as *const [G; OUT_347]) }; __ret } } else { aiur_fn_347(__args, record, io_buffer, __cu)? } }; + let __r_arr: [G; OUT_343] = { let __args: [G; IN_343] = [__v_0, __v_2, __v_6]; let __cu = unconstrained; if let Some(result) = record.function_queries[343].get_mut(&__args[..]) { if !__cu && *result.multiplicity == G::ZERO { aiur_fn_343(__args, record, io_buffer, false)? } else { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_343] = unsafe { *(result.output.as_ptr() as *const [G; OUT_343]) }; __ret } } else { aiur_fn_343(__args, record, io_buffer, __cu)? } }; let __v_7: G = __r_arr[0]; match __v_7.as_canonical_u64() { 1u64 => { - let __r_arr: [G; OUT_374] = { let __args: [G; IN_374] = [__v_0, __v_1, __v_2]; let __cu = unconstrained; if let Some(result) = record.function_queries[374].get_mut(&__args[..]) { if !__cu && *result.multiplicity == G::ZERO { aiur_fn_374(__args, record, io_buffer, false)? } else { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_374] = unsafe { *(result.output.as_ptr() as *const [G; OUT_374]) }; __ret } } else { aiur_fn_374(__args, record, io_buffer, __cu)? } }; + let __r_arr: [G; OUT_370] = { let __args: [G; IN_370] = [__v_0, __v_1, __v_2]; let __cu = unconstrained; if let Some(result) = record.function_queries[370].get_mut(&__args[..]) { if !__cu && *result.multiplicity == G::ZERO { aiur_fn_370(__args, record, io_buffer, false)? } else { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_370] = unsafe { *(result.output.as_ptr() as *const [G; OUT_370]) }; __ret } } else { aiur_fn_370(__args, record, io_buffer, __cu)? } }; let __v_8: G = __r_arr[0]; - let __ret: [G; OUT_372] = [__v_8]; - if let Some(result) = record.function_queries[372].get_mut(&inp[..]) { debug_assert_eq!(result.output, &__ret[..]); if !unconstrained { *result.multiplicity += G::ONE; } } else { record.function_queries[372].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained)); }; + let __ret: [G; OUT_368] = [__v_8]; + if let Some(result) = record.function_queries[368].get_mut(&inp[..]) { debug_assert_eq!(result.output, &__ret[..]); if !unconstrained { *result.multiplicity += G::ONE; } } else { record.function_queries[368].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained)); }; return Ok(__ret); }, _ => { let __v_8: G = (__v_2 + __v_3); - let __r_arr: [G; OUT_363] = { let __args: [G; IN_363] = [__v_0, __v_3, __v_8]; let __cu = unconstrained; if let Some(result) = record.function_queries[363].get_mut(&__args[..]) { if !__cu && *result.multiplicity == G::ZERO { aiur_fn_363(__args, record, io_buffer, false)? } else { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_363] = unsafe { *(result.output.as_ptr() as *const [G; OUT_363]) }; __ret } } else { aiur_fn_363(__args, record, io_buffer, __cu)? } }; + let __r_arr: [G; OUT_359] = { let __args: [G; IN_359] = [__v_0, __v_3, __v_8]; let __cu = unconstrained; if let Some(result) = record.function_queries[359].get_mut(&__args[..]) { if !__cu && *result.multiplicity == G::ZERO { aiur_fn_359(__args, record, io_buffer, false)? } else { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_359] = unsafe { *(result.output.as_ptr() as *const [G; OUT_359]) }; __ret } } else { aiur_fn_359(__args, record, io_buffer, __cu)? } }; let __v_9: G = __r_arr[0]; - let __ret: [G; OUT_372] = [__v_9]; - if let Some(result) = record.function_queries[372].get_mut(&inp[..]) { debug_assert_eq!(result.output, &__ret[..]); if !unconstrained { *result.multiplicity += G::ONE; } } else { record.function_queries[372].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained)); }; + let __ret: [G; OUT_368] = [__v_9]; + if let Some(result) = record.function_queries[368].get_mut(&inp[..]) { debug_assert_eq!(result.output, &__ret[..]); if !unconstrained { *result.multiplicity += G::ONE; } } else { record.function_queries[368].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained)); }; return Ok(__ret); }, } @@ -33520,33 +33246,33 @@ fn aiur_fn_372( }) } -const INPUT_SIZE_373: usize = 3; -const IN_373: usize = 3; -const OUT_373: usize = 1; -fn aiur_fn_373( - inp: [G; IN_373], +const INPUT_SIZE_369: usize = 3; +const IN_369: usize = 3; +const OUT_369: usize = 1; +fn aiur_fn_369( + inp: [G; IN_369], record: &mut QueryRecord, io_buffer: &mut IOBuffer, unconstrained: bool, -) -> Result<[G; OUT_373], ExecError> { +) -> Result<[G; OUT_369], ExecError> { stacker::maybe_grow(64 * 1024, 4 * 1024 * 1024, || { let __v_0: G = inp[0]; let __v_1: G = inp[1]; let __v_2: G = inp[2]; - let __r_arr: [G; OUT_764] = { let __args: [G; IN_764] = [__v_1]; let __cu = unconstrained; if let Some(result) = record.function_queries[764].get_mut(&__args[..]) { if !__cu && *result.multiplicity == G::ZERO { aiur_fn_764(__args, record, io_buffer, false)? } else { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_764] = unsafe { *(result.output.as_ptr() as *const [G; OUT_764]) }; __ret } } else { aiur_fn_764(__args, record, io_buffer, __cu)? } }; + let __r_arr: [G; OUT_760] = { let __args: [G; IN_760] = [__v_1]; let __cu = unconstrained; if let Some(result) = record.function_queries[760].get_mut(&__args[..]) { if !__cu && *result.multiplicity == G::ZERO { aiur_fn_760(__args, record, io_buffer, false)? } else { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_760] = unsafe { *(result.output.as_ptr() as *const [G; OUT_760]) }; __ret } } else { aiur_fn_760(__args, record, io_buffer, __cu)? } }; let __v_3: G = __r_arr[0]; let __v_4: G = (__v_0 - __v_2); - let __r_arr: [G; OUT_346] = { let __args: [G; IN_346] = [__v_4, __v_3]; let __cu = unconstrained; if let Some(result) = record.function_queries[346].get_mut(&__args[..]) { if !__cu && *result.multiplicity == G::ZERO { aiur_fn_346(__args, record, io_buffer, false)? } else { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_346] = unsafe { *(result.output.as_ptr() as *const [G; OUT_346]) }; __ret } } else { aiur_fn_346(__args, record, io_buffer, __cu)? } }; + let __r_arr: [G; OUT_342] = { let __args: [G; IN_342] = [__v_4, __v_3]; let __cu = unconstrained; if let Some(result) = record.function_queries[342].get_mut(&__args[..]) { if !__cu && *result.multiplicity == G::ZERO { aiur_fn_342(__args, record, io_buffer, false)? } else { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_342] = unsafe { *(result.output.as_ptr() as *const [G; OUT_342]) }; __ret } } else { aiur_fn_342(__args, record, io_buffer, __cu)? } }; let __v_5: G = __r_arr[0]; match __v_5.as_canonical_u64() { 1u64 => { - let __r_arr: [G; OUT_766] = { let __args: [G; IN_766] = [__v_1, __v_4]; let __cu = unconstrained; if let Some(result) = record.function_queries[766].get_mut(&__args[..]) { if !__cu && *result.multiplicity == G::ZERO { aiur_fn_766(__args, record, io_buffer, false)? } else { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_766] = unsafe { *(result.output.as_ptr() as *const [G; OUT_766]) }; __ret } } else { aiur_fn_766(__args, record, io_buffer, __cu)? } }; + let __r_arr: [G; OUT_762] = { let __args: [G; IN_762] = [__v_1, __v_4]; let __cu = unconstrained; if let Some(result) = record.function_queries[762].get_mut(&__args[..]) { if !__cu && *result.multiplicity == G::ZERO { aiur_fn_762(__args, record, io_buffer, false)? } else { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_762] = unsafe { *(result.output.as_ptr() as *const [G; OUT_762]) }; __ret } } else { aiur_fn_762(__args, record, io_buffer, __cu)? } }; let __v_6: G = __r_arr[0]; let __v_7: G = G::from_u64(0); - let __r_arr: [G; OUT_359] = { let __args: [G; IN_359] = [__v_6, __v_2, __v_7]; let __cu = unconstrained; if let Some(result) = record.function_queries[359].get_mut(&__args[..]) { if !__cu && *result.multiplicity == G::ZERO { aiur_fn_359(__args, record, io_buffer, false)? } else { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_359] = unsafe { *(result.output.as_ptr() as *const [G; OUT_359]) }; __ret } } else { aiur_fn_359(__args, record, io_buffer, __cu)? } }; + let __r_arr: [G; OUT_355] = { let __args: [G; IN_355] = [__v_6, __v_2, __v_7]; let __cu = unconstrained; if let Some(result) = record.function_queries[355].get_mut(&__args[..]) { if !__cu && *result.multiplicity == G::ZERO { aiur_fn_355(__args, record, io_buffer, false)? } else { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_355] = unsafe { *(result.output.as_ptr() as *const [G; OUT_355]) }; __ret } } else { aiur_fn_355(__args, record, io_buffer, __cu)? } }; let __v_8: G = __r_arr[0]; - let __ret: [G; OUT_373] = [__v_8]; - if let Some(result) = record.function_queries[373].get_mut(&inp[..]) { debug_assert_eq!(result.output, &__ret[..]); if !unconstrained { *result.multiplicity += G::ONE; } } else { record.function_queries[373].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained)); }; + let __ret: [G; OUT_369] = [__v_8]; + if let Some(result) = record.function_queries[369].get_mut(&inp[..]) { debug_assert_eq!(result.output, &__ret[..]); if !unconstrained { *result.multiplicity += G::ONE; } } else { record.function_queries[369].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained)); }; return Ok(__ret); }, 0u64 => { @@ -33554,8 +33280,8 @@ fn aiur_fn_373( let __v_7: G = (__v_0 - __v_3); let __v_8: G = G::from_u64(0); let __v_9: G = { let __values: [G; 4] = [__v_6, __v_7, __v_8, __v_8]; let __mq = record.memory_queries.get_mut(&4).ok_or(ExecError::InvalidMemorySize(4))?; if let Some(result) = __mq.get_mut(&__values[..]) { if !unconstrained { *result.multiplicity += G::ONE; } result.output[0] } else { let __ptr = G::from_usize(__mq.len()); __mq.insert(&__values[..], &[__ptr], G::from_bool(!unconstrained)); __ptr } }; - let __ret: [G; OUT_373] = [__v_9]; - if let Some(result) = record.function_queries[373].get_mut(&inp[..]) { debug_assert_eq!(result.output, &__ret[..]); if !unconstrained { *result.multiplicity += G::ONE; } } else { record.function_queries[373].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained)); }; + let __ret: [G; OUT_369] = [__v_9]; + if let Some(result) = record.function_queries[369].get_mut(&inp[..]) { debug_assert_eq!(result.output, &__ret[..]); if !unconstrained { *result.multiplicity += G::ONE; } } else { record.function_queries[369].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained)); }; return Ok(__ret); }, _ => { @@ -33565,15 +33291,15 @@ fn aiur_fn_373( }) } -const INPUT_SIZE_374: usize = 3; -const IN_374: usize = 3; -const OUT_374: usize = 1; -fn aiur_fn_374( - inp: [G; IN_374], +const INPUT_SIZE_370: usize = 3; +const IN_370: usize = 3; +const OUT_370: usize = 1; +fn aiur_fn_370( + inp: [G; IN_370], record: &mut QueryRecord, io_buffer: &mut IOBuffer, unconstrained: bool, -) -> Result<[G; OUT_374], ExecError> { +) -> Result<[G; OUT_370], ExecError> { stacker::maybe_grow(64 * 1024, 4 * 1024 * 1024, || { let __v_0: G = inp[0]; let __v_1: G = inp[1]; @@ -33585,90 +33311,90 @@ fn aiur_fn_374( let __v_6: G = __loaded[3]; match __v_3.as_canonical_u64() { 0u64 => { - let __r_arr: [G; OUT_373] = { let __args: [G; IN_373] = [__v_4, __v_1, __v_2]; let __cu = unconstrained; if let Some(result) = record.function_queries[373].get_mut(&__args[..]) { if !__cu && *result.multiplicity == G::ZERO { aiur_fn_373(__args, record, io_buffer, false)? } else { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_373] = unsafe { *(result.output.as_ptr() as *const [G; OUT_373]) }; __ret } } else { aiur_fn_373(__args, record, io_buffer, __cu)? } }; + let __r_arr: [G; OUT_369] = { let __args: [G; IN_369] = [__v_4, __v_1, __v_2]; let __cu = unconstrained; if let Some(result) = record.function_queries[369].get_mut(&__args[..]) { if !__cu && *result.multiplicity == G::ZERO { aiur_fn_369(__args, record, io_buffer, false)? } else { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_369] = unsafe { *(result.output.as_ptr() as *const [G; OUT_369]) }; __ret } } else { aiur_fn_369(__args, record, io_buffer, __cu)? } }; let __v_7: G = __r_arr[0]; - let __ret: [G; OUT_374] = [__v_7]; - if let Some(result) = record.function_queries[374].get_mut(&inp[..]) { debug_assert_eq!(result.output, &__ret[..]); if !unconstrained { *result.multiplicity += G::ONE; } } else { record.function_queries[374].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained)); }; + let __ret: [G; OUT_370] = [__v_7]; + if let Some(result) = record.function_queries[370].get_mut(&inp[..]) { debug_assert_eq!(result.output, &__ret[..]); if !unconstrained { *result.multiplicity += G::ONE; } } else { record.function_queries[370].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained)); }; return Ok(__ret); }, 1u64 => { let __v_7: G = G::from_u64(1); let __v_8: G = G::from_u64(0); let __v_9: G = { let __values: [G; 4] = [__v_7, __v_4, __v_8, __v_8]; let __mq = record.memory_queries.get_mut(&4).ok_or(ExecError::InvalidMemorySize(4))?; if let Some(result) = __mq.get_mut(&__values[..]) { if !unconstrained { *result.multiplicity += G::ONE; } result.output[0] } else { let __ptr = G::from_usize(__mq.len()); __mq.insert(&__values[..], &[__ptr], G::from_bool(!unconstrained)); __ptr } }; - let __ret: [G; OUT_374] = [__v_9]; - if let Some(result) = record.function_queries[374].get_mut(&inp[..]) { debug_assert_eq!(result.output, &__ret[..]); if !unconstrained { *result.multiplicity += G::ONE; } } else { record.function_queries[374].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained)); }; + let __ret: [G; OUT_370] = [__v_9]; + if let Some(result) = record.function_queries[370].get_mut(&inp[..]) { debug_assert_eq!(result.output, &__ret[..]); if !unconstrained { *result.multiplicity += G::ONE; } } else { record.function_queries[370].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained)); }; return Ok(__ret); }, 2u64 => { let __v_7: G = G::from_u64(2); let __v_8: G = G::from_u64(0); let __v_9: G = { let __values: [G; 4] = [__v_7, __v_4, __v_5, __v_8]; let __mq = record.memory_queries.get_mut(&4).ok_or(ExecError::InvalidMemorySize(4))?; if let Some(result) = __mq.get_mut(&__values[..]) { if !unconstrained { *result.multiplicity += G::ONE; } result.output[0] } else { let __ptr = G::from_usize(__mq.len()); __mq.insert(&__values[..], &[__ptr], G::from_bool(!unconstrained)); __ptr } }; - let __ret: [G; OUT_374] = [__v_9]; - if let Some(result) = record.function_queries[374].get_mut(&inp[..]) { debug_assert_eq!(result.output, &__ret[..]); if !unconstrained { *result.multiplicity += G::ONE; } } else { record.function_queries[374].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained)); }; + let __ret: [G; OUT_370] = [__v_9]; + if let Some(result) = record.function_queries[370].get_mut(&inp[..]) { debug_assert_eq!(result.output, &__ret[..]); if !unconstrained { *result.multiplicity += G::ONE; } } else { record.function_queries[370].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained)); }; return Ok(__ret); }, 3u64 => { let __v_7: G = G::from_u64(3); - let __r_arr: [G; OUT_372] = { let __args: [G; IN_372] = [__v_4, __v_1, __v_2]; let __cu = unconstrained; if let Some(result) = record.function_queries[372].get_mut(&__args[..]) { if !__cu && *result.multiplicity == G::ZERO { aiur_fn_372(__args, record, io_buffer, false)? } else { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_372] = unsafe { *(result.output.as_ptr() as *const [G; OUT_372]) }; __ret } } else { aiur_fn_372(__args, record, io_buffer, __cu)? } }; + let __r_arr: [G; OUT_368] = { let __args: [G; IN_368] = [__v_4, __v_1, __v_2]; let __cu = unconstrained; if let Some(result) = record.function_queries[368].get_mut(&__args[..]) { if !__cu && *result.multiplicity == G::ZERO { aiur_fn_368(__args, record, io_buffer, false)? } else { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_368] = unsafe { *(result.output.as_ptr() as *const [G; OUT_368]) }; __ret } } else { aiur_fn_368(__args, record, io_buffer, __cu)? } }; let __v_8: G = __r_arr[0]; - let __r_arr: [G; OUT_372] = { let __args: [G; IN_372] = [__v_5, __v_1, __v_2]; let __cu = unconstrained; if let Some(result) = record.function_queries[372].get_mut(&__args[..]) { if !__cu && *result.multiplicity == G::ZERO { aiur_fn_372(__args, record, io_buffer, false)? } else { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_372] = unsafe { *(result.output.as_ptr() as *const [G; OUT_372]) }; __ret } } else { aiur_fn_372(__args, record, io_buffer, __cu)? } }; + let __r_arr: [G; OUT_368] = { let __args: [G; IN_368] = [__v_5, __v_1, __v_2]; let __cu = unconstrained; if let Some(result) = record.function_queries[368].get_mut(&__args[..]) { if !__cu && *result.multiplicity == G::ZERO { aiur_fn_368(__args, record, io_buffer, false)? } else { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_368] = unsafe { *(result.output.as_ptr() as *const [G; OUT_368]) }; __ret } } else { aiur_fn_368(__args, record, io_buffer, __cu)? } }; let __v_9: G = __r_arr[0]; let __v_10: G = G::from_u64(0); let __v_11: G = { let __values: [G; 4] = [__v_7, __v_8, __v_9, __v_10]; let __mq = record.memory_queries.get_mut(&4).ok_or(ExecError::InvalidMemorySize(4))?; if let Some(result) = __mq.get_mut(&__values[..]) { if !unconstrained { *result.multiplicity += G::ONE; } result.output[0] } else { let __ptr = G::from_usize(__mq.len()); __mq.insert(&__values[..], &[__ptr], G::from_bool(!unconstrained)); __ptr } }; - let __ret: [G; OUT_374] = [__v_11]; - if let Some(result) = record.function_queries[374].get_mut(&inp[..]) { debug_assert_eq!(result.output, &__ret[..]); if !unconstrained { *result.multiplicity += G::ONE; } } else { record.function_queries[374].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained)); }; + let __ret: [G; OUT_370] = [__v_11]; + if let Some(result) = record.function_queries[370].get_mut(&inp[..]) { debug_assert_eq!(result.output, &__ret[..]); if !unconstrained { *result.multiplicity += G::ONE; } } else { record.function_queries[370].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained)); }; return Ok(__ret); }, 4u64 => { let __v_7: G = G::from_u64(4); - let __r_arr: [G; OUT_372] = { let __args: [G; IN_372] = [__v_4, __v_1, __v_2]; let __cu = unconstrained; if let Some(result) = record.function_queries[372].get_mut(&__args[..]) { if !__cu && *result.multiplicity == G::ZERO { aiur_fn_372(__args, record, io_buffer, false)? } else { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_372] = unsafe { *(result.output.as_ptr() as *const [G; OUT_372]) }; __ret } } else { aiur_fn_372(__args, record, io_buffer, __cu)? } }; + let __r_arr: [G; OUT_368] = { let __args: [G; IN_368] = [__v_4, __v_1, __v_2]; let __cu = unconstrained; if let Some(result) = record.function_queries[368].get_mut(&__args[..]) { if !__cu && *result.multiplicity == G::ZERO { aiur_fn_368(__args, record, io_buffer, false)? } else { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_368] = unsafe { *(result.output.as_ptr() as *const [G; OUT_368]) }; __ret } } else { aiur_fn_368(__args, record, io_buffer, __cu)? } }; let __v_8: G = __r_arr[0]; let __v_9: G = G::from_u64(1); let __v_10: G = (__v_2 + __v_9); - let __r_arr: [G; OUT_372] = { let __args: [G; IN_372] = [__v_5, __v_1, __v_10]; let __cu = unconstrained; if let Some(result) = record.function_queries[372].get_mut(&__args[..]) { if !__cu && *result.multiplicity == G::ZERO { aiur_fn_372(__args, record, io_buffer, false)? } else { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_372] = unsafe { *(result.output.as_ptr() as *const [G; OUT_372]) }; __ret } } else { aiur_fn_372(__args, record, io_buffer, __cu)? } }; + let __r_arr: [G; OUT_368] = { let __args: [G; IN_368] = [__v_5, __v_1, __v_10]; let __cu = unconstrained; if let Some(result) = record.function_queries[368].get_mut(&__args[..]) { if !__cu && *result.multiplicity == G::ZERO { aiur_fn_368(__args, record, io_buffer, false)? } else { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_368] = unsafe { *(result.output.as_ptr() as *const [G; OUT_368]) }; __ret } } else { aiur_fn_368(__args, record, io_buffer, __cu)? } }; let __v_11: G = __r_arr[0]; let __v_12: G = G::from_u64(0); let __v_13: G = { let __values: [G; 4] = [__v_7, __v_8, __v_11, __v_12]; let __mq = record.memory_queries.get_mut(&4).ok_or(ExecError::InvalidMemorySize(4))?; if let Some(result) = __mq.get_mut(&__values[..]) { if !unconstrained { *result.multiplicity += G::ONE; } result.output[0] } else { let __ptr = G::from_usize(__mq.len()); __mq.insert(&__values[..], &[__ptr], G::from_bool(!unconstrained)); __ptr } }; - let __ret: [G; OUT_374] = [__v_13]; - if let Some(result) = record.function_queries[374].get_mut(&inp[..]) { debug_assert_eq!(result.output, &__ret[..]); if !unconstrained { *result.multiplicity += G::ONE; } } else { record.function_queries[374].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained)); }; + let __ret: [G; OUT_370] = [__v_13]; + if let Some(result) = record.function_queries[370].get_mut(&inp[..]) { debug_assert_eq!(result.output, &__ret[..]); if !unconstrained { *result.multiplicity += G::ONE; } } else { record.function_queries[370].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained)); }; return Ok(__ret); }, 5u64 => { let __v_7: G = G::from_u64(5); - let __r_arr: [G; OUT_372] = { let __args: [G; IN_372] = [__v_4, __v_1, __v_2]; let __cu = unconstrained; if let Some(result) = record.function_queries[372].get_mut(&__args[..]) { if !__cu && *result.multiplicity == G::ZERO { aiur_fn_372(__args, record, io_buffer, false)? } else { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_372] = unsafe { *(result.output.as_ptr() as *const [G; OUT_372]) }; __ret } } else { aiur_fn_372(__args, record, io_buffer, __cu)? } }; + let __r_arr: [G; OUT_368] = { let __args: [G; IN_368] = [__v_4, __v_1, __v_2]; let __cu = unconstrained; if let Some(result) = record.function_queries[368].get_mut(&__args[..]) { if !__cu && *result.multiplicity == G::ZERO { aiur_fn_368(__args, record, io_buffer, false)? } else { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_368] = unsafe { *(result.output.as_ptr() as *const [G; OUT_368]) }; __ret } } else { aiur_fn_368(__args, record, io_buffer, __cu)? } }; let __v_8: G = __r_arr[0]; let __v_9: G = G::from_u64(1); let __v_10: G = (__v_2 + __v_9); - let __r_arr: [G; OUT_372] = { let __args: [G; IN_372] = [__v_5, __v_1, __v_10]; let __cu = unconstrained; if let Some(result) = record.function_queries[372].get_mut(&__args[..]) { if !__cu && *result.multiplicity == G::ZERO { aiur_fn_372(__args, record, io_buffer, false)? } else { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_372] = unsafe { *(result.output.as_ptr() as *const [G; OUT_372]) }; __ret } } else { aiur_fn_372(__args, record, io_buffer, __cu)? } }; + let __r_arr: [G; OUT_368] = { let __args: [G; IN_368] = [__v_5, __v_1, __v_10]; let __cu = unconstrained; if let Some(result) = record.function_queries[368].get_mut(&__args[..]) { if !__cu && *result.multiplicity == G::ZERO { aiur_fn_368(__args, record, io_buffer, false)? } else { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_368] = unsafe { *(result.output.as_ptr() as *const [G; OUT_368]) }; __ret } } else { aiur_fn_368(__args, record, io_buffer, __cu)? } }; let __v_11: G = __r_arr[0]; let __v_12: G = G::from_u64(0); let __v_13: G = { let __values: [G; 4] = [__v_7, __v_8, __v_11, __v_12]; let __mq = record.memory_queries.get_mut(&4).ok_or(ExecError::InvalidMemorySize(4))?; if let Some(result) = __mq.get_mut(&__values[..]) { if !unconstrained { *result.multiplicity += G::ONE; } result.output[0] } else { let __ptr = G::from_usize(__mq.len()); __mq.insert(&__values[..], &[__ptr], G::from_bool(!unconstrained)); __ptr } }; - let __ret: [G; OUT_374] = [__v_13]; - if let Some(result) = record.function_queries[374].get_mut(&inp[..]) { debug_assert_eq!(result.output, &__ret[..]); if !unconstrained { *result.multiplicity += G::ONE; } } else { record.function_queries[374].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained)); }; + let __ret: [G; OUT_370] = [__v_13]; + if let Some(result) = record.function_queries[370].get_mut(&inp[..]) { debug_assert_eq!(result.output, &__ret[..]); if !unconstrained { *result.multiplicity += G::ONE; } } else { record.function_queries[370].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained)); }; return Ok(__ret); }, 6u64 => { - let __r_arr: [G; OUT_375] = { let __args: [G; IN_375] = [__v_4, __v_5, __v_6, __v_1, __v_2]; let __cu = unconstrained; if let Some(result) = record.function_queries[375].get_mut(&__args[..]) { if !__cu && *result.multiplicity == G::ZERO { aiur_fn_375(__args, record, io_buffer, false)? } else { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_375] = unsafe { *(result.output.as_ptr() as *const [G; OUT_375]) }; __ret } } else { aiur_fn_375(__args, record, io_buffer, __cu)? } }; + let __r_arr: [G; OUT_371] = { let __args: [G; IN_371] = [__v_4, __v_5, __v_6, __v_1, __v_2]; let __cu = unconstrained; if let Some(result) = record.function_queries[371].get_mut(&__args[..]) { if !__cu && *result.multiplicity == G::ZERO { aiur_fn_371(__args, record, io_buffer, false)? } else { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_371] = unsafe { *(result.output.as_ptr() as *const [G; OUT_371]) }; __ret } } else { aiur_fn_371(__args, record, io_buffer, __cu)? } }; let __v_7: G = __r_arr[0]; - let __ret: [G; OUT_374] = [__v_7]; - if let Some(result) = record.function_queries[374].get_mut(&inp[..]) { debug_assert_eq!(result.output, &__ret[..]); if !unconstrained { *result.multiplicity += G::ONE; } } else { record.function_queries[374].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained)); }; + let __ret: [G; OUT_370] = [__v_7]; + if let Some(result) = record.function_queries[370].get_mut(&inp[..]) { debug_assert_eq!(result.output, &__ret[..]); if !unconstrained { *result.multiplicity += G::ONE; } } else { record.function_queries[370].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained)); }; return Ok(__ret); }, 7u64 => { let __v_7: G = G::from_u64(7); let __v_8: G = G::from_u64(0); let __v_9: G = { let __values: [G; 4] = [__v_7, __v_4, __v_5, __v_8]; let __mq = record.memory_queries.get_mut(&4).ok_or(ExecError::InvalidMemorySize(4))?; if let Some(result) = __mq.get_mut(&__values[..]) { if !unconstrained { *result.multiplicity += G::ONE; } result.output[0] } else { let __ptr = G::from_usize(__mq.len()); __mq.insert(&__values[..], &[__ptr], G::from_bool(!unconstrained)); __ptr } }; - let __ret: [G; OUT_374] = [__v_9]; - if let Some(result) = record.function_queries[374].get_mut(&inp[..]) { debug_assert_eq!(result.output, &__ret[..]); if !unconstrained { *result.multiplicity += G::ONE; } } else { record.function_queries[374].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained)); }; + let __ret: [G; OUT_370] = [__v_9]; + if let Some(result) = record.function_queries[370].get_mut(&inp[..]) { debug_assert_eq!(result.output, &__ret[..]); if !unconstrained { *result.multiplicity += G::ONE; } } else { record.function_queries[370].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained)); }; return Ok(__ret); }, 8u64 => { let __v_7: G = G::from_u64(8); - let __r_arr: [G; OUT_372] = { let __args: [G; IN_372] = [__v_6, __v_1, __v_2]; let __cu = unconstrained; if let Some(result) = record.function_queries[372].get_mut(&__args[..]) { if !__cu && *result.multiplicity == G::ZERO { aiur_fn_372(__args, record, io_buffer, false)? } else { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_372] = unsafe { *(result.output.as_ptr() as *const [G; OUT_372]) }; __ret } } else { aiur_fn_372(__args, record, io_buffer, __cu)? } }; + let __r_arr: [G; OUT_368] = { let __args: [G; IN_368] = [__v_6, __v_1, __v_2]; let __cu = unconstrained; if let Some(result) = record.function_queries[368].get_mut(&__args[..]) { if !__cu && *result.multiplicity == G::ZERO { aiur_fn_368(__args, record, io_buffer, false)? } else { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_368] = unsafe { *(result.output.as_ptr() as *const [G; OUT_368]) }; __ret } } else { aiur_fn_368(__args, record, io_buffer, __cu)? } }; let __v_8: G = __r_arr[0]; let __v_9: G = { let __values: [G; 4] = [__v_7, __v_4, __v_5, __v_8]; let __mq = record.memory_queries.get_mut(&4).ok_or(ExecError::InvalidMemorySize(4))?; if let Some(result) = __mq.get_mut(&__values[..]) { if !unconstrained { *result.multiplicity += G::ONE; } result.output[0] } else { let __ptr = G::from_usize(__mq.len()); __mq.insert(&__values[..], &[__ptr], G::from_bool(!unconstrained)); __ptr } }; - let __ret: [G; OUT_374] = [__v_9]; - if let Some(result) = record.function_queries[374].get_mut(&inp[..]) { debug_assert_eq!(result.output, &__ret[..]); if !unconstrained { *result.multiplicity += G::ONE; } } else { record.function_queries[374].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained)); }; + let __ret: [G; OUT_370] = [__v_9]; + if let Some(result) = record.function_queries[370].get_mut(&inp[..]) { debug_assert_eq!(result.output, &__ret[..]); if !unconstrained { *result.multiplicity += G::ONE; } } else { record.function_queries[370].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained)); }; return Ok(__ret); }, _ => { @@ -33678,15 +33404,15 @@ fn aiur_fn_374( }) } -const INPUT_SIZE_375: usize = 5; -const IN_375: usize = 5; -const OUT_375: usize = 1; -fn aiur_fn_375( - inp: [G; IN_375], +const INPUT_SIZE_371: usize = 5; +const IN_371: usize = 5; +const OUT_371: usize = 1; +fn aiur_fn_371( + inp: [G; IN_371], record: &mut QueryRecord, io_buffer: &mut IOBuffer, unconstrained: bool, -) -> Result<[G; OUT_375], ExecError> { +) -> Result<[G; OUT_371], ExecError> { stacker::maybe_grow(64 * 1024, 4 * 1024 * 1024, || { let __v_0: G = inp[0]; let __v_1: G = inp[1]; @@ -33694,30 +33420,30 @@ fn aiur_fn_375( let __v_3: G = inp[3]; let __v_4: G = inp[4]; let __v_5: G = G::from_u64(6); - let __r_arr: [G; OUT_372] = { let __args: [G; IN_372] = [__v_0, __v_3, __v_4]; let __cu = unconstrained; if let Some(result) = record.function_queries[372].get_mut(&__args[..]) { if !__cu && *result.multiplicity == G::ZERO { aiur_fn_372(__args, record, io_buffer, false)? } else { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_372] = unsafe { *(result.output.as_ptr() as *const [G; OUT_372]) }; __ret } } else { aiur_fn_372(__args, record, io_buffer, __cu)? } }; + let __r_arr: [G; OUT_368] = { let __args: [G; IN_368] = [__v_0, __v_3, __v_4]; let __cu = unconstrained; if let Some(result) = record.function_queries[368].get_mut(&__args[..]) { if !__cu && *result.multiplicity == G::ZERO { aiur_fn_368(__args, record, io_buffer, false)? } else { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_368] = unsafe { *(result.output.as_ptr() as *const [G; OUT_368]) }; __ret } } else { aiur_fn_368(__args, record, io_buffer, __cu)? } }; let __v_6: G = __r_arr[0]; - let __r_arr: [G; OUT_372] = { let __args: [G; IN_372] = [__v_1, __v_3, __v_4]; let __cu = unconstrained; if let Some(result) = record.function_queries[372].get_mut(&__args[..]) { if !__cu && *result.multiplicity == G::ZERO { aiur_fn_372(__args, record, io_buffer, false)? } else { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_372] = unsafe { *(result.output.as_ptr() as *const [G; OUT_372]) }; __ret } } else { aiur_fn_372(__args, record, io_buffer, __cu)? } }; + let __r_arr: [G; OUT_368] = { let __args: [G; IN_368] = [__v_1, __v_3, __v_4]; let __cu = unconstrained; if let Some(result) = record.function_queries[368].get_mut(&__args[..]) { if !__cu && *result.multiplicity == G::ZERO { aiur_fn_368(__args, record, io_buffer, false)? } else { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_368] = unsafe { *(result.output.as_ptr() as *const [G; OUT_368]) }; __ret } } else { aiur_fn_368(__args, record, io_buffer, __cu)? } }; let __v_7: G = __r_arr[0]; let __v_8: G = G::from_u64(1); let __v_9: G = (__v_4 + __v_8); - let __r_arr: [G; OUT_372] = { let __args: [G; IN_372] = [__v_2, __v_3, __v_9]; let __cu = unconstrained; if let Some(result) = record.function_queries[372].get_mut(&__args[..]) { if !__cu && *result.multiplicity == G::ZERO { aiur_fn_372(__args, record, io_buffer, false)? } else { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_372] = unsafe { *(result.output.as_ptr() as *const [G; OUT_372]) }; __ret } } else { aiur_fn_372(__args, record, io_buffer, __cu)? } }; + let __r_arr: [G; OUT_368] = { let __args: [G; IN_368] = [__v_2, __v_3, __v_9]; let __cu = unconstrained; if let Some(result) = record.function_queries[368].get_mut(&__args[..]) { if !__cu && *result.multiplicity == G::ZERO { aiur_fn_368(__args, record, io_buffer, false)? } else { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_368] = unsafe { *(result.output.as_ptr() as *const [G; OUT_368]) }; __ret } } else { aiur_fn_368(__args, record, io_buffer, __cu)? } }; let __v_10: G = __r_arr[0]; let __v_11: G = { let __values: [G; 4] = [__v_5, __v_6, __v_7, __v_10]; let __mq = record.memory_queries.get_mut(&4).ok_or(ExecError::InvalidMemorySize(4))?; if let Some(result) = __mq.get_mut(&__values[..]) { if !unconstrained { *result.multiplicity += G::ONE; } result.output[0] } else { let __ptr = G::from_usize(__mq.len()); __mq.insert(&__values[..], &[__ptr], G::from_bool(!unconstrained)); __ptr } }; - let __ret: [G; OUT_375] = [__v_11]; - if let Some(result) = record.function_queries[375].get_mut(&inp[..]) { debug_assert_eq!(result.output, &__ret[..]); if !unconstrained { *result.multiplicity += G::ONE; } } else { record.function_queries[375].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained)); }; + let __ret: [G; OUT_371] = [__v_11]; + if let Some(result) = record.function_queries[371].get_mut(&inp[..]) { debug_assert_eq!(result.output, &__ret[..]); if !unconstrained { *result.multiplicity += G::ONE; } } else { record.function_queries[371].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained)); }; return Ok(__ret); }) } -const INPUT_SIZE_376: usize = 3; -const IN_376: usize = 3; -const OUT_376: usize = 3; -fn aiur_fn_376( - inp: [G; IN_376], +const INPUT_SIZE_372: usize = 3; +const IN_372: usize = 3; +const OUT_372: usize = 3; +fn aiur_fn_372( + inp: [G; IN_372], record: &mut QueryRecord, io_buffer: &mut IOBuffer, unconstrained: bool, -) -> Result<[G; OUT_376], ExecError> { +) -> Result<[G; OUT_372], ExecError> { stacker::maybe_grow(64 * 1024, 4 * 1024 * 1024, || { let __v_0: G = inp[0]; let __v_1: G = inp[1]; @@ -33737,17 +33463,17 @@ fn aiur_fn_376( 0u64 => { let __v_10: G = G::from_u64(0); let __v_11: G = { let __values: [G; 3] = [__v_10, __v_8, __v_2]; let __mq = record.memory_queries.get_mut(&3).ok_or(ExecError::InvalidMemorySize(3))?; if let Some(result) = __mq.get_mut(&__values[..]) { if !unconstrained { *result.multiplicity += G::ONE; } result.output[0] } else { let __ptr = G::from_usize(__mq.len()); __mq.insert(&__values[..], &[__ptr], G::from_bool(!unconstrained)); __ptr } }; - let __r_arr: [G; OUT_376] = { let __args: [G; IN_376] = [__v_5, __v_9, __v_11]; let __cu = unconstrained; if let Some(result) = record.function_queries[376].get_mut(&__args[..]) { if !__cu && *result.multiplicity == G::ZERO { aiur_fn_376(__args, record, io_buffer, false)? } else { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_376] = unsafe { *(result.output.as_ptr() as *const [G; OUT_376]) }; __ret } } else { aiur_fn_376(__args, record, io_buffer, __cu)? } }; + let __r_arr: [G; OUT_372] = { let __args: [G; IN_372] = [__v_5, __v_9, __v_11]; let __cu = unconstrained; if let Some(result) = record.function_queries[372].get_mut(&__args[..]) { if !__cu && *result.multiplicity == G::ZERO { aiur_fn_372(__args, record, io_buffer, false)? } else { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_372] = unsafe { *(result.output.as_ptr() as *const [G; OUT_372]) }; __ret } } else { aiur_fn_372(__args, record, io_buffer, __cu)? } }; let __v_12: G = __r_arr[0]; let __v_13: G = __r_arr[1]; let __v_14: G = __r_arr[2]; - let __ret: [G; OUT_376] = [__v_12, __v_13, __v_14]; - if let Some(result) = record.function_queries[376].get_mut(&inp[..]) { debug_assert_eq!(result.output, &__ret[..]); if !unconstrained { *result.multiplicity += G::ONE; } } else { record.function_queries[376].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained)); }; + let __ret: [G; OUT_372] = [__v_12, __v_13, __v_14]; + if let Some(result) = record.function_queries[372].get_mut(&inp[..]) { debug_assert_eq!(result.output, &__ret[..]); if !unconstrained { *result.multiplicity += G::ONE; } } else { record.function_queries[372].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained)); }; return Ok(__ret); }, 1u64 => { - let __ret: [G; OUT_376] = [__v_0, __v_2, __v_1]; - if let Some(result) = record.function_queries[376].get_mut(&inp[..]) { debug_assert_eq!(result.output, &__ret[..]); if !unconstrained { *result.multiplicity += G::ONE; } } else { record.function_queries[376].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained)); }; + let __ret: [G; OUT_372] = [__v_0, __v_2, __v_1]; + if let Some(result) = record.function_queries[372].get_mut(&inp[..]) { debug_assert_eq!(result.output, &__ret[..]); if !unconstrained { *result.multiplicity += G::ONE; } } else { record.function_queries[372].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained)); }; return Ok(__ret); }, _ => { @@ -33756,23 +33482,23 @@ fn aiur_fn_376( } }, _ => { - let __ret: [G; OUT_376] = [__v_0, __v_2, __v_1]; - if let Some(result) = record.function_queries[376].get_mut(&inp[..]) { debug_assert_eq!(result.output, &__ret[..]); if !unconstrained { *result.multiplicity += G::ONE; } } else { record.function_queries[376].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained)); }; + let __ret: [G; OUT_372] = [__v_0, __v_2, __v_1]; + if let Some(result) = record.function_queries[372].get_mut(&inp[..]) { debug_assert_eq!(result.output, &__ret[..]); if !unconstrained { *result.multiplicity += G::ONE; } } else { record.function_queries[372].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained)); }; return Ok(__ret); }, } }) } -const INPUT_SIZE_377: usize = 3; -const IN_377: usize = 3; -const OUT_377: usize = 1; -fn aiur_fn_377( - inp: [G; IN_377], +const INPUT_SIZE_373: usize = 3; +const IN_373: usize = 3; +const OUT_373: usize = 1; +fn aiur_fn_373( + inp: [G; IN_373], record: &mut QueryRecord, io_buffer: &mut IOBuffer, unconstrained: bool, -) -> Result<[G; OUT_377], ExecError> { +) -> Result<[G; OUT_373], ExecError> { stacker::maybe_grow(64 * 1024, 4 * 1024 * 1024, || { let __v_0: G = inp[0]; let __v_1: G = inp[1]; @@ -33780,56 +33506,56 @@ fn aiur_fn_377( let __v_3: G = G::from_u64(1); let __v_4: G = G::from_u64(1); let __v_5: G = { let __values: [G; 3] = [__v_3, __v_4, __v_4]; let __mq = record.memory_queries.get_mut(&3).ok_or(ExecError::InvalidMemorySize(3))?; if let Some(result) = __mq.get_mut(&__values[..]) { if !unconstrained { *result.multiplicity += G::ONE; } result.output[0] } else { let __ptr = G::from_usize(__mq.len()); __mq.insert(&__values[..], &[__ptr], G::from_bool(!unconstrained)); __ptr } }; - let __r_arr: [G; OUT_376] = { let __args: [G; IN_376] = [__v_1, __v_0, __v_5]; let __cu = unconstrained; if let Some(result) = record.function_queries[376].get_mut(&__args[..]) { if !__cu && *result.multiplicity == G::ZERO { aiur_fn_376(__args, record, io_buffer, false)? } else { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_376] = unsafe { *(result.output.as_ptr() as *const [G; OUT_376]) }; __ret } } else { aiur_fn_376(__args, record, io_buffer, __cu)? } }; + let __r_arr: [G; OUT_372] = { let __args: [G; IN_372] = [__v_1, __v_0, __v_5]; let __cu = unconstrained; if let Some(result) = record.function_queries[372].get_mut(&__args[..]) { if !__cu && *result.multiplicity == G::ZERO { aiur_fn_372(__args, record, io_buffer, false)? } else { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_372] = unsafe { *(result.output.as_ptr() as *const [G; OUT_372]) }; __ret } } else { aiur_fn_372(__args, record, io_buffer, __cu)? } }; let __v_6: G = __r_arr[0]; let __v_7: G = __r_arr[1]; let __v_8: G = __r_arr[2]; - let __r_arr: [G; OUT_764] = { let __args: [G; IN_764] = [__v_7]; let __cu = unconstrained; if let Some(result) = record.function_queries[764].get_mut(&__args[..]) { if !__cu && *result.multiplicity == G::ZERO { aiur_fn_764(__args, record, io_buffer, false)? } else { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_764] = unsafe { *(result.output.as_ptr() as *const [G; OUT_764]) }; __ret } } else { aiur_fn_764(__args, record, io_buffer, __cu)? } }; + let __r_arr: [G; OUT_760] = { let __args: [G; IN_760] = [__v_7]; let __cu = unconstrained; if let Some(result) = record.function_queries[760].get_mut(&__args[..]) { if !__cu && *result.multiplicity == G::ZERO { aiur_fn_760(__args, record, io_buffer, false)? } else { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_760] = unsafe { *(result.output.as_ptr() as *const [G; OUT_760]) }; __ret } } else { aiur_fn_760(__args, record, io_buffer, __cu)? } }; let __v_9: G = __r_arr[0]; match __v_9.as_canonical_u64() { 0u64 => { - let __r_arr: [G; OUT_255] = { let __args: [G; IN_255] = [__v_1, __v_0]; let __cu = unconstrained; if let Some(result) = record.function_queries[255].get_mut(&__args[..]) { if !__cu && *result.multiplicity == G::ZERO { aiur_fn_255(__args, record, io_buffer, false)? } else { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_255] = unsafe { *(result.output.as_ptr() as *const [G; OUT_255]) }; __ret } } else { aiur_fn_255(__args, record, io_buffer, __cu)? } }; + let __r_arr: [G; OUT_251] = { let __args: [G; IN_251] = [__v_1, __v_0]; let __cu = unconstrained; if let Some(result) = record.function_queries[251].get_mut(&__args[..]) { if !__cu && *result.multiplicity == G::ZERO { aiur_fn_251(__args, record, io_buffer, false)? } else { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_251] = unsafe { *(result.output.as_ptr() as *const [G; OUT_251]) }; __ret } } else { aiur_fn_251(__args, record, io_buffer, __cu)? } }; let __v_10: G = __r_arr[0]; - let __ret: [G; OUT_377] = [__v_10]; - if let Some(result) = record.function_queries[377].get_mut(&inp[..]) { debug_assert_eq!(result.output, &__ret[..]); if !unconstrained { *result.multiplicity += G::ONE; } } else { record.function_queries[377].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained)); }; + let __ret: [G; OUT_373] = [__v_10]; + if let Some(result) = record.function_queries[373].get_mut(&inp[..]) { debug_assert_eq!(result.output, &__ret[..]); if !unconstrained { *result.multiplicity += G::ONE; } } else { record.function_queries[373].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained)); }; return Ok(__ret); }, 1u64 => { let __v_10: G = G::from_u64(0); - let __r_arr: [G; OUT_766] = { let __args: [G; IN_766] = [__v_7, __v_10]; let __cu = unconstrained; if let Some(result) = record.function_queries[766].get_mut(&__args[..]) { if !__cu && *result.multiplicity == G::ZERO { aiur_fn_766(__args, record, io_buffer, false)? } else { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_766] = unsafe { *(result.output.as_ptr() as *const [G; OUT_766]) }; __ret } } else { aiur_fn_766(__args, record, io_buffer, __cu)? } }; + let __r_arr: [G; OUT_762] = { let __args: [G; IN_762] = [__v_7, __v_10]; let __cu = unconstrained; if let Some(result) = record.function_queries[762].get_mut(&__args[..]) { if !__cu && *result.multiplicity == G::ZERO { aiur_fn_762(__args, record, io_buffer, false)? } else { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_762] = unsafe { *(result.output.as_ptr() as *const [G; OUT_762]) }; __ret } } else { aiur_fn_762(__args, record, io_buffer, __cu)? } }; let __v_11: G = __r_arr[0]; let __v_12: G = G::from_u64(0); - let __r_arr: [G; OUT_368] = { let __args: [G; IN_368] = [__v_6, __v_11, __v_12]; let __cu = unconstrained; if let Some(result) = record.function_queries[368].get_mut(&__args[..]) { if !__cu && *result.multiplicity == G::ZERO { aiur_fn_368(__args, record, io_buffer, false)? } else { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_368] = unsafe { *(result.output.as_ptr() as *const [G; OUT_368]) }; __ret } } else { aiur_fn_368(__args, record, io_buffer, __cu)? } }; + let __r_arr: [G; OUT_364] = { let __args: [G; IN_364] = [__v_6, __v_11, __v_12]; let __cu = unconstrained; if let Some(result) = record.function_queries[364].get_mut(&__args[..]) { if !__cu && *result.multiplicity == G::ZERO { aiur_fn_364(__args, record, io_buffer, false)? } else { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_364] = unsafe { *(result.output.as_ptr() as *const [G; OUT_364]) }; __ret } } else { aiur_fn_364(__args, record, io_buffer, __cu)? } }; let __v_13: G = __r_arr[0]; - let __r_arr: [G; OUT_378] = { let __args: [G; IN_378] = [__v_13, __v_8, __v_2]; let __cu = unconstrained; if let Some(result) = record.function_queries[378].get_mut(&__args[..]) { if !__cu && *result.multiplicity == G::ZERO { aiur_fn_378(__args, record, io_buffer, false)? } else { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_378] = unsafe { *(result.output.as_ptr() as *const [G; OUT_378]) }; __ret } } else { aiur_fn_378(__args, record, io_buffer, __cu)? } }; + let __r_arr: [G; OUT_374] = { let __args: [G; IN_374] = [__v_13, __v_8, __v_2]; let __cu = unconstrained; if let Some(result) = record.function_queries[374].get_mut(&__args[..]) { if !__cu && *result.multiplicity == G::ZERO { aiur_fn_374(__args, record, io_buffer, false)? } else { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_374] = unsafe { *(result.output.as_ptr() as *const [G; OUT_374]) }; __ret } } else { aiur_fn_374(__args, record, io_buffer, __cu)? } }; let __v_14: G = __r_arr[0]; - let __ret: [G; OUT_377] = [__v_14]; - if let Some(result) = record.function_queries[377].get_mut(&inp[..]) { debug_assert_eq!(result.output, &__ret[..]); if !unconstrained { *result.multiplicity += G::ONE; } } else { record.function_queries[377].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained)); }; + let __ret: [G; OUT_373] = [__v_14]; + if let Some(result) = record.function_queries[373].get_mut(&inp[..]) { debug_assert_eq!(result.output, &__ret[..]); if !unconstrained { *result.multiplicity += G::ONE; } } else { record.function_queries[373].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained)); }; return Ok(__ret); }, _ => { let __v_10: G = G::from_u64(0); - let __r_arr: [G; OUT_372] = { let __args: [G; IN_372] = [__v_6, __v_7, __v_10]; let __cu = unconstrained; if let Some(result) = record.function_queries[372].get_mut(&__args[..]) { if !__cu && *result.multiplicity == G::ZERO { aiur_fn_372(__args, record, io_buffer, false)? } else { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_372] = unsafe { *(result.output.as_ptr() as *const [G; OUT_372]) }; __ret } } else { aiur_fn_372(__args, record, io_buffer, __cu)? } }; + let __r_arr: [G; OUT_368] = { let __args: [G; IN_368] = [__v_6, __v_7, __v_10]; let __cu = unconstrained; if let Some(result) = record.function_queries[368].get_mut(&__args[..]) { if !__cu && *result.multiplicity == G::ZERO { aiur_fn_368(__args, record, io_buffer, false)? } else { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_368] = unsafe { *(result.output.as_ptr() as *const [G; OUT_368]) }; __ret } } else { aiur_fn_368(__args, record, io_buffer, __cu)? } }; let __v_11: G = __r_arr[0]; - let __r_arr: [G; OUT_378] = { let __args: [G; IN_378] = [__v_11, __v_8, __v_2]; let __cu = unconstrained; if let Some(result) = record.function_queries[378].get_mut(&__args[..]) { if !__cu && *result.multiplicity == G::ZERO { aiur_fn_378(__args, record, io_buffer, false)? } else { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_378] = unsafe { *(result.output.as_ptr() as *const [G; OUT_378]) }; __ret } } else { aiur_fn_378(__args, record, io_buffer, __cu)? } }; + let __r_arr: [G; OUT_374] = { let __args: [G; IN_374] = [__v_11, __v_8, __v_2]; let __cu = unconstrained; if let Some(result) = record.function_queries[374].get_mut(&__args[..]) { if !__cu && *result.multiplicity == G::ZERO { aiur_fn_374(__args, record, io_buffer, false)? } else { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_374] = unsafe { *(result.output.as_ptr() as *const [G; OUT_374]) }; __ret } } else { aiur_fn_374(__args, record, io_buffer, __cu)? } }; let __v_12: G = __r_arr[0]; - let __ret: [G; OUT_377] = [__v_12]; - if let Some(result) = record.function_queries[377].get_mut(&inp[..]) { debug_assert_eq!(result.output, &__ret[..]); if !unconstrained { *result.multiplicity += G::ONE; } } else { record.function_queries[377].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained)); }; + let __ret: [G; OUT_373] = [__v_12]; + if let Some(result) = record.function_queries[373].get_mut(&inp[..]) { debug_assert_eq!(result.output, &__ret[..]); if !unconstrained { *result.multiplicity += G::ONE; } } else { record.function_queries[373].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained)); }; return Ok(__ret); }, } }) } -const INPUT_SIZE_378: usize = 3; -const IN_378: usize = 3; -const OUT_378: usize = 1; -fn aiur_fn_378( - inp: [G; IN_378], +const INPUT_SIZE_374: usize = 3; +const IN_374: usize = 3; +const OUT_374: usize = 1; +fn aiur_fn_374( + inp: [G; IN_374], record: &mut QueryRecord, io_buffer: &mut IOBuffer, unconstrained: bool, -) -> Result<[G; OUT_378], ExecError> { +) -> Result<[G; OUT_374], ExecError> { stacker::maybe_grow(64 * 1024, 4 * 1024 * 1024, || { let __v_0: G = inp[0]; let __v_1: G = inp[1]; @@ -33844,87 +33570,87 @@ fn aiur_fn_378( let __r_arr: [G; OUT_111] = { let __args: [G; IN_111] = [__v_0]; let __cu = unconstrained; if let Some(result) = record.function_queries[111].get_mut(&__args[..]) { if !__cu && *result.multiplicity == G::ZERO { aiur_fn_111(__args, record, io_buffer, false)? } else { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_111] = unsafe { *(result.output.as_ptr() as *const [G; OUT_111]) }; __ret } } else { aiur_fn_111(__args, record, io_buffer, __cu)? } }; let __v_7: G = __r_arr[0]; let __v_8: G = __r_arr[1]; - let __r_arr: [G; OUT_763] = { let __args: [G; IN_763] = [__v_8, __v_1]; let __cu = unconstrained; if let Some(result) = record.function_queries[763].get_mut(&__args[..]) { if !__cu && *result.multiplicity == G::ZERO { aiur_fn_763(__args, record, io_buffer, false)? } else { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_763] = unsafe { *(result.output.as_ptr() as *const [G; OUT_763]) }; __ret } } else { aiur_fn_763(__args, record, io_buffer, __cu)? } }; + let __r_arr: [G; OUT_759] = { let __args: [G; IN_759] = [__v_8, __v_1]; let __cu = unconstrained; if let Some(result) = record.function_queries[759].get_mut(&__args[..]) { if !__cu && *result.multiplicity == G::ZERO { aiur_fn_759(__args, record, io_buffer, false)? } else { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_759] = unsafe { *(result.output.as_ptr() as *const [G; OUT_759]) }; __ret } } else { aiur_fn_759(__args, record, io_buffer, __cu)? } }; let __v_9: G = __r_arr[0]; - let __r_arr: [G; OUT_378] = { let __args: [G; IN_378] = [__v_7, __v_9, __v_2]; let __cu = unconstrained; if let Some(result) = record.function_queries[378].get_mut(&__args[..]) { if !__cu && *result.multiplicity == G::ZERO { aiur_fn_378(__args, record, io_buffer, false)? } else { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_378] = unsafe { *(result.output.as_ptr() as *const [G; OUT_378]) }; __ret } } else { aiur_fn_378(__args, record, io_buffer, __cu)? } }; + let __r_arr: [G; OUT_374] = { let __args: [G; IN_374] = [__v_7, __v_9, __v_2]; let __cu = unconstrained; if let Some(result) = record.function_queries[374].get_mut(&__args[..]) { if !__cu && *result.multiplicity == G::ZERO { aiur_fn_374(__args, record, io_buffer, false)? } else { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_374] = unsafe { *(result.output.as_ptr() as *const [G; OUT_374]) }; __ret } } else { aiur_fn_374(__args, record, io_buffer, __cu)? } }; let __v_10: G = __r_arr[0]; - let __ret: [G; OUT_378] = [__v_10]; - if let Some(result) = record.function_queries[378].get_mut(&inp[..]) { debug_assert_eq!(result.output, &__ret[..]); if !unconstrained { *result.multiplicity += G::ONE; } } else { record.function_queries[378].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained)); }; + let __ret: [G; OUT_374] = [__v_10]; + if let Some(result) = record.function_queries[374].get_mut(&inp[..]) { debug_assert_eq!(result.output, &__ret[..]); if !unconstrained { *result.multiplicity += G::ONE; } } else { record.function_queries[374].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained)); }; return Ok(__ret); }, 4u64 => { - let __r_arr: [G; OUT_377] = { let __args: [G; IN_377] = [__v_1, __v_0, __v_2]; let __cu = unconstrained; if let Some(result) = record.function_queries[377].get_mut(&__args[..]) { if !__cu && *result.multiplicity == G::ZERO { aiur_fn_377(__args, record, io_buffer, false)? } else { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_377] = unsafe { *(result.output.as_ptr() as *const [G; OUT_377]) }; __ret } } else { aiur_fn_377(__args, record, io_buffer, __cu)? } }; + let __r_arr: [G; OUT_373] = { let __args: [G; IN_373] = [__v_1, __v_0, __v_2]; let __cu = unconstrained; if let Some(result) = record.function_queries[373].get_mut(&__args[..]) { if !__cu && *result.multiplicity == G::ZERO { aiur_fn_373(__args, record, io_buffer, false)? } else { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_373] = unsafe { *(result.output.as_ptr() as *const [G; OUT_373]) }; __ret } } else { aiur_fn_373(__args, record, io_buffer, __cu)? } }; let __v_7: G = __r_arr[0]; - let __ret: [G; OUT_378] = [__v_7]; - if let Some(result) = record.function_queries[378].get_mut(&inp[..]) { debug_assert_eq!(result.output, &__ret[..]); if !unconstrained { *result.multiplicity += G::ONE; } } else { record.function_queries[378].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained)); }; + let __ret: [G; OUT_374] = [__v_7]; + if let Some(result) = record.function_queries[374].get_mut(&inp[..]) { debug_assert_eq!(result.output, &__ret[..]); if !unconstrained { *result.multiplicity += G::ONE; } } else { record.function_queries[374].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained)); }; return Ok(__ret); }, 2u64 => { - let __r_arr: [G; OUT_397] = { let __args: [G; IN_397] = [__v_4, __v_5, __v_0, __v_1, __v_2]; let __cu = unconstrained; if let Some(result) = record.function_queries[397].get_mut(&__args[..]) { if !__cu && *result.multiplicity == G::ZERO { aiur_fn_397(__args, record, io_buffer, false)? } else { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_397] = unsafe { *(result.output.as_ptr() as *const [G; OUT_397]) }; __ret } } else { aiur_fn_397(__args, record, io_buffer, __cu)? } }; + let __r_arr: [G; OUT_393] = { let __args: [G; IN_393] = [__v_4, __v_5, __v_0, __v_1, __v_2]; let __cu = unconstrained; if let Some(result) = record.function_queries[393].get_mut(&__args[..]) { if !__cu && *result.multiplicity == G::ZERO { aiur_fn_393(__args, record, io_buffer, false)? } else { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_393] = unsafe { *(result.output.as_ptr() as *const [G; OUT_393]) }; __ret } } else { aiur_fn_393(__args, record, io_buffer, __cu)? } }; let __v_7: G = __r_arr[0]; - let __ret: [G; OUT_378] = [__v_7]; - if let Some(result) = record.function_queries[378].get_mut(&inp[..]) { debug_assert_eq!(result.output, &__ret[..]); if !unconstrained { *result.multiplicity += G::ONE; } } else { record.function_queries[378].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained)); }; + let __ret: [G; OUT_374] = [__v_7]; + if let Some(result) = record.function_queries[374].get_mut(&inp[..]) { debug_assert_eq!(result.output, &__ret[..]); if !unconstrained { *result.multiplicity += G::ONE; } } else { record.function_queries[374].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained)); }; return Ok(__ret); }, 6u64 => { let __v_7: G = G::from_u64(0); - let __r_arr: [G; OUT_368] = { let __args: [G; IN_368] = [__v_6, __v_5, __v_7]; let __cu = unconstrained; if let Some(result) = record.function_queries[368].get_mut(&__args[..]) { if !__cu && *result.multiplicity == G::ZERO { aiur_fn_368(__args, record, io_buffer, false)? } else { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_368] = unsafe { *(result.output.as_ptr() as *const [G; OUT_368]) }; __ret } } else { aiur_fn_368(__args, record, io_buffer, __cu)? } }; + let __r_arr: [G; OUT_364] = { let __args: [G; IN_364] = [__v_6, __v_5, __v_7]; let __cu = unconstrained; if let Some(result) = record.function_queries[364].get_mut(&__args[..]) { if !__cu && *result.multiplicity == G::ZERO { aiur_fn_364(__args, record, io_buffer, false)? } else { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_364] = unsafe { *(result.output.as_ptr() as *const [G; OUT_364]) }; __ret } } else { aiur_fn_364(__args, record, io_buffer, __cu)? } }; let __v_8: G = __r_arr[0]; - let __r_arr: [G; OUT_378] = { let __args: [G; IN_378] = [__v_8, __v_1, __v_2]; let __cu = unconstrained; if let Some(result) = record.function_queries[378].get_mut(&__args[..]) { if !__cu && *result.multiplicity == G::ZERO { aiur_fn_378(__args, record, io_buffer, false)? } else { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_378] = unsafe { *(result.output.as_ptr() as *const [G; OUT_378]) }; __ret } } else { aiur_fn_378(__args, record, io_buffer, __cu)? } }; + let __r_arr: [G; OUT_374] = { let __args: [G; IN_374] = [__v_8, __v_1, __v_2]; let __cu = unconstrained; if let Some(result) = record.function_queries[374].get_mut(&__args[..]) { if !__cu && *result.multiplicity == G::ZERO { aiur_fn_374(__args, record, io_buffer, false)? } else { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_374] = unsafe { *(result.output.as_ptr() as *const [G; OUT_374]) }; __ret } } else { aiur_fn_374(__args, record, io_buffer, __cu)? } }; let __v_9: G = __r_arr[0]; - let __ret: [G; OUT_378] = [__v_9]; - if let Some(result) = record.function_queries[378].get_mut(&inp[..]) { debug_assert_eq!(result.output, &__ret[..]); if !unconstrained { *result.multiplicity += G::ONE; } } else { record.function_queries[378].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained)); }; + let __ret: [G; OUT_374] = [__v_9]; + if let Some(result) = record.function_queries[374].get_mut(&inp[..]) { debug_assert_eq!(result.output, &__ret[..]); if !unconstrained { *result.multiplicity += G::ONE; } } else { record.function_queries[374].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained)); }; return Ok(__ret); }, 8u64 => { - let __r_arr: [G; OUT_379] = { let __args: [G; IN_379] = [__v_4, __v_5, __v_6, __v_1, __v_2]; let __cu = unconstrained; if let Some(result) = record.function_queries[379].get_mut(&__args[..]) { if !__cu && *result.multiplicity == G::ZERO { aiur_fn_379(__args, record, io_buffer, false)? } else { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_379] = unsafe { *(result.output.as_ptr() as *const [G; OUT_379]) }; __ret } } else { aiur_fn_379(__args, record, io_buffer, __cu)? } }; + let __r_arr: [G; OUT_375] = { let __args: [G; IN_375] = [__v_4, __v_5, __v_6, __v_1, __v_2]; let __cu = unconstrained; if let Some(result) = record.function_queries[375].get_mut(&__args[..]) { if !__cu && *result.multiplicity == G::ZERO { aiur_fn_375(__args, record, io_buffer, false)? } else { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_375] = unsafe { *(result.output.as_ptr() as *const [G; OUT_375]) }; __ret } } else { aiur_fn_375(__args, record, io_buffer, __cu)? } }; let __v_7: G = __r_arr[0]; - let __ret: [G; OUT_378] = [__v_7]; - if let Some(result) = record.function_queries[378].get_mut(&inp[..]) { debug_assert_eq!(result.output, &__ret[..]); if !unconstrained { *result.multiplicity += G::ONE; } } else { record.function_queries[378].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained)); }; + let __ret: [G; OUT_374] = [__v_7]; + if let Some(result) = record.function_queries[374].get_mut(&inp[..]) { debug_assert_eq!(result.output, &__ret[..]); if !unconstrained { *result.multiplicity += G::ONE; } } else { record.function_queries[374].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained)); }; return Ok(__ret); }, _ => { - let __r_arr: [G; OUT_255] = { let __args: [G; IN_255] = [__v_0, __v_1]; let __cu = unconstrained; if let Some(result) = record.function_queries[255].get_mut(&__args[..]) { if !__cu && *result.multiplicity == G::ZERO { aiur_fn_255(__args, record, io_buffer, false)? } else { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_255] = unsafe { *(result.output.as_ptr() as *const [G; OUT_255]) }; __ret } } else { aiur_fn_255(__args, record, io_buffer, __cu)? } }; + let __r_arr: [G; OUT_251] = { let __args: [G; IN_251] = [__v_0, __v_1]; let __cu = unconstrained; if let Some(result) = record.function_queries[251].get_mut(&__args[..]) { if !__cu && *result.multiplicity == G::ZERO { aiur_fn_251(__args, record, io_buffer, false)? } else { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_251] = unsafe { *(result.output.as_ptr() as *const [G; OUT_251]) }; __ret } } else { aiur_fn_251(__args, record, io_buffer, __cu)? } }; let __v_7: G = __r_arr[0]; - let __ret: [G; OUT_378] = [__v_7]; - if let Some(result) = record.function_queries[378].get_mut(&inp[..]) { debug_assert_eq!(result.output, &__ret[..]); if !unconstrained { *result.multiplicity += G::ONE; } } else { record.function_queries[378].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained)); }; + let __ret: [G; OUT_374] = [__v_7]; + if let Some(result) = record.function_queries[374].get_mut(&inp[..]) { debug_assert_eq!(result.output, &__ret[..]); if !unconstrained { *result.multiplicity += G::ONE; } } else { record.function_queries[374].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained)); }; return Ok(__ret); }, } }) } -const INPUT_SIZE_379: usize = 5; -const IN_379: usize = 5; -const OUT_379: usize = 1; -fn aiur_fn_379( - inp: [G; IN_379], +const INPUT_SIZE_375: usize = 5; +const IN_375: usize = 5; +const OUT_375: usize = 1; +fn aiur_fn_375( + inp: [G; IN_375], record: &mut QueryRecord, io_buffer: &mut IOBuffer, unconstrained: bool, -) -> Result<[G; OUT_379], ExecError> { +) -> Result<[G; OUT_375], ExecError> { stacker::maybe_grow(64 * 1024, 4 * 1024 * 1024, || { let __v_0: G = inp[0]; let __v_1: G = inp[1]; let __v_2: G = inp[2]; let __v_3: G = inp[3]; let __v_4: G = inp[4]; - let __r_arr: [G; OUT_418] = { let __args: [G; IN_418] = [__v_2, __v_4]; let __cu = unconstrained; if let Some(result) = record.function_queries[418].get_mut(&__args[..]) { if !__cu && *result.multiplicity == G::ZERO { aiur_fn_418(__args, record, io_buffer, false)? } else { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_418] = unsafe { *(result.output.as_ptr() as *const [G; OUT_418]) }; __ret } } else { aiur_fn_418(__args, record, io_buffer, __cu)? } }; + let __r_arr: [G; OUT_414] = { let __args: [G; IN_414] = [__v_2, __v_4]; let __cu = unconstrained; if let Some(result) = record.function_queries[414].get_mut(&__args[..]) { if !__cu && *result.multiplicity == G::ZERO { aiur_fn_414(__args, record, io_buffer, false)? } else { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_414] = unsafe { *(result.output.as_ptr() as *const [G; OUT_414]) }; __ret } } else { aiur_fn_414(__args, record, io_buffer, __cu)? } }; let __v_5: G = __r_arr[0]; - let __r_arr: [G; OUT_231] = { let __args: [G; IN_231] = [__v_5, __v_4]; let __cu = unconstrained; if let Some(result) = record.function_queries[231].get_mut(&__args[..]) { if !__cu && *result.multiplicity == G::ZERO { aiur_fn_231(__args, record, io_buffer, false)? } else { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_231] = unsafe { *(result.output.as_ptr() as *const [G; OUT_231]) }; __ret } } else { aiur_fn_231(__args, record, io_buffer, __cu)? } }; + let __r_arr: [G; OUT_227] = { let __args: [G; IN_227] = [__v_5, __v_4]; let __cu = unconstrained; if let Some(result) = record.function_queries[227].get_mut(&__args[..]) { if !__cu && *result.multiplicity == G::ZERO { aiur_fn_227(__args, record, io_buffer, false)? } else { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_227] = unsafe { *(result.output.as_ptr() as *const [G; OUT_227]) }; __ret } } else { aiur_fn_227(__args, record, io_buffer, __cu)? } }; let __v_6: G = __r_arr[0]; let __r_arr: [G; OUT_111] = { let __args: [G; IN_111] = [__v_6]; let __cu = unconstrained; if let Some(result) = record.function_queries[111].get_mut(&__args[..]) { if !__cu && *result.multiplicity == G::ZERO { aiur_fn_111(__args, record, io_buffer, false)? } else { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_111] = unsafe { *(result.output.as_ptr() as *const [G; OUT_111]) }; __ret } } else { aiur_fn_111(__args, record, io_buffer, __cu)? } }; let __v_7: G = __r_arr[0]; let __v_8: G = __r_arr[1]; - let __r_arr: [G; OUT_386] = { let __args: [G; IN_386] = [__v_0, __v_1, __v_7, __v_8]; let __cu = unconstrained; if let Some(result) = record.function_queries[386].get_mut(&__args[..]) { if !__cu && *result.multiplicity == G::ZERO { aiur_fn_386(__args, record, io_buffer, false)? } else { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_386] = unsafe { *(result.output.as_ptr() as *const [G; OUT_386]) }; __ret } } else { aiur_fn_386(__args, record, io_buffer, __cu)? } }; + let __r_arr: [G; OUT_382] = { let __args: [G; IN_382] = [__v_0, __v_1, __v_7, __v_8]; let __cu = unconstrained; if let Some(result) = record.function_queries[382].get_mut(&__args[..]) { if !__cu && *result.multiplicity == G::ZERO { aiur_fn_382(__args, record, io_buffer, false)? } else { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_382] = unsafe { *(result.output.as_ptr() as *const [G; OUT_382]) }; __ret } } else { aiur_fn_382(__args, record, io_buffer, __cu)? } }; let __v_9: G = __r_arr[0]; let __v_10: G = __r_arr[1]; match __v_9.as_canonical_u64() { 1u64 => { - let __r_arr: [G; OUT_378] = { let __args: [G; IN_378] = [__v_10, __v_3, __v_4]; let __cu = unconstrained; if let Some(result) = record.function_queries[378].get_mut(&__args[..]) { if !__cu && *result.multiplicity == G::ZERO { aiur_fn_378(__args, record, io_buffer, false)? } else { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_378] = unsafe { *(result.output.as_ptr() as *const [G; OUT_378]) }; __ret } } else { aiur_fn_378(__args, record, io_buffer, __cu)? } }; + let __r_arr: [G; OUT_374] = { let __args: [G; IN_374] = [__v_10, __v_3, __v_4]; let __cu = unconstrained; if let Some(result) = record.function_queries[374].get_mut(&__args[..]) { if !__cu && *result.multiplicity == G::ZERO { aiur_fn_374(__args, record, io_buffer, false)? } else { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_374] = unsafe { *(result.output.as_ptr() as *const [G; OUT_374]) }; __ret } } else { aiur_fn_374(__args, record, io_buffer, __cu)? } }; let __v_11: G = __r_arr[0]; - let __ret: [G; OUT_379] = [__v_11]; - if let Some(result) = record.function_queries[379].get_mut(&inp[..]) { debug_assert_eq!(result.output, &__ret[..]); if !unconstrained { *result.multiplicity += G::ONE; } } else { record.function_queries[379].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained)); }; + let __ret: [G; OUT_375] = [__v_11]; + if let Some(result) = record.function_queries[375].get_mut(&inp[..]) { debug_assert_eq!(result.output, &__ret[..]); if !unconstrained { *result.multiplicity += G::ONE; } } else { record.function_queries[375].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained)); }; return Ok(__ret); }, _ => { @@ -33935,7 +33661,7 @@ fn aiur_fn_379( let __v_14: G = __loaded[3]; match __v_11.as_canonical_u64() { 2u64 => { - let __r_arr: [G; OUT_387] = { let __args: [G; IN_387] = [__v_7]; let __cu = unconstrained; if let Some(result) = record.function_queries[387].get_mut(&__args[..]) { if !__cu && *result.multiplicity == G::ZERO { aiur_fn_387(__args, record, io_buffer, false)? } else { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_387] = unsafe { *(result.output.as_ptr() as *const [G; OUT_387]) }; __ret } } else { aiur_fn_387(__args, record, io_buffer, __cu)? } }; + let __r_arr: [G; OUT_383] = { let __args: [G; IN_383] = [__v_7]; let __cu = unconstrained; if let Some(result) = record.function_queries[383].get_mut(&__args[..]) { if !__cu && *result.multiplicity == G::ZERO { aiur_fn_383(__args, record, io_buffer, false)? } else { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_383] = unsafe { *(result.output.as_ptr() as *const [G; OUT_383]) }; __ret } } else { aiur_fn_383(__args, record, io_buffer, __cu)? } }; let __v_15: G = __r_arr[0]; let __loaded: [G; 12] = { let __mq = record.memory_queries.get_mut(&12).ok_or(ExecError::InvalidMemorySize(12))?; let __ptr_u64 = __v_15.as_canonical_u64(); let __ptr_usize = usize::try_from(__ptr_u64).ok().ok_or(ExecError::PointerTooLarge(__ptr_u64))?; let (__args, __mult) = __mq.get_index_mut(__ptr_usize).ok_or(ExecError::UnboundPointer { ptr: __ptr_u64, size: 12 })?; if !unconstrained { *__mult += G::ONE; } let __arr: [G; 12] = __args[..12].try_into().unwrap(); __arr }; let __v_16: G = __loaded[0]; @@ -33953,21 +33679,21 @@ fn aiur_fn_379( match __v_16.as_canonical_u64() { 6u64 => { let __v_28: G = (__v_22 + __v_1); - let __r_arr: [G; OUT_766] = { let __args: [G; IN_766] = [__v_8, __v_28]; let __cu = unconstrained; if let Some(result) = record.function_queries[766].get_mut(&__args[..]) { if !__cu && *result.multiplicity == G::ZERO { aiur_fn_766(__args, record, io_buffer, false)? } else { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_766] = unsafe { *(result.output.as_ptr() as *const [G; OUT_766]) }; __ret } } else { aiur_fn_766(__args, record, io_buffer, __cu)? } }; + let __r_arr: [G; OUT_762] = { let __args: [G; IN_762] = [__v_8, __v_28]; let __cu = unconstrained; if let Some(result) = record.function_queries[762].get_mut(&__args[..]) { if !__cu && *result.multiplicity == G::ZERO { aiur_fn_762(__args, record, io_buffer, false)? } else { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_762] = unsafe { *(result.output.as_ptr() as *const [G; OUT_762]) }; __ret } } else { aiur_fn_762(__args, record, io_buffer, __cu)? } }; let __v_29: G = __r_arr[0]; - let __r_arr: [G; OUT_378] = { let __args: [G; IN_378] = [__v_29, __v_3, __v_4]; let __cu = unconstrained; if let Some(result) = record.function_queries[378].get_mut(&__args[..]) { if !__cu && *result.multiplicity == G::ZERO { aiur_fn_378(__args, record, io_buffer, false)? } else { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_378] = unsafe { *(result.output.as_ptr() as *const [G; OUT_378]) }; __ret } } else { aiur_fn_378(__args, record, io_buffer, __cu)? } }; + let __r_arr: [G; OUT_374] = { let __args: [G; IN_374] = [__v_29, __v_3, __v_4]; let __cu = unconstrained; if let Some(result) = record.function_queries[374].get_mut(&__args[..]) { if !__cu && *result.multiplicity == G::ZERO { aiur_fn_374(__args, record, io_buffer, false)? } else { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_374] = unsafe { *(result.output.as_ptr() as *const [G; OUT_374]) }; __ret } } else { aiur_fn_374(__args, record, io_buffer, __cu)? } }; let __v_30: G = __r_arr[0]; - let __ret: [G; OUT_379] = [__v_30]; - if let Some(result) = record.function_queries[379].get_mut(&inp[..]) { debug_assert_eq!(result.output, &__ret[..]); if !unconstrained { *result.multiplicity += G::ONE; } } else { record.function_queries[379].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained)); }; + let __ret: [G; OUT_375] = [__v_30]; + if let Some(result) = record.function_queries[375].get_mut(&inp[..]) { debug_assert_eq!(result.output, &__ret[..]); if !unconstrained { *result.multiplicity += G::ONE; } } else { record.function_queries[375].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained)); }; return Ok(__ret); }, _ => { let __v_28: G = G::from_u64(8); let __v_29: G = { let __values: [G; 4] = [__v_28, __v_0, __v_1, __v_5]; let __mq = record.memory_queries.get_mut(&4).ok_or(ExecError::InvalidMemorySize(4))?; if let Some(result) = __mq.get_mut(&__values[..]) { if !unconstrained { *result.multiplicity += G::ONE; } result.output[0] } else { let __ptr = G::from_usize(__mq.len()); __mq.insert(&__values[..], &[__ptr], G::from_bool(!unconstrained)); __ptr } }; - let __r_arr: [G; OUT_255] = { let __args: [G; IN_255] = [__v_29, __v_3]; let __cu = unconstrained; if let Some(result) = record.function_queries[255].get_mut(&__args[..]) { if !__cu && *result.multiplicity == G::ZERO { aiur_fn_255(__args, record, io_buffer, false)? } else { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_255] = unsafe { *(result.output.as_ptr() as *const [G; OUT_255]) }; __ret } } else { aiur_fn_255(__args, record, io_buffer, __cu)? } }; + let __r_arr: [G; OUT_251] = { let __args: [G; IN_251] = [__v_29, __v_3]; let __cu = unconstrained; if let Some(result) = record.function_queries[251].get_mut(&__args[..]) { if !__cu && *result.multiplicity == G::ZERO { aiur_fn_251(__args, record, io_buffer, false)? } else { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_251] = unsafe { *(result.output.as_ptr() as *const [G; OUT_251]) }; __ret } } else { aiur_fn_251(__args, record, io_buffer, __cu)? } }; let __v_30: G = __r_arr[0]; - let __ret: [G; OUT_379] = [__v_30]; - if let Some(result) = record.function_queries[379].get_mut(&inp[..]) { debug_assert_eq!(result.output, &__ret[..]); if !unconstrained { *result.multiplicity += G::ONE; } } else { record.function_queries[379].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained)); }; + let __ret: [G; OUT_375] = [__v_30]; + if let Some(result) = record.function_queries[375].get_mut(&inp[..]) { debug_assert_eq!(result.output, &__ret[..]); if !unconstrained { *result.multiplicity += G::ONE; } } else { record.function_queries[375].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained)); }; return Ok(__ret); }, } @@ -33975,10 +33701,10 @@ fn aiur_fn_379( _ => { let __v_15: G = G::from_u64(8); let __v_16: G = { let __values: [G; 4] = [__v_15, __v_0, __v_1, __v_5]; let __mq = record.memory_queries.get_mut(&4).ok_or(ExecError::InvalidMemorySize(4))?; if let Some(result) = __mq.get_mut(&__values[..]) { if !unconstrained { *result.multiplicity += G::ONE; } result.output[0] } else { let __ptr = G::from_usize(__mq.len()); __mq.insert(&__values[..], &[__ptr], G::from_bool(!unconstrained)); __ptr } }; - let __r_arr: [G; OUT_255] = { let __args: [G; IN_255] = [__v_16, __v_3]; let __cu = unconstrained; if let Some(result) = record.function_queries[255].get_mut(&__args[..]) { if !__cu && *result.multiplicity == G::ZERO { aiur_fn_255(__args, record, io_buffer, false)? } else { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_255] = unsafe { *(result.output.as_ptr() as *const [G; OUT_255]) }; __ret } } else { aiur_fn_255(__args, record, io_buffer, __cu)? } }; + let __r_arr: [G; OUT_251] = { let __args: [G; IN_251] = [__v_16, __v_3]; let __cu = unconstrained; if let Some(result) = record.function_queries[251].get_mut(&__args[..]) { if !__cu && *result.multiplicity == G::ZERO { aiur_fn_251(__args, record, io_buffer, false)? } else { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_251] = unsafe { *(result.output.as_ptr() as *const [G; OUT_251]) }; __ret } } else { aiur_fn_251(__args, record, io_buffer, __cu)? } }; let __v_17: G = __r_arr[0]; - let __ret: [G; OUT_379] = [__v_17]; - if let Some(result) = record.function_queries[379].get_mut(&inp[..]) { debug_assert_eq!(result.output, &__ret[..]); if !unconstrained { *result.multiplicity += G::ONE; } } else { record.function_queries[379].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained)); }; + let __ret: [G; OUT_375] = [__v_17]; + if let Some(result) = record.function_queries[375].get_mut(&inp[..]) { debug_assert_eq!(result.output, &__ret[..]); if !unconstrained { *result.multiplicity += G::ONE; } } else { record.function_queries[375].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained)); }; return Ok(__ret); }, } @@ -33987,15 +33713,15 @@ fn aiur_fn_379( }) } -const INPUT_SIZE_380: usize = 0; -const IN_380: usize = 0; -const OUT_380: usize = 1; -fn aiur_fn_380( - inp: [G; IN_380], +const INPUT_SIZE_376: usize = 0; +const IN_376: usize = 0; +const OUT_376: usize = 1; +fn aiur_fn_376( + inp: [G; IN_376], record: &mut QueryRecord, io_buffer: &mut IOBuffer, unconstrained: bool, -) -> Result<[G; OUT_380], ExecError> { +) -> Result<[G; OUT_376], ExecError> { stacker::maybe_grow(64 * 1024, 4 * 1024 * 1024, || { let __v_0: G = G::from_u64(116); let __v_1: G = G::from_u64(89); @@ -34030,21 +33756,21 @@ fn aiur_fn_380( let __v_30: G = G::from_u64(91); let __v_31: G = G::from_u64(151); let __v_32: G = { let __values: [G; 32] = [__v_0, __v_1, __v_2, __v_3, __v_4, __v_5, __v_6, __v_7, __v_8, __v_9, __v_10, __v_11, __v_12, __v_13, __v_14, __v_15, __v_16, __v_17, __v_18, __v_19, __v_20, __v_21, __v_22, __v_23, __v_24, __v_25, __v_26, __v_27, __v_28, __v_29, __v_30, __v_31]; let __mq = record.memory_queries.get_mut(&32).ok_or(ExecError::InvalidMemorySize(32))?; if let Some(result) = __mq.get_mut(&__values[..]) { if !unconstrained { *result.multiplicity += G::ONE; } result.output[0] } else { let __ptr = G::from_usize(__mq.len()); __mq.insert(&__values[..], &[__ptr], G::from_bool(!unconstrained)); __ptr } }; - let __ret: [G; OUT_380] = [__v_32]; - if let Some(result) = record.function_queries[380].get_mut(&inp[..]) { debug_assert_eq!(result.output, &__ret[..]); if !unconstrained { *result.multiplicity += G::ONE; } } else { record.function_queries[380].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained)); }; + let __ret: [G; OUT_376] = [__v_32]; + if let Some(result) = record.function_queries[376].get_mut(&inp[..]) { debug_assert_eq!(result.output, &__ret[..]); if !unconstrained { *result.multiplicity += G::ONE; } } else { record.function_queries[376].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained)); }; return Ok(__ret); }) } -const INPUT_SIZE_381: usize = 0; -const IN_381: usize = 0; -const OUT_381: usize = 1; -fn aiur_fn_381( - inp: [G; IN_381], +const INPUT_SIZE_377: usize = 0; +const IN_377: usize = 0; +const OUT_377: usize = 1; +fn aiur_fn_377( + inp: [G; IN_377], record: &mut QueryRecord, io_buffer: &mut IOBuffer, unconstrained: bool, -) -> Result<[G; OUT_381], ExecError> { +) -> Result<[G; OUT_377], ExecError> { stacker::maybe_grow(64 * 1024, 4 * 1024 * 1024, || { let __v_0: G = G::from_u64(171); let __v_1: G = G::from_u64(55); @@ -34079,21 +33805,21 @@ fn aiur_fn_381( let __v_30: G = G::from_u64(87); let __v_31: G = G::from_u64(25); let __v_32: G = { let __values: [G; 32] = [__v_0, __v_1, __v_2, __v_3, __v_4, __v_5, __v_6, __v_7, __v_8, __v_9, __v_10, __v_11, __v_12, __v_13, __v_14, __v_15, __v_16, __v_17, __v_18, __v_19, __v_20, __v_21, __v_22, __v_23, __v_24, __v_25, __v_26, __v_27, __v_28, __v_29, __v_30, __v_31]; let __mq = record.memory_queries.get_mut(&32).ok_or(ExecError::InvalidMemorySize(32))?; if let Some(result) = __mq.get_mut(&__values[..]) { if !unconstrained { *result.multiplicity += G::ONE; } result.output[0] } else { let __ptr = G::from_usize(__mq.len()); __mq.insert(&__values[..], &[__ptr], G::from_bool(!unconstrained)); __ptr } }; - let __ret: [G; OUT_381] = [__v_32]; - if let Some(result) = record.function_queries[381].get_mut(&inp[..]) { debug_assert_eq!(result.output, &__ret[..]); if !unconstrained { *result.multiplicity += G::ONE; } } else { record.function_queries[381].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained)); }; + let __ret: [G; OUT_377] = [__v_32]; + if let Some(result) = record.function_queries[377].get_mut(&inp[..]) { debug_assert_eq!(result.output, &__ret[..]); if !unconstrained { *result.multiplicity += G::ONE; } } else { record.function_queries[377].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained)); }; return Ok(__ret); }) } -const INPUT_SIZE_382: usize = 0; -const IN_382: usize = 0; -const OUT_382: usize = 1; -fn aiur_fn_382( - inp: [G; IN_382], +const INPUT_SIZE_378: usize = 0; +const IN_378: usize = 0; +const OUT_378: usize = 1; +fn aiur_fn_378( + inp: [G; IN_378], record: &mut QueryRecord, io_buffer: &mut IOBuffer, unconstrained: bool, -) -> Result<[G; OUT_382], ExecError> { +) -> Result<[G; OUT_378], ExecError> { stacker::maybe_grow(64 * 1024, 4 * 1024 * 1024, || { let __v_0: G = G::from_u64(57); let __v_1: G = G::from_u64(138); @@ -34128,21 +33854,21 @@ fn aiur_fn_382( let __v_30: G = G::from_u64(182); let __v_31: G = G::from_u64(49); let __v_32: G = { let __values: [G; 32] = [__v_0, __v_1, __v_2, __v_3, __v_4, __v_5, __v_6, __v_7, __v_8, __v_9, __v_10, __v_11, __v_12, __v_13, __v_14, __v_15, __v_16, __v_17, __v_18, __v_19, __v_20, __v_21, __v_22, __v_23, __v_24, __v_25, __v_26, __v_27, __v_28, __v_29, __v_30, __v_31]; let __mq = record.memory_queries.get_mut(&32).ok_or(ExecError::InvalidMemorySize(32))?; if let Some(result) = __mq.get_mut(&__values[..]) { if !unconstrained { *result.multiplicity += G::ONE; } result.output[0] } else { let __ptr = G::from_usize(__mq.len()); __mq.insert(&__values[..], &[__ptr], G::from_bool(!unconstrained)); __ptr } }; - let __ret: [G; OUT_382] = [__v_32]; - if let Some(result) = record.function_queries[382].get_mut(&inp[..]) { debug_assert_eq!(result.output, &__ret[..]); if !unconstrained { *result.multiplicity += G::ONE; } } else { record.function_queries[382].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained)); }; + let __ret: [G; OUT_378] = [__v_32]; + if let Some(result) = record.function_queries[378].get_mut(&inp[..]) { debug_assert_eq!(result.output, &__ret[..]); if !unconstrained { *result.multiplicity += G::ONE; } } else { record.function_queries[378].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained)); }; return Ok(__ret); }) } -const INPUT_SIZE_383: usize = 0; -const IN_383: usize = 0; -const OUT_383: usize = 1; -fn aiur_fn_383( - inp: [G; IN_383], +const INPUT_SIZE_379: usize = 0; +const IN_379: usize = 0; +const OUT_379: usize = 1; +fn aiur_fn_379( + inp: [G; IN_379], record: &mut QueryRecord, io_buffer: &mut IOBuffer, unconstrained: bool, -) -> Result<[G; OUT_383], ExecError> { +) -> Result<[G; OUT_379], ExecError> { stacker::maybe_grow(64 * 1024, 4 * 1024 * 1024, || { let __v_0: G = G::from_u64(136); let __v_1: G = G::from_u64(38); @@ -34177,21 +33903,21 @@ fn aiur_fn_383( let __v_30: G = G::from_u64(236); let __v_31: G = G::from_u64(246); let __v_32: G = { let __values: [G; 32] = [__v_0, __v_1, __v_2, __v_3, __v_4, __v_5, __v_6, __v_7, __v_8, __v_9, __v_10, __v_11, __v_12, __v_13, __v_14, __v_15, __v_16, __v_17, __v_18, __v_19, __v_20, __v_21, __v_22, __v_23, __v_24, __v_25, __v_26, __v_27, __v_28, __v_29, __v_30, __v_31]; let __mq = record.memory_queries.get_mut(&32).ok_or(ExecError::InvalidMemorySize(32))?; if let Some(result) = __mq.get_mut(&__values[..]) { if !unconstrained { *result.multiplicity += G::ONE; } result.output[0] } else { let __ptr = G::from_usize(__mq.len()); __mq.insert(&__values[..], &[__ptr], G::from_bool(!unconstrained)); __ptr } }; - let __ret: [G; OUT_383] = [__v_32]; - if let Some(result) = record.function_queries[383].get_mut(&inp[..]) { debug_assert_eq!(result.output, &__ret[..]); if !unconstrained { *result.multiplicity += G::ONE; } } else { record.function_queries[383].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained)); }; + let __ret: [G; OUT_379] = [__v_32]; + if let Some(result) = record.function_queries[379].get_mut(&inp[..]) { debug_assert_eq!(result.output, &__ret[..]); if !unconstrained { *result.multiplicity += G::ONE; } } else { record.function_queries[379].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained)); }; return Ok(__ret); }) } -const INPUT_SIZE_384: usize = 0; -const IN_384: usize = 0; -const OUT_384: usize = 1; -fn aiur_fn_384( - inp: [G; IN_384], +const INPUT_SIZE_380: usize = 0; +const IN_380: usize = 0; +const OUT_380: usize = 1; +fn aiur_fn_380( + inp: [G; IN_380], record: &mut QueryRecord, io_buffer: &mut IOBuffer, unconstrained: bool, -) -> Result<[G; OUT_384], ExecError> { +) -> Result<[G; OUT_380], ExecError> { stacker::maybe_grow(64 * 1024, 4 * 1024 * 1024, || { let __v_0: G = G::from_u64(141); let __v_1: G = G::from_u64(196); @@ -34226,21 +33952,21 @@ fn aiur_fn_384( let __v_30: G = G::from_u64(123); let __v_31: G = G::from_u64(208); let __v_32: G = { let __values: [G; 32] = [__v_0, __v_1, __v_2, __v_3, __v_4, __v_5, __v_6, __v_7, __v_8, __v_9, __v_10, __v_11, __v_12, __v_13, __v_14, __v_15, __v_16, __v_17, __v_18, __v_19, __v_20, __v_21, __v_22, __v_23, __v_24, __v_25, __v_26, __v_27, __v_28, __v_29, __v_30, __v_31]; let __mq = record.memory_queries.get_mut(&32).ok_or(ExecError::InvalidMemorySize(32))?; if let Some(result) = __mq.get_mut(&__values[..]) { if !unconstrained { *result.multiplicity += G::ONE; } result.output[0] } else { let __ptr = G::from_usize(__mq.len()); __mq.insert(&__values[..], &[__ptr], G::from_bool(!unconstrained)); __ptr } }; - let __ret: [G; OUT_384] = [__v_32]; - if let Some(result) = record.function_queries[384].get_mut(&inp[..]) { debug_assert_eq!(result.output, &__ret[..]); if !unconstrained { *result.multiplicity += G::ONE; } } else { record.function_queries[384].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained)); }; + let __ret: [G; OUT_380] = [__v_32]; + if let Some(result) = record.function_queries[380].get_mut(&inp[..]) { debug_assert_eq!(result.output, &__ret[..]); if !unconstrained { *result.multiplicity += G::ONE; } } else { record.function_queries[380].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained)); }; return Ok(__ret); }) } -const INPUT_SIZE_385: usize = 0; -const IN_385: usize = 0; -const OUT_385: usize = 1; -fn aiur_fn_385( - inp: [G; IN_385], +const INPUT_SIZE_381: usize = 0; +const IN_381: usize = 0; +const OUT_381: usize = 1; +fn aiur_fn_381( + inp: [G; IN_381], record: &mut QueryRecord, io_buffer: &mut IOBuffer, unconstrained: bool, -) -> Result<[G; OUT_385], ExecError> { +) -> Result<[G; OUT_381], ExecError> { stacker::maybe_grow(64 * 1024, 4 * 1024 * 1024, || { let __v_0: G = G::from_u64(18); let __v_1: G = G::from_u64(73); @@ -34275,27 +34001,27 @@ fn aiur_fn_385( let __v_30: G = G::from_u64(173); let __v_31: G = G::from_u64(22); let __v_32: G = { let __values: [G; 32] = [__v_0, __v_1, __v_2, __v_3, __v_4, __v_5, __v_6, __v_7, __v_8, __v_9, __v_10, __v_11, __v_12, __v_13, __v_14, __v_15, __v_16, __v_17, __v_18, __v_19, __v_20, __v_21, __v_22, __v_23, __v_24, __v_25, __v_26, __v_27, __v_28, __v_29, __v_30, __v_31]; let __mq = record.memory_queries.get_mut(&32).ok_or(ExecError::InvalidMemorySize(32))?; if let Some(result) = __mq.get_mut(&__values[..]) { if !unconstrained { *result.multiplicity += G::ONE; } result.output[0] } else { let __ptr = G::from_usize(__mq.len()); __mq.insert(&__values[..], &[__ptr], G::from_bool(!unconstrained)); __ptr } }; - let __ret: [G; OUT_385] = [__v_32]; - if let Some(result) = record.function_queries[385].get_mut(&inp[..]) { debug_assert_eq!(result.output, &__ret[..]); if !unconstrained { *result.multiplicity += G::ONE; } } else { record.function_queries[385].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained)); }; + let __ret: [G; OUT_381] = [__v_32]; + if let Some(result) = record.function_queries[381].get_mut(&inp[..]) { debug_assert_eq!(result.output, &__ret[..]); if !unconstrained { *result.multiplicity += G::ONE; } } else { record.function_queries[381].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained)); }; return Ok(__ret); }) } -const INPUT_SIZE_386: usize = 4; -const IN_386: usize = 4; -const OUT_386: usize = 2; -fn aiur_fn_386( - inp: [G; IN_386], +const INPUT_SIZE_382: usize = 4; +const IN_382: usize = 4; +const OUT_382: usize = 2; +fn aiur_fn_382( + inp: [G; IN_382], record: &mut QueryRecord, io_buffer: &mut IOBuffer, unconstrained: bool, -) -> Result<[G; OUT_386], ExecError> { +) -> Result<[G; OUT_382], ExecError> { stacker::maybe_grow(64 * 1024, 4 * 1024 * 1024, || { let __v_0: G = inp[0]; let __v_1: G = inp[1]; let __v_2: G = inp[2]; let __v_3: G = inp[3]; - let __r_arr: [G; OUT_380] = { let __args: [G; IN_380] = []; let __cu = unconstrained; if let Some(result) = record.function_queries[380].get_mut(&__args[..]) { if !__cu && *result.multiplicity == G::ZERO { aiur_fn_380(__args, record, io_buffer, false)? } else { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_380] = unsafe { *(result.output.as_ptr() as *const [G; OUT_380]) }; __ret } } else { aiur_fn_380(__args, record, io_buffer, __cu)? } }; + let __r_arr: [G; OUT_376] = { let __args: [G; IN_376] = []; let __cu = unconstrained; if let Some(result) = record.function_queries[376].get_mut(&__args[..]) { if !__cu && *result.multiplicity == G::ZERO { aiur_fn_376(__args, record, io_buffer, false)? } else { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_376] = unsafe { *(result.output.as_ptr() as *const [G; OUT_376]) }; __ret } } else { aiur_fn_376(__args, record, io_buffer, __cu)? } }; let __v_4: G = __r_arr[0]; let __r_arr: [G; OUT_1] = { let __args: [G; IN_1] = [__v_0, __v_4]; let __cu = unconstrained; if let Some(result) = record.function_queries[1].get_mut(&__args[..]) { if !__cu && *result.multiplicity == G::ZERO { aiur_fn_1(__args, record, io_buffer, false)? } else { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_1] = unsafe { *(result.output.as_ptr() as *const [G; OUT_1]) }; __ret } } else { aiur_fn_1(__args, record, io_buffer, __cu)? } }; let __v_5: G = __r_arr[0]; @@ -34306,8 +34032,8 @@ fn aiur_fn_386( let __v_8: G = G::from_u64(0); let __v_9: G = G::from_u64(0); let __v_10: G = { let __values: [G; 4] = [__v_7, __v_8, __v_9, __v_9]; let __mq = record.memory_queries.get_mut(&4).ok_or(ExecError::InvalidMemorySize(4))?; if let Some(result) = __mq.get_mut(&__values[..]) { if !unconstrained { *result.multiplicity += G::ONE; } result.output[0] } else { let __ptr = G::from_usize(__mq.len()); __mq.insert(&__values[..], &[__ptr], G::from_bool(!unconstrained)); __ptr } }; - let __ret: [G; OUT_386] = [__v_6, __v_10]; - if let Some(result) = record.function_queries[386].get_mut(&inp[..]) { debug_assert_eq!(result.output, &__ret[..]); if !unconstrained { *result.multiplicity += G::ONE; } } else { record.function_queries[386].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained)); }; + let __ret: [G; OUT_382] = [__v_6, __v_10]; + if let Some(result) = record.function_queries[382].get_mut(&inp[..]) { debug_assert_eq!(result.output, &__ret[..]); if !unconstrained { *result.multiplicity += G::ONE; } } else { record.function_queries[382].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained)); }; return Ok(__ret); }, _ => { @@ -34320,7 +34046,7 @@ fn aiur_fn_386( let __v_9: G = __loaded[3]; match __v_6.as_canonical_u64() { 2u64 => { - let __r_arr: [G; OUT_381] = { let __args: [G; IN_381] = []; let __cu = unconstrained; if let Some(result) = record.function_queries[381].get_mut(&__args[..]) { if !__cu && *result.multiplicity == G::ZERO { aiur_fn_381(__args, record, io_buffer, false)? } else { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_381] = unsafe { *(result.output.as_ptr() as *const [G; OUT_381]) }; __ret } } else { aiur_fn_381(__args, record, io_buffer, __cu)? } }; + let __r_arr: [G; OUT_377] = { let __args: [G; IN_377] = []; let __cu = unconstrained; if let Some(result) = record.function_queries[377].get_mut(&__args[..]) { if !__cu && *result.multiplicity == G::ZERO { aiur_fn_377(__args, record, io_buffer, false)? } else { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_377] = unsafe { *(result.output.as_ptr() as *const [G; OUT_377]) }; __ret } } else { aiur_fn_377(__args, record, io_buffer, __cu)? } }; let __v_10: G = __r_arr[0]; let __r_arr: [G; OUT_1] = { let __args: [G; IN_1] = [__v_7, __v_10]; let __cu = unconstrained; if let Some(result) = record.function_queries[1].get_mut(&__args[..]) { if !__cu && *result.multiplicity == G::ZERO { aiur_fn_1(__args, record, io_buffer, false)? } else { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_1] = unsafe { *(result.output.as_ptr() as *const [G; OUT_1]) }; __ret } } else { aiur_fn_1(__args, record, io_buffer, __cu)? } }; let __v_11: G = __r_arr[0]; @@ -34331,12 +34057,12 @@ fn aiur_fn_386( let __v_14: G = G::from_u64(0); let __v_15: G = G::from_u64(0); let __v_16: G = { let __values: [G; 4] = [__v_13, __v_14, __v_15, __v_15]; let __mq = record.memory_queries.get_mut(&4).ok_or(ExecError::InvalidMemorySize(4))?; if let Some(result) = __mq.get_mut(&__values[..]) { if !unconstrained { *result.multiplicity += G::ONE; } result.output[0] } else { let __ptr = G::from_usize(__mq.len()); __mq.insert(&__values[..], &[__ptr], G::from_bool(!unconstrained)); __ptr } }; - let __ret: [G; OUT_386] = [__v_12, __v_16]; - if let Some(result) = record.function_queries[386].get_mut(&inp[..]) { debug_assert_eq!(result.output, &__ret[..]); if !unconstrained { *result.multiplicity += G::ONE; } } else { record.function_queries[386].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained)); }; + let __ret: [G; OUT_382] = [__v_12, __v_16]; + if let Some(result) = record.function_queries[382].get_mut(&inp[..]) { debug_assert_eq!(result.output, &__ret[..]); if !unconstrained { *result.multiplicity += G::ONE; } } else { record.function_queries[382].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained)); }; return Ok(__ret); }, _ => { - let __r_arr: [G; OUT_764] = { let __args: [G; IN_764] = [__v_3]; let __cu = unconstrained; if let Some(result) = record.function_queries[764].get_mut(&__args[..]) { if !__cu && *result.multiplicity == G::ZERO { aiur_fn_764(__args, record, io_buffer, false)? } else { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_764] = unsafe { *(result.output.as_ptr() as *const [G; OUT_764]) }; __ret } } else { aiur_fn_764(__args, record, io_buffer, __cu)? } }; + let __r_arr: [G; OUT_760] = { let __args: [G; IN_760] = [__v_3]; let __cu = unconstrained; if let Some(result) = record.function_queries[760].get_mut(&__args[..]) { if !__cu && *result.multiplicity == G::ZERO { aiur_fn_760(__args, record, io_buffer, false)? } else { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_760] = unsafe { *(result.output.as_ptr() as *const [G; OUT_760]) }; __ret } } else { aiur_fn_760(__args, record, io_buffer, __cu)? } }; let __v_12: G = __r_arr[0]; let __v_13: G = G::from_u64(5); let __v_14: G = { let __a_val = __v_12.as_canonical_u64(); let __b_val = __v_13.as_canonical_u64(); let __a_u32 = u32::try_from(__a_val).ok().ok_or(ExecError::U32OutOfRange(__a_val))?; let __b_u32 = u32::try_from(__b_val).ok().ok_or(ExecError::U32OutOfRange(__b_val))?; let __result = G::from_bool(__a_u32 < __b_u32); if !unconstrained { let __x_bytes = __a_u32.to_le_bytes(); let __z_bytes = __b_u32.to_le_bytes(); let __c_u32 = __b_u32.wrapping_sub(__a_u32).wrapping_sub(1); let __y_bytes = __c_u32.to_le_bytes(); record.bytes2_queries.bump_range_check(&G::from_u8(__x_bytes[0]), &G::from_u8(__x_bytes[1])); record.bytes2_queries.bump_range_check(&G::from_u8(__x_bytes[2]), &G::from_u8(__x_bytes[3])); record.bytes2_queries.bump_range_check(&G::from_u8(__y_bytes[0]), &G::from_u8(__y_bytes[1])); record.bytes2_queries.bump_range_check(&G::from_u8(__y_bytes[2]), &G::from_u8(__y_bytes[3])); record.bytes2_queries.bump_range_check(&G::from_u8(__z_bytes[0]), &G::from_u8(__z_bytes[1])); record.bytes2_queries.bump_range_check(&G::from_u8(__z_bytes[2]), &G::from_u8(__z_bytes[3])); } __result }; @@ -34347,25 +34073,25 @@ fn aiur_fn_386( let __v_17: G = G::from_u64(0); let __v_18: G = G::from_u64(0); let __v_19: G = { let __values: [G; 4] = [__v_16, __v_17, __v_18, __v_18]; let __mq = record.memory_queries.get_mut(&4).ok_or(ExecError::InvalidMemorySize(4))?; if let Some(result) = __mq.get_mut(&__values[..]) { if !unconstrained { *result.multiplicity += G::ONE; } result.output[0] } else { let __ptr = G::from_usize(__mq.len()); __mq.insert(&__values[..], &[__ptr], G::from_bool(!unconstrained)); __ptr } }; - let __ret: [G; OUT_386] = [__v_15, __v_19]; - if let Some(result) = record.function_queries[386].get_mut(&inp[..]) { debug_assert_eq!(result.output, &__ret[..]); if !unconstrained { *result.multiplicity += G::ONE; } } else { record.function_queries[386].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained)); }; + let __ret: [G; OUT_382] = [__v_15, __v_19]; + if let Some(result) = record.function_queries[382].get_mut(&inp[..]) { debug_assert_eq!(result.output, &__ret[..]); if !unconstrained { *result.multiplicity += G::ONE; } } else { record.function_queries[382].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained)); }; return Ok(__ret); }, _ => { let __v_15: G = G::from_u64(0); - let __r_arr: [G; OUT_766] = { let __args: [G; IN_766] = [__v_3, __v_15]; let __cu = unconstrained; if let Some(result) = record.function_queries[766].get_mut(&__args[..]) { if !__cu && *result.multiplicity == G::ZERO { aiur_fn_766(__args, record, io_buffer, false)? } else { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_766] = unsafe { *(result.output.as_ptr() as *const [G; OUT_766]) }; __ret } } else { aiur_fn_766(__args, record, io_buffer, __cu)? } }; + let __r_arr: [G; OUT_762] = { let __args: [G; IN_762] = [__v_3, __v_15]; let __cu = unconstrained; if let Some(result) = record.function_queries[762].get_mut(&__args[..]) { if !__cu && *result.multiplicity == G::ZERO { aiur_fn_762(__args, record, io_buffer, false)? } else { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_762] = unsafe { *(result.output.as_ptr() as *const [G; OUT_762]) }; __ret } } else { aiur_fn_762(__args, record, io_buffer, __cu)? } }; let __v_16: G = __r_arr[0]; let __v_17: G = G::from_u64(1); - let __r_arr: [G; OUT_766] = { let __args: [G; IN_766] = [__v_3, __v_17]; let __cu = unconstrained; if let Some(result) = record.function_queries[766].get_mut(&__args[..]) { if !__cu && *result.multiplicity == G::ZERO { aiur_fn_766(__args, record, io_buffer, false)? } else { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_766] = unsafe { *(result.output.as_ptr() as *const [G; OUT_766]) }; __ret } } else { aiur_fn_766(__args, record, io_buffer, __cu)? } }; + let __r_arr: [G; OUT_762] = { let __args: [G; IN_762] = [__v_3, __v_17]; let __cu = unconstrained; if let Some(result) = record.function_queries[762].get_mut(&__args[..]) { if !__cu && *result.multiplicity == G::ZERO { aiur_fn_762(__args, record, io_buffer, false)? } else { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_762] = unsafe { *(result.output.as_ptr() as *const [G; OUT_762]) }; __ret } } else { aiur_fn_762(__args, record, io_buffer, __cu)? } }; let __v_18: G = __r_arr[0]; let __v_19: G = G::from_u64(2); - let __r_arr: [G; OUT_766] = { let __args: [G; IN_766] = [__v_3, __v_19]; let __cu = unconstrained; if let Some(result) = record.function_queries[766].get_mut(&__args[..]) { if !__cu && *result.multiplicity == G::ZERO { aiur_fn_766(__args, record, io_buffer, false)? } else { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_766] = unsafe { *(result.output.as_ptr() as *const [G; OUT_766]) }; __ret } } else { aiur_fn_766(__args, record, io_buffer, __cu)? } }; + let __r_arr: [G; OUT_762] = { let __args: [G; IN_762] = [__v_3, __v_19]; let __cu = unconstrained; if let Some(result) = record.function_queries[762].get_mut(&__args[..]) { if !__cu && *result.multiplicity == G::ZERO { aiur_fn_762(__args, record, io_buffer, false)? } else { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_762] = unsafe { *(result.output.as_ptr() as *const [G; OUT_762]) }; __ret } } else { aiur_fn_762(__args, record, io_buffer, __cu)? } }; let __v_20: G = __r_arr[0]; let __v_21: G = G::from_u64(3); - let __r_arr: [G; OUT_766] = { let __args: [G; IN_766] = [__v_3, __v_21]; let __cu = unconstrained; if let Some(result) = record.function_queries[766].get_mut(&__args[..]) { if !__cu && *result.multiplicity == G::ZERO { aiur_fn_766(__args, record, io_buffer, false)? } else { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_766] = unsafe { *(result.output.as_ptr() as *const [G; OUT_766]) }; __ret } } else { aiur_fn_766(__args, record, io_buffer, __cu)? } }; + let __r_arr: [G; OUT_762] = { let __args: [G; IN_762] = [__v_3, __v_21]; let __cu = unconstrained; if let Some(result) = record.function_queries[762].get_mut(&__args[..]) { if !__cu && *result.multiplicity == G::ZERO { aiur_fn_762(__args, record, io_buffer, false)? } else { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_762] = unsafe { *(result.output.as_ptr() as *const [G; OUT_762]) }; __ret } } else { aiur_fn_762(__args, record, io_buffer, __cu)? } }; let __v_22: G = __r_arr[0]; let __v_23: G = G::from_u64(4); - let __r_arr: [G; OUT_766] = { let __args: [G; IN_766] = [__v_3, __v_23]; let __cu = unconstrained; if let Some(result) = record.function_queries[766].get_mut(&__args[..]) { if !__cu && *result.multiplicity == G::ZERO { aiur_fn_766(__args, record, io_buffer, false)? } else { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_766] = unsafe { *(result.output.as_ptr() as *const [G; OUT_766]) }; __ret } } else { aiur_fn_766(__args, record, io_buffer, __cu)? } }; + let __r_arr: [G; OUT_762] = { let __args: [G; IN_762] = [__v_3, __v_23]; let __cu = unconstrained; if let Some(result) = record.function_queries[762].get_mut(&__args[..]) { if !__cu && *result.multiplicity == G::ZERO { aiur_fn_762(__args, record, io_buffer, false)? } else { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_762] = unsafe { *(result.output.as_ptr() as *const [G; OUT_762]) }; __ret } } else { aiur_fn_762(__args, record, io_buffer, __cu)? } }; let __v_24: G = __r_arr[0]; let __loaded: [G; 4] = { let __mq = record.memory_queries.get_mut(&4).ok_or(ExecError::InvalidMemorySize(4))?; let __ptr_u64 = __v_18.as_canonical_u64(); let __ptr_usize = usize::try_from(__ptr_u64).ok().ok_or(ExecError::PointerTooLarge(__ptr_u64))?; let (__args, __mult) = __mq.get_index_mut(__ptr_usize).ok_or(ExecError::UnboundPointer { ptr: __ptr_u64, size: 4 })?; if !unconstrained { *__mult += G::ONE; } let __arr: [G; 4] = __args[..4].try_into().unwrap(); __arr }; let __v_25: G = __loaded[0]; @@ -34399,7 +34125,7 @@ fn aiur_fn_386( let __v_45: G = G::from_u64(0); let __v_46: G = { let __values: [G; 4] = [__v_44, __v_39, __v_43, __v_45]; let __mq = record.memory_queries.get_mut(&4).ok_or(ExecError::InvalidMemorySize(4))?; if let Some(result) = __mq.get_mut(&__values[..]) { if !unconstrained { *result.multiplicity += G::ONE; } result.output[0] } else { let __ptr = G::from_usize(__mq.len()); __mq.insert(&__values[..], &[__ptr], G::from_bool(!unconstrained)); __ptr } }; let __v_47: G = G::from_u64(2); - let __r_arr: [G; OUT_382] = { let __args: [G; IN_382] = []; let __cu = unconstrained; if let Some(result) = record.function_queries[382].get_mut(&__args[..]) { if !__cu && *result.multiplicity == G::ZERO { aiur_fn_382(__args, record, io_buffer, false)? } else { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_382] = unsafe { *(result.output.as_ptr() as *const [G; OUT_382]) }; __ret } } else { aiur_fn_382(__args, record, io_buffer, __cu)? } }; + let __r_arr: [G; OUT_378] = { let __args: [G; IN_378] = []; let __cu = unconstrained; if let Some(result) = record.function_queries[378].get_mut(&__args[..]) { if !__cu && *result.multiplicity == G::ZERO { aiur_fn_378(__args, record, io_buffer, false)? } else { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_378] = unsafe { *(result.output.as_ptr() as *const [G; OUT_378]) }; __ret } } else { aiur_fn_378(__args, record, io_buffer, __cu)? } }; let __v_48: G = __r_arr[0]; let __v_49: G = G::from_u64(1); let __v_50: G = G::from_u64(1); @@ -34428,13 +34154,13 @@ fn aiur_fn_386( let __v_73: G = G::from_u64(0); let __v_74: G = { let __values: [G; 4] = [__v_72, __v_71, __v_24, __v_73]; let __mq = record.memory_queries.get_mut(&4).ok_or(ExecError::InvalidMemorySize(4))?; if let Some(result) = __mq.get_mut(&__values[..]) { if !unconstrained { *result.multiplicity += G::ONE; } result.output[0] } else { let __ptr = G::from_usize(__mq.len()); __mq.insert(&__values[..], &[__ptr], G::from_bool(!unconstrained)); __ptr } }; let __v_75: G = G::from_u64(5); - let __r_arr: [G; OUT_775] = { let __args: [G; IN_775] = [__v_3, __v_75]; let __cu = unconstrained; if let Some(result) = record.function_queries[775].get_mut(&__args[..]) { if !__cu && *result.multiplicity == G::ZERO { aiur_fn_775(__args, record, io_buffer, false)? } else { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_775] = unsafe { *(result.output.as_ptr() as *const [G; OUT_775]) }; __ret } } else { aiur_fn_775(__args, record, io_buffer, __cu)? } }; + let __r_arr: [G; OUT_771] = { let __args: [G; IN_771] = [__v_3, __v_75]; let __cu = unconstrained; if let Some(result) = record.function_queries[771].get_mut(&__args[..]) { if !__cu && *result.multiplicity == G::ZERO { aiur_fn_771(__args, record, io_buffer, false)? } else { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_771] = unsafe { *(result.output.as_ptr() as *const [G; OUT_771]) }; __ret } } else { aiur_fn_771(__args, record, io_buffer, __cu)? } }; let __v_76: G = __r_arr[0]; let __v_77: G = G::from_u64(1); - let __r_arr: [G; OUT_255] = { let __args: [G; IN_255] = [__v_74, __v_76]; let __cu = unconstrained; if let Some(result) = record.function_queries[255].get_mut(&__args[..]) { if !__cu && *result.multiplicity == G::ZERO { aiur_fn_255(__args, record, io_buffer, false)? } else { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_255] = unsafe { *(result.output.as_ptr() as *const [G; OUT_255]) }; __ret } } else { aiur_fn_255(__args, record, io_buffer, __cu)? } }; + let __r_arr: [G; OUT_251] = { let __args: [G; IN_251] = [__v_74, __v_76]; let __cu = unconstrained; if let Some(result) = record.function_queries[251].get_mut(&__args[..]) { if !__cu && *result.multiplicity == G::ZERO { aiur_fn_251(__args, record, io_buffer, false)? } else { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_251] = unsafe { *(result.output.as_ptr() as *const [G; OUT_251]) }; __ret } } else { aiur_fn_251(__args, record, io_buffer, __cu)? } }; let __v_78: G = __r_arr[0]; - let __ret: [G; OUT_386] = [__v_77, __v_78]; - if let Some(result) = record.function_queries[386].get_mut(&inp[..]) { debug_assert_eq!(result.output, &__ret[..]); if !unconstrained { *result.multiplicity += G::ONE; } } else { record.function_queries[386].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained)); }; + let __ret: [G; OUT_382] = [__v_77, __v_78]; + if let Some(result) = record.function_queries[382].get_mut(&inp[..]) { debug_assert_eq!(result.output, &__ret[..]); if !unconstrained { *result.multiplicity += G::ONE; } } else { record.function_queries[382].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained)); }; return Ok(__ret); }, _ => { @@ -34443,8 +34169,8 @@ fn aiur_fn_386( let __v_44: G = G::from_u64(0); let __v_45: G = G::from_u64(0); let __v_46: G = { let __values: [G; 4] = [__v_43, __v_44, __v_45, __v_45]; let __mq = record.memory_queries.get_mut(&4).ok_or(ExecError::InvalidMemorySize(4))?; if let Some(result) = __mq.get_mut(&__values[..]) { if !unconstrained { *result.multiplicity += G::ONE; } result.output[0] } else { let __ptr = G::from_usize(__mq.len()); __mq.insert(&__values[..], &[__ptr], G::from_bool(!unconstrained)); __ptr } }; - let __ret: [G; OUT_386] = [__v_42, __v_46]; - if let Some(result) = record.function_queries[386].get_mut(&inp[..]) { debug_assert_eq!(result.output, &__ret[..]); if !unconstrained { *result.multiplicity += G::ONE; } } else { record.function_queries[386].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained)); }; + let __ret: [G; OUT_382] = [__v_42, __v_46]; + if let Some(result) = record.function_queries[382].get_mut(&inp[..]) { debug_assert_eq!(result.output, &__ret[..]); if !unconstrained { *result.multiplicity += G::ONE; } } else { record.function_queries[382].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained)); }; return Ok(__ret); }, } @@ -34455,8 +34181,8 @@ fn aiur_fn_386( let __v_35: G = G::from_u64(0); let __v_36: G = G::from_u64(0); let __v_37: G = { let __values: [G; 4] = [__v_34, __v_35, __v_36, __v_36]; let __mq = record.memory_queries.get_mut(&4).ok_or(ExecError::InvalidMemorySize(4))?; if let Some(result) = __mq.get_mut(&__values[..]) { if !unconstrained { *result.multiplicity += G::ONE; } result.output[0] } else { let __ptr = G::from_usize(__mq.len()); __mq.insert(&__values[..], &[__ptr], G::from_bool(!unconstrained)); __ptr } }; - let __ret: [G; OUT_386] = [__v_33, __v_37]; - if let Some(result) = record.function_queries[386].get_mut(&inp[..]) { debug_assert_eq!(result.output, &__ret[..]); if !unconstrained { *result.multiplicity += G::ONE; } } else { record.function_queries[386].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained)); }; + let __ret: [G; OUT_382] = [__v_33, __v_37]; + if let Some(result) = record.function_queries[382].get_mut(&inp[..]) { debug_assert_eq!(result.output, &__ret[..]); if !unconstrained { *result.multiplicity += G::ONE; } } else { record.function_queries[382].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained)); }; return Ok(__ret); }, } @@ -34467,8 +34193,8 @@ fn aiur_fn_386( let __v_31: G = G::from_u64(0); let __v_32: G = G::from_u64(0); let __v_33: G = { let __values: [G; 4] = [__v_30, __v_31, __v_32, __v_32]; let __mq = record.memory_queries.get_mut(&4).ok_or(ExecError::InvalidMemorySize(4))?; if let Some(result) = __mq.get_mut(&__values[..]) { if !unconstrained { *result.multiplicity += G::ONE; } result.output[0] } else { let __ptr = G::from_usize(__mq.len()); __mq.insert(&__values[..], &[__ptr], G::from_bool(!unconstrained)); __ptr } }; - let __ret: [G; OUT_386] = [__v_29, __v_33]; - if let Some(result) = record.function_queries[386].get_mut(&inp[..]) { debug_assert_eq!(result.output, &__ret[..]); if !unconstrained { *result.multiplicity += G::ONE; } } else { record.function_queries[386].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained)); }; + let __ret: [G; OUT_382] = [__v_29, __v_33]; + if let Some(result) = record.function_queries[382].get_mut(&inp[..]) { debug_assert_eq!(result.output, &__ret[..]); if !unconstrained { *result.multiplicity += G::ONE; } } else { record.function_queries[382].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained)); }; return Ok(__ret); }, } @@ -34483,8 +34209,8 @@ fn aiur_fn_386( let __v_12: G = G::from_u64(0); let __v_13: G = G::from_u64(0); let __v_14: G = { let __values: [G; 4] = [__v_11, __v_12, __v_13, __v_13]; let __mq = record.memory_queries.get_mut(&4).ok_or(ExecError::InvalidMemorySize(4))?; if let Some(result) = __mq.get_mut(&__values[..]) { if !unconstrained { *result.multiplicity += G::ONE; } result.output[0] } else { let __ptr = G::from_usize(__mq.len()); __mq.insert(&__values[..], &[__ptr], G::from_bool(!unconstrained)); __ptr } }; - let __ret: [G; OUT_386] = [__v_10, __v_14]; - if let Some(result) = record.function_queries[386].get_mut(&inp[..]) { debug_assert_eq!(result.output, &__ret[..]); if !unconstrained { *result.multiplicity += G::ONE; } } else { record.function_queries[386].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained)); }; + let __ret: [G; OUT_382] = [__v_10, __v_14]; + if let Some(result) = record.function_queries[382].get_mut(&inp[..]) { debug_assert_eq!(result.output, &__ret[..]); if !unconstrained { *result.multiplicity += G::ONE; } } else { record.function_queries[382].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained)); }; return Ok(__ret); }, } @@ -34495,8 +34221,8 @@ fn aiur_fn_386( let __v_8: G = G::from_u64(0); let __v_9: G = G::from_u64(0); let __v_10: G = { let __values: [G; 4] = [__v_7, __v_8, __v_9, __v_9]; let __mq = record.memory_queries.get_mut(&4).ok_or(ExecError::InvalidMemorySize(4))?; if let Some(result) = __mq.get_mut(&__values[..]) { if !unconstrained { *result.multiplicity += G::ONE; } result.output[0] } else { let __ptr = G::from_usize(__mq.len()); __mq.insert(&__values[..], &[__ptr], G::from_bool(!unconstrained)); __ptr } }; - let __ret: [G; OUT_386] = [__v_6, __v_10]; - if let Some(result) = record.function_queries[386].get_mut(&inp[..]) { debug_assert_eq!(result.output, &__ret[..]); if !unconstrained { *result.multiplicity += G::ONE; } } else { record.function_queries[386].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained)); }; + let __ret: [G; OUT_382] = [__v_6, __v_10]; + if let Some(result) = record.function_queries[382].get_mut(&inp[..]) { debug_assert_eq!(result.output, &__ret[..]); if !unconstrained { *result.multiplicity += G::ONE; } } else { record.function_queries[382].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained)); }; return Ok(__ret); }, } @@ -34505,15 +34231,15 @@ fn aiur_fn_386( }) } -const INPUT_SIZE_387: usize = 1; -const IN_387: usize = 1; -const OUT_387: usize = 1; -fn aiur_fn_387( - inp: [G; IN_387], +const INPUT_SIZE_383: usize = 1; +const IN_383: usize = 1; +const OUT_383: usize = 1; +fn aiur_fn_383( + inp: [G; IN_383], record: &mut QueryRecord, io_buffer: &mut IOBuffer, unconstrained: bool, -) -> Result<[G; OUT_387], ExecError> { +) -> Result<[G; OUT_383], ExecError> { stacker::maybe_grow(64 * 1024, 4 * 1024 * 1024, || { let __v_0: G = inp[0]; let __loaded: [G; 4] = { let __mq = record.memory_queries.get_mut(&4).ok_or(ExecError::InvalidMemorySize(4))?; let __ptr_u64 = __v_0.as_canonical_u64(); let __ptr_usize = usize::try_from(__ptr_u64).ok().ok_or(ExecError::PointerTooLarge(__ptr_u64))?; let (__args, __mult) = __mq.get_index_mut(__ptr_usize).ok_or(ExecError::UnboundPointer { ptr: __ptr_u64, size: 4 })?; if !unconstrained { *__mult += G::ONE; } let __arr: [G; 4] = __args[..4].try_into().unwrap(); __arr }; @@ -34523,10 +34249,10 @@ fn aiur_fn_387( let __v_4: G = __loaded[3]; match __v_1.as_canonical_u64() { 2u64 => { - let __r_arr: [G; OUT_287] = { let __args: [G; IN_287] = [__v_2]; let __cu = unconstrained; if let Some(result) = record.function_queries[287].get_mut(&__args[..]) { if !__cu && *result.multiplicity == G::ZERO { aiur_fn_287(__args, record, io_buffer, false)? } else { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_287] = unsafe { *(result.output.as_ptr() as *const [G; OUT_287]) }; __ret } } else { aiur_fn_287(__args, record, io_buffer, __cu)? } }; + let __r_arr: [G; OUT_283] = { let __args: [G; IN_283] = [__v_2]; let __cu = unconstrained; if let Some(result) = record.function_queries[283].get_mut(&__args[..]) { if !__cu && *result.multiplicity == G::ZERO { aiur_fn_283(__args, record, io_buffer, false)? } else { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_283] = unsafe { *(result.output.as_ptr() as *const [G; OUT_283]) }; __ret } } else { aiur_fn_283(__args, record, io_buffer, __cu)? } }; let __v_5: G = __r_arr[0]; - let __ret: [G; OUT_387] = [__v_5]; - if let Some(result) = record.function_queries[387].get_mut(&inp[..]) { debug_assert_eq!(result.output, &__ret[..]); if !unconstrained { *result.multiplicity += G::ONE; } } else { record.function_queries[387].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained)); }; + let __ret: [G; OUT_383] = [__v_5]; + if let Some(result) = record.function_queries[383].get_mut(&inp[..]) { debug_assert_eq!(result.output, &__ret[..]); if !unconstrained { *result.multiplicity += G::ONE; } } else { record.function_queries[383].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained)); }; return Ok(__ret); }, _ => { @@ -34541,23 +34267,23 @@ fn aiur_fn_387( let __v_13: G = G::from_u64(0); let __v_14: G = G::from_u64(0); let __v_15: G = { let __values: [G; 12] = [__v_5, __v_6, __v_12, __v_13, __v_14, __v_14, __v_14, __v_14, __v_14, __v_14, __v_14, __v_14]; let __mq = record.memory_queries.get_mut(&12).ok_or(ExecError::InvalidMemorySize(12))?; if let Some(result) = __mq.get_mut(&__values[..]) { if !unconstrained { *result.multiplicity += G::ONE; } result.output[0] } else { let __ptr = G::from_usize(__mq.len()); __mq.insert(&__values[..], &[__ptr], G::from_bool(!unconstrained)); __ptr } }; - let __ret: [G; OUT_387] = [__v_15]; - if let Some(result) = record.function_queries[387].get_mut(&inp[..]) { debug_assert_eq!(result.output, &__ret[..]); if !unconstrained { *result.multiplicity += G::ONE; } } else { record.function_queries[387].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained)); }; + let __ret: [G; OUT_383] = [__v_15]; + if let Some(result) = record.function_queries[383].get_mut(&inp[..]) { debug_assert_eq!(result.output, &__ret[..]); if !unconstrained { *result.multiplicity += G::ONE; } } else { record.function_queries[383].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained)); }; return Ok(__ret); }, } }) } -const INPUT_SIZE_388: usize = 2; -const IN_388: usize = 2; -const OUT_388: usize = 1; -fn aiur_fn_388( - inp: [G; IN_388], +const INPUT_SIZE_384: usize = 2; +const IN_384: usize = 2; +const OUT_384: usize = 1; +fn aiur_fn_384( + inp: [G; IN_384], record: &mut QueryRecord, io_buffer: &mut IOBuffer, unconstrained: bool, -) -> Result<[G; OUT_388], ExecError> { +) -> Result<[G; OUT_384], ExecError> { stacker::maybe_grow(64 * 1024, 4 * 1024 * 1024, || { let __v_0: G = inp[0]; let __v_1: G = inp[1]; @@ -34570,19 +34296,19 @@ fn aiur_fn_388( let __v_5: G = G::from_u64(1); let __v_6: G = G::from_u64(1); let __v_7: G = { let __values: [G; 3] = [__v_5, __v_6, __v_6]; let __mq = record.memory_queries.get_mut(&3).ok_or(ExecError::InvalidMemorySize(3))?; if let Some(result) = __mq.get_mut(&__values[..]) { if !unconstrained { *result.multiplicity += G::ONE; } result.output[0] } else { let __ptr = G::from_usize(__mq.len()); __mq.insert(&__values[..], &[__ptr], G::from_bool(!unconstrained)); __ptr } }; - let __ret: [G; OUT_388] = [__v_7]; - if let Some(result) = record.function_queries[388].get_mut(&inp[..]) { debug_assert_eq!(result.output, &__ret[..]); if !unconstrained { *result.multiplicity += G::ONE; } } else { record.function_queries[388].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained)); }; + let __ret: [G; OUT_384] = [__v_7]; + if let Some(result) = record.function_queries[384].get_mut(&inp[..]) { debug_assert_eq!(result.output, &__ret[..]); if !unconstrained { *result.multiplicity += G::ONE; } } else { record.function_queries[384].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained)); }; return Ok(__ret); }, 0u64 => { - let __r_arr: [G; OUT_418] = { let __args: [G; IN_418] = [__v_3, __v_1]; let __cu = unconstrained; if let Some(result) = record.function_queries[418].get_mut(&__args[..]) { if !__cu && *result.multiplicity == G::ZERO { aiur_fn_418(__args, record, io_buffer, false)? } else { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_418] = unsafe { *(result.output.as_ptr() as *const [G; OUT_418]) }; __ret } } else { aiur_fn_418(__args, record, io_buffer, __cu)? } }; + let __r_arr: [G; OUT_414] = { let __args: [G; IN_414] = [__v_3, __v_1]; let __cu = unconstrained; if let Some(result) = record.function_queries[414].get_mut(&__args[..]) { if !__cu && *result.multiplicity == G::ZERO { aiur_fn_414(__args, record, io_buffer, false)? } else { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_414] = unsafe { *(result.output.as_ptr() as *const [G; OUT_414]) }; __ret } } else { aiur_fn_414(__args, record, io_buffer, __cu)? } }; let __v_5: G = __r_arr[0]; let __v_6: G = G::from_u64(0); - let __r_arr: [G; OUT_388] = { let __args: [G; IN_388] = [__v_4, __v_1]; let __cu = unconstrained; if let Some(result) = record.function_queries[388].get_mut(&__args[..]) { if !__cu && *result.multiplicity == G::ZERO { aiur_fn_388(__args, record, io_buffer, false)? } else { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_388] = unsafe { *(result.output.as_ptr() as *const [G; OUT_388]) }; __ret } } else { aiur_fn_388(__args, record, io_buffer, __cu)? } }; + let __r_arr: [G; OUT_384] = { let __args: [G; IN_384] = [__v_4, __v_1]; let __cu = unconstrained; if let Some(result) = record.function_queries[384].get_mut(&__args[..]) { if !__cu && *result.multiplicity == G::ZERO { aiur_fn_384(__args, record, io_buffer, false)? } else { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_384] = unsafe { *(result.output.as_ptr() as *const [G; OUT_384]) }; __ret } } else { aiur_fn_384(__args, record, io_buffer, __cu)? } }; let __v_7: G = __r_arr[0]; let __v_8: G = { let __values: [G; 3] = [__v_6, __v_5, __v_7]; let __mq = record.memory_queries.get_mut(&3).ok_or(ExecError::InvalidMemorySize(3))?; if let Some(result) = __mq.get_mut(&__values[..]) { if !unconstrained { *result.multiplicity += G::ONE; } result.output[0] } else { let __ptr = G::from_usize(__mq.len()); __mq.insert(&__values[..], &[__ptr], G::from_bool(!unconstrained)); __ptr } }; - let __ret: [G; OUT_388] = [__v_8]; - if let Some(result) = record.function_queries[388].get_mut(&inp[..]) { debug_assert_eq!(result.output, &__ret[..]); if !unconstrained { *result.multiplicity += G::ONE; } } else { record.function_queries[388].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained)); }; + let __ret: [G; OUT_384] = [__v_8]; + if let Some(result) = record.function_queries[384].get_mut(&inp[..]) { debug_assert_eq!(result.output, &__ret[..]); if !unconstrained { *result.multiplicity += G::ONE; } } else { record.function_queries[384].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained)); }; return Ok(__ret); }, _ => { @@ -34592,22 +34318,22 @@ fn aiur_fn_388( }) } -const INPUT_SIZE_389: usize = 3; -const IN_389: usize = 3; -const OUT_389: usize = 2; -fn aiur_fn_389( - inp: [G; IN_389], +const INPUT_SIZE_385: usize = 3; +const IN_385: usize = 3; +const OUT_385: usize = 2; +fn aiur_fn_385( + inp: [G; IN_385], record: &mut QueryRecord, io_buffer: &mut IOBuffer, unconstrained: bool, -) -> Result<[G; OUT_389], ExecError> { +) -> Result<[G; OUT_385], ExecError> { stacker::maybe_grow(64 * 1024, 4 * 1024 * 1024, || { let __v_0: G = inp[0]; let __v_1: G = inp[1]; let __v_2: G = inp[2]; - let __r_arr: [G; OUT_388] = { let __args: [G; IN_388] = [__v_1, __v_2]; let __cu = unconstrained; if let Some(result) = record.function_queries[388].get_mut(&__args[..]) { if !__cu && *result.multiplicity == G::ZERO { aiur_fn_388(__args, record, io_buffer, false)? } else { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_388] = unsafe { *(result.output.as_ptr() as *const [G; OUT_388]) }; __ret } } else { aiur_fn_388(__args, record, io_buffer, __cu)? } }; + let __r_arr: [G; OUT_384] = { let __args: [G; IN_384] = [__v_1, __v_2]; let __cu = unconstrained; if let Some(result) = record.function_queries[384].get_mut(&__args[..]) { if !__cu && *result.multiplicity == G::ZERO { aiur_fn_384(__args, record, io_buffer, false)? } else { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_384] = unsafe { *(result.output.as_ptr() as *const [G; OUT_384]) }; __ret } } else { aiur_fn_384(__args, record, io_buffer, __cu)? } }; let __v_3: G = __r_arr[0]; - let __r_arr: [G; OUT_764] = { let __args: [G; IN_764] = [__v_3]; let __cu = unconstrained; if let Some(result) = record.function_queries[764].get_mut(&__args[..]) { if !__cu && *result.multiplicity == G::ZERO { aiur_fn_764(__args, record, io_buffer, false)? } else { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_764] = unsafe { *(result.output.as_ptr() as *const [G; OUT_764]) }; __ret } } else { aiur_fn_764(__args, record, io_buffer, __cu)? } }; + let __r_arr: [G; OUT_760] = { let __args: [G; IN_760] = [__v_3]; let __cu = unconstrained; if let Some(result) = record.function_queries[760].get_mut(&__args[..]) { if !__cu && *result.multiplicity == G::ZERO { aiur_fn_760(__args, record, io_buffer, false)? } else { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_760] = unsafe { *(result.output.as_ptr() as *const [G; OUT_760]) }; __ret } } else { aiur_fn_760(__args, record, io_buffer, __cu)? } }; let __v_4: G = __r_arr[0]; let __r_arr: [G; OUT_145] = { let __args: [G; IN_145] = []; let __cu = unconstrained; if let Some(result) = record.function_queries[145].get_mut(&__args[..]) { if !__cu && *result.multiplicity == G::ZERO { aiur_fn_145(__args, record, io_buffer, false)? } else { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_145] = unsafe { *(result.output.as_ptr() as *const [G; OUT_145]) }; __ret } } else { aiur_fn_145(__args, record, io_buffer, __cu)? } }; let __v_5: G = __r_arr[0]; @@ -34628,31 +34354,31 @@ fn aiur_fn_389( let __v_13: G = G::from_u64(0); let __v_14: G = G::from_u64(0); let __v_15: G = { let __values: [G; 4] = [__v_12, __v_13, __v_14, __v_14]; let __mq = record.memory_queries.get_mut(&4).ok_or(ExecError::InvalidMemorySize(4))?; if let Some(result) = __mq.get_mut(&__values[..]) { if !unconstrained { *result.multiplicity += G::ONE; } result.output[0] } else { let __ptr = G::from_usize(__mq.len()); __mq.insert(&__values[..], &[__ptr], G::from_bool(!unconstrained)); __ptr } }; - let __ret: [G; OUT_389] = [__v_11, __v_15]; - if let Some(result) = record.function_queries[389].get_mut(&inp[..]) { debug_assert_eq!(result.output, &__ret[..]); if !unconstrained { *result.multiplicity += G::ONE; } } else { record.function_queries[389].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained)); }; + let __ret: [G; OUT_385] = [__v_11, __v_15]; + if let Some(result) = record.function_queries[385].get_mut(&inp[..]) { debug_assert_eq!(result.output, &__ret[..]); if !unconstrained { *result.multiplicity += G::ONE; } } else { record.function_queries[385].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained)); }; return Ok(__ret); }, _ => { let __v_11: G = G::from_u64(0); - let __r_arr: [G; OUT_766] = { let __args: [G; IN_766] = [__v_3, __v_11]; let __cu = unconstrained; if let Some(result) = record.function_queries[766].get_mut(&__args[..]) { if !__cu && *result.multiplicity == G::ZERO { aiur_fn_766(__args, record, io_buffer, false)? } else { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_766] = unsafe { *(result.output.as_ptr() as *const [G; OUT_766]) }; __ret } } else { aiur_fn_766(__args, record, io_buffer, __cu)? } }; + let __r_arr: [G; OUT_762] = { let __args: [G; IN_762] = [__v_3, __v_11]; let __cu = unconstrained; if let Some(result) = record.function_queries[762].get_mut(&__args[..]) { if !__cu && *result.multiplicity == G::ZERO { aiur_fn_762(__args, record, io_buffer, false)? } else { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_762] = unsafe { *(result.output.as_ptr() as *const [G; OUT_762]) }; __ret } } else { aiur_fn_762(__args, record, io_buffer, __cu)? } }; let __v_12: G = __r_arr[0]; - let __r_arr: [G; OUT_243] = { let __args: [G; IN_243] = [__v_12]; let __cu = unconstrained; if let Some(result) = record.function_queries[243].get_mut(&__args[..]) { if !__cu && *result.multiplicity == G::ZERO { aiur_fn_243(__args, record, io_buffer, false)? } else { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_243] = unsafe { *(result.output.as_ptr() as *const [G; OUT_243]) }; __ret } } else { aiur_fn_243(__args, record, io_buffer, __cu)? } }; + let __r_arr: [G; OUT_239] = { let __args: [G; IN_239] = [__v_12]; let __cu = unconstrained; if let Some(result) = record.function_queries[239].get_mut(&__args[..]) { if !__cu && *result.multiplicity == G::ZERO { aiur_fn_239(__args, record, io_buffer, false)? } else { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_239] = unsafe { *(result.output.as_ptr() as *const [G; OUT_239]) }; __ret } } else { aiur_fn_239(__args, record, io_buffer, __cu)? } }; let __v_13: G = __r_arr[0]; let __v_14: G = __r_arr[1]; match __v_13.as_canonical_u64() { 1u64 => { let __v_15: G = G::from_u64(1); - let __r_arr: [G; OUT_775] = { let __args: [G; IN_775] = [__v_3, __v_15]; let __cu = unconstrained; if let Some(result) = record.function_queries[775].get_mut(&__args[..]) { if !__cu && *result.multiplicity == G::ZERO { aiur_fn_775(__args, record, io_buffer, false)? } else { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_775] = unsafe { *(result.output.as_ptr() as *const [G; OUT_775]) }; __ret } } else { aiur_fn_775(__args, record, io_buffer, __cu)? } }; + let __r_arr: [G; OUT_771] = { let __args: [G; IN_771] = [__v_3, __v_15]; let __cu = unconstrained; if let Some(result) = record.function_queries[771].get_mut(&__args[..]) { if !__cu && *result.multiplicity == G::ZERO { aiur_fn_771(__args, record, io_buffer, false)? } else { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_771] = unsafe { *(result.output.as_ptr() as *const [G; OUT_771]) }; __ret } } else { aiur_fn_771(__args, record, io_buffer, __cu)? } }; let __v_16: G = __r_arr[0]; let __v_17: G = G::from_u64(1); let __r_arr: [G; OUT_112] = { let __args: [G; IN_112] = [__v_14]; let __cu = unconstrained; if let Some(result) = record.function_queries[112].get_mut(&__args[..]) { if !__cu && *result.multiplicity == G::ZERO { aiur_fn_112(__args, record, io_buffer, false)? } else { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_112] = unsafe { *(result.output.as_ptr() as *const [G; OUT_112]) }; __ret } } else { aiur_fn_112(__args, record, io_buffer, __cu)? } }; let __v_18: G = __r_arr[0]; - let __r_arr: [G; OUT_245] = { let __args: [G; IN_245] = [__v_18]; let __cu = unconstrained; if let Some(result) = record.function_queries[245].get_mut(&__args[..]) { if !__cu && *result.multiplicity == G::ZERO { aiur_fn_245(__args, record, io_buffer, false)? } else { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_245] = unsafe { *(result.output.as_ptr() as *const [G; OUT_245]) }; __ret } } else { aiur_fn_245(__args, record, io_buffer, __cu)? } }; + let __r_arr: [G; OUT_241] = { let __args: [G; IN_241] = [__v_18]; let __cu = unconstrained; if let Some(result) = record.function_queries[241].get_mut(&__args[..]) { if !__cu && *result.multiplicity == G::ZERO { aiur_fn_241(__args, record, io_buffer, false)? } else { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_241] = unsafe { *(result.output.as_ptr() as *const [G; OUT_241]) }; __ret } } else { aiur_fn_241(__args, record, io_buffer, __cu)? } }; let __v_19: G = __r_arr[0]; - let __r_arr: [G; OUT_255] = { let __args: [G; IN_255] = [__v_19, __v_16]; let __cu = unconstrained; if let Some(result) = record.function_queries[255].get_mut(&__args[..]) { if !__cu && *result.multiplicity == G::ZERO { aiur_fn_255(__args, record, io_buffer, false)? } else { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_255] = unsafe { *(result.output.as_ptr() as *const [G; OUT_255]) }; __ret } } else { aiur_fn_255(__args, record, io_buffer, __cu)? } }; + let __r_arr: [G; OUT_251] = { let __args: [G; IN_251] = [__v_19, __v_16]; let __cu = unconstrained; if let Some(result) = record.function_queries[251].get_mut(&__args[..]) { if !__cu && *result.multiplicity == G::ZERO { aiur_fn_251(__args, record, io_buffer, false)? } else { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_251] = unsafe { *(result.output.as_ptr() as *const [G; OUT_251]) }; __ret } } else { aiur_fn_251(__args, record, io_buffer, __cu)? } }; let __v_20: G = __r_arr[0]; - let __ret: [G; OUT_389] = [__v_17, __v_20]; - if let Some(result) = record.function_queries[389].get_mut(&inp[..]) { debug_assert_eq!(result.output, &__ret[..]); if !unconstrained { *result.multiplicity += G::ONE; } } else { record.function_queries[389].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained)); }; + let __ret: [G; OUT_385] = [__v_17, __v_20]; + if let Some(result) = record.function_queries[385].get_mut(&inp[..]) { debug_assert_eq!(result.output, &__ret[..]); if !unconstrained { *result.multiplicity += G::ONE; } } else { record.function_queries[385].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained)); }; return Ok(__ret); }, _ => { @@ -34661,8 +34387,8 @@ fn aiur_fn_389( let __v_17: G = G::from_u64(0); let __v_18: G = G::from_u64(0); let __v_19: G = { let __values: [G; 4] = [__v_16, __v_17, __v_18, __v_18]; let __mq = record.memory_queries.get_mut(&4).ok_or(ExecError::InvalidMemorySize(4))?; if let Some(result) = __mq.get_mut(&__values[..]) { if !unconstrained { *result.multiplicity += G::ONE; } result.output[0] } else { let __ptr = G::from_usize(__mq.len()); __mq.insert(&__values[..], &[__ptr], G::from_bool(!unconstrained)); __ptr } }; - let __ret: [G; OUT_389] = [__v_15, __v_19]; - if let Some(result) = record.function_queries[389].get_mut(&inp[..]) { debug_assert_eq!(result.output, &__ret[..]); if !unconstrained { *result.multiplicity += G::ONE; } } else { record.function_queries[389].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained)); }; + let __ret: [G; OUT_385] = [__v_15, __v_19]; + if let Some(result) = record.function_queries[385].get_mut(&inp[..]) { debug_assert_eq!(result.output, &__ret[..]); if !unconstrained { *result.multiplicity += G::ONE; } } else { record.function_queries[385].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained)); }; return Ok(__ret); }, } @@ -34681,33 +34407,33 @@ fn aiur_fn_389( let __v_13: G = G::from_u64(0); let __v_14: G = G::from_u64(0); let __v_15: G = { let __values: [G; 4] = [__v_12, __v_13, __v_14, __v_14]; let __mq = record.memory_queries.get_mut(&4).ok_or(ExecError::InvalidMemorySize(4))?; if let Some(result) = __mq.get_mut(&__values[..]) { if !unconstrained { *result.multiplicity += G::ONE; } result.output[0] } else { let __ptr = G::from_usize(__mq.len()); __mq.insert(&__values[..], &[__ptr], G::from_bool(!unconstrained)); __ptr } }; - let __ret: [G; OUT_389] = [__v_11, __v_15]; - if let Some(result) = record.function_queries[389].get_mut(&inp[..]) { debug_assert_eq!(result.output, &__ret[..]); if !unconstrained { *result.multiplicity += G::ONE; } } else { record.function_queries[389].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained)); }; + let __ret: [G; OUT_385] = [__v_11, __v_15]; + if let Some(result) = record.function_queries[385].get_mut(&inp[..]) { debug_assert_eq!(result.output, &__ret[..]); if !unconstrained { *result.multiplicity += G::ONE; } } else { record.function_queries[385].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained)); }; return Ok(__ret); }, _ => { let __v_11: G = G::from_u64(0); - let __r_arr: [G; OUT_766] = { let __args: [G; IN_766] = [__v_3, __v_11]; let __cu = unconstrained; if let Some(result) = record.function_queries[766].get_mut(&__args[..]) { if !__cu && *result.multiplicity == G::ZERO { aiur_fn_766(__args, record, io_buffer, false)? } else { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_766] = unsafe { *(result.output.as_ptr() as *const [G; OUT_766]) }; __ret } } else { aiur_fn_766(__args, record, io_buffer, __cu)? } }; + let __r_arr: [G; OUT_762] = { let __args: [G; IN_762] = [__v_3, __v_11]; let __cu = unconstrained; if let Some(result) = record.function_queries[762].get_mut(&__args[..]) { if !__cu && *result.multiplicity == G::ZERO { aiur_fn_762(__args, record, io_buffer, false)? } else { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_762] = unsafe { *(result.output.as_ptr() as *const [G; OUT_762]) }; __ret } } else { aiur_fn_762(__args, record, io_buffer, __cu)? } }; let __v_12: G = __r_arr[0]; - let __r_arr: [G; OUT_243] = { let __args: [G; IN_243] = [__v_12]; let __cu = unconstrained; if let Some(result) = record.function_queries[243].get_mut(&__args[..]) { if !__cu && *result.multiplicity == G::ZERO { aiur_fn_243(__args, record, io_buffer, false)? } else { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_243] = unsafe { *(result.output.as_ptr() as *const [G; OUT_243]) }; __ret } } else { aiur_fn_243(__args, record, io_buffer, __cu)? } }; + let __r_arr: [G; OUT_239] = { let __args: [G; IN_239] = [__v_12]; let __cu = unconstrained; if let Some(result) = record.function_queries[239].get_mut(&__args[..]) { if !__cu && *result.multiplicity == G::ZERO { aiur_fn_239(__args, record, io_buffer, false)? } else { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_239] = unsafe { *(result.output.as_ptr() as *const [G; OUT_239]) }; __ret } } else { aiur_fn_239(__args, record, io_buffer, __cu)? } }; let __v_13: G = __r_arr[0]; let __v_14: G = __r_arr[1]; match __v_13.as_canonical_u64() { 1u64 => { let __v_15: G = G::from_u64(1); - let __r_arr: [G; OUT_775] = { let __args: [G; IN_775] = [__v_3, __v_15]; let __cu = unconstrained; if let Some(result) = record.function_queries[775].get_mut(&__args[..]) { if !__cu && *result.multiplicity == G::ZERO { aiur_fn_775(__args, record, io_buffer, false)? } else { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_775] = unsafe { *(result.output.as_ptr() as *const [G; OUT_775]) }; __ret } } else { aiur_fn_775(__args, record, io_buffer, __cu)? } }; + let __r_arr: [G; OUT_771] = { let __args: [G; IN_771] = [__v_3, __v_15]; let __cu = unconstrained; if let Some(result) = record.function_queries[771].get_mut(&__args[..]) { if !__cu && *result.multiplicity == G::ZERO { aiur_fn_771(__args, record, io_buffer, false)? } else { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_771] = unsafe { *(result.output.as_ptr() as *const [G; OUT_771]) }; __ret } } else { aiur_fn_771(__args, record, io_buffer, __cu)? } }; let __v_16: G = __r_arr[0]; let __v_17: G = G::from_u64(1); let __r_arr: [G; OUT_121] = { let __args: [G; IN_121] = [__v_14]; let __cu = unconstrained; if let Some(result) = record.function_queries[121].get_mut(&__args[..]) { if !__cu && *result.multiplicity == G::ZERO { aiur_fn_121(__args, record, io_buffer, false)? } else { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_121] = unsafe { *(result.output.as_ptr() as *const [G; OUT_121]) }; __ret } } else { aiur_fn_121(__args, record, io_buffer, __cu)? } }; let __v_18: G = __r_arr[0]; let __r_arr: [G; OUT_118] = { let __args: [G; IN_118] = [__v_18]; let __cu = unconstrained; if let Some(result) = record.function_queries[118].get_mut(&__args[..]) { if !__cu && *result.multiplicity == G::ZERO { aiur_fn_118(__args, record, io_buffer, false)? } else { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_118] = unsafe { *(result.output.as_ptr() as *const [G; OUT_118]) }; __ret } } else { aiur_fn_118(__args, record, io_buffer, __cu)? } }; let __v_19: G = __r_arr[0]; - let __r_arr: [G; OUT_245] = { let __args: [G; IN_245] = [__v_19]; let __cu = unconstrained; if let Some(result) = record.function_queries[245].get_mut(&__args[..]) { if !__cu && *result.multiplicity == G::ZERO { aiur_fn_245(__args, record, io_buffer, false)? } else { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_245] = unsafe { *(result.output.as_ptr() as *const [G; OUT_245]) }; __ret } } else { aiur_fn_245(__args, record, io_buffer, __cu)? } }; + let __r_arr: [G; OUT_241] = { let __args: [G; IN_241] = [__v_19]; let __cu = unconstrained; if let Some(result) = record.function_queries[241].get_mut(&__args[..]) { if !__cu && *result.multiplicity == G::ZERO { aiur_fn_241(__args, record, io_buffer, false)? } else { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_241] = unsafe { *(result.output.as_ptr() as *const [G; OUT_241]) }; __ret } } else { aiur_fn_241(__args, record, io_buffer, __cu)? } }; let __v_20: G = __r_arr[0]; - let __r_arr: [G; OUT_255] = { let __args: [G; IN_255] = [__v_20, __v_16]; let __cu = unconstrained; if let Some(result) = record.function_queries[255].get_mut(&__args[..]) { if !__cu && *result.multiplicity == G::ZERO { aiur_fn_255(__args, record, io_buffer, false)? } else { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_255] = unsafe { *(result.output.as_ptr() as *const [G; OUT_255]) }; __ret } } else { aiur_fn_255(__args, record, io_buffer, __cu)? } }; + let __r_arr: [G; OUT_251] = { let __args: [G; IN_251] = [__v_20, __v_16]; let __cu = unconstrained; if let Some(result) = record.function_queries[251].get_mut(&__args[..]) { if !__cu && *result.multiplicity == G::ZERO { aiur_fn_251(__args, record, io_buffer, false)? } else { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_251] = unsafe { *(result.output.as_ptr() as *const [G; OUT_251]) }; __ret } } else { aiur_fn_251(__args, record, io_buffer, __cu)? } }; let __v_21: G = __r_arr[0]; - let __ret: [G; OUT_389] = [__v_17, __v_21]; - if let Some(result) = record.function_queries[389].get_mut(&inp[..]) { debug_assert_eq!(result.output, &__ret[..]); if !unconstrained { *result.multiplicity += G::ONE; } } else { record.function_queries[389].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained)); }; + let __ret: [G; OUT_385] = [__v_17, __v_21]; + if let Some(result) = record.function_queries[385].get_mut(&inp[..]) { debug_assert_eq!(result.output, &__ret[..]); if !unconstrained { *result.multiplicity += G::ONE; } } else { record.function_queries[385].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained)); }; return Ok(__ret); }, _ => { @@ -34716,8 +34442,8 @@ fn aiur_fn_389( let __v_17: G = G::from_u64(0); let __v_18: G = G::from_u64(0); let __v_19: G = { let __values: [G; 4] = [__v_16, __v_17, __v_18, __v_18]; let __mq = record.memory_queries.get_mut(&4).ok_or(ExecError::InvalidMemorySize(4))?; if let Some(result) = __mq.get_mut(&__values[..]) { if !unconstrained { *result.multiplicity += G::ONE; } result.output[0] } else { let __ptr = G::from_usize(__mq.len()); __mq.insert(&__values[..], &[__ptr], G::from_bool(!unconstrained)); __ptr } }; - let __ret: [G; OUT_389] = [__v_15, __v_19]; - if let Some(result) = record.function_queries[389].get_mut(&inp[..]) { debug_assert_eq!(result.output, &__ret[..]); if !unconstrained { *result.multiplicity += G::ONE; } } else { record.function_queries[389].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained)); }; + let __ret: [G; OUT_385] = [__v_15, __v_19]; + if let Some(result) = record.function_queries[385].get_mut(&inp[..]) { debug_assert_eq!(result.output, &__ret[..]); if !unconstrained { *result.multiplicity += G::ONE; } } else { record.function_queries[385].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained)); }; return Ok(__ret); }, } @@ -34725,11 +34451,11 @@ fn aiur_fn_389( } }, _ => { - let __r_arr: [G; OUT_264] = { let __args: [G; IN_264] = [__v_0, __v_3, __v_4]; let __cu = unconstrained; if let Some(result) = record.function_queries[264].get_mut(&__args[..]) { if !__cu && *result.multiplicity == G::ZERO { aiur_fn_264(__args, record, io_buffer, false)? } else { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_264] = unsafe { *(result.output.as_ptr() as *const [G; OUT_264]) }; __ret } } else { aiur_fn_264(__args, record, io_buffer, __cu)? } }; + let __r_arr: [G; OUT_260] = { let __args: [G; IN_260] = [__v_0, __v_3, __v_4]; let __cu = unconstrained; if let Some(result) = record.function_queries[260].get_mut(&__args[..]) { if !__cu && *result.multiplicity == G::ZERO { aiur_fn_260(__args, record, io_buffer, false)? } else { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_260] = unsafe { *(result.output.as_ptr() as *const [G; OUT_260]) }; __ret } } else { aiur_fn_260(__args, record, io_buffer, __cu)? } }; let __v_9: G = __r_arr[0]; let __v_10: G = __r_arr[1]; - let __ret: [G; OUT_389] = [__v_9, __v_10]; - if let Some(result) = record.function_queries[389].get_mut(&inp[..]) { debug_assert_eq!(result.output, &__ret[..]); if !unconstrained { *result.multiplicity += G::ONE; } } else { record.function_queries[389].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained)); }; + let __ret: [G; OUT_385] = [__v_9, __v_10]; + if let Some(result) = record.function_queries[385].get_mut(&inp[..]) { debug_assert_eq!(result.output, &__ret[..]); if !unconstrained { *result.multiplicity += G::ONE; } } else { record.function_queries[385].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained)); }; return Ok(__ret); }, } @@ -34738,19 +34464,19 @@ fn aiur_fn_389( }) } -const INPUT_SIZE_390: usize = 2; -const IN_390: usize = 2; -const OUT_390: usize = 1; -fn aiur_fn_390( - inp: [G; IN_390], +const INPUT_SIZE_386: usize = 2; +const IN_386: usize = 2; +const OUT_386: usize = 1; +fn aiur_fn_386( + inp: [G; IN_386], record: &mut QueryRecord, io_buffer: &mut IOBuffer, unconstrained: bool, -) -> Result<[G; OUT_390], ExecError> { +) -> Result<[G; OUT_386], ExecError> { stacker::maybe_grow(64 * 1024, 4 * 1024 * 1024, || { let __v_0: G = inp[0]; let __v_1: G = inp[1]; - let __r_arr: [G; OUT_388] = { let __args: [G; IN_388] = [__v_0, __v_1]; let __cu = unconstrained; if let Some(result) = record.function_queries[388].get_mut(&__args[..]) { if !__cu && *result.multiplicity == G::ZERO { aiur_fn_388(__args, record, io_buffer, false)? } else { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_388] = unsafe { *(result.output.as_ptr() as *const [G; OUT_388]) }; __ret } } else { aiur_fn_388(__args, record, io_buffer, __cu)? } }; + let __r_arr: [G; OUT_384] = { let __args: [G; IN_384] = [__v_0, __v_1]; let __cu = unconstrained; if let Some(result) = record.function_queries[384].get_mut(&__args[..]) { if !__cu && *result.multiplicity == G::ZERO { aiur_fn_384(__args, record, io_buffer, false)? } else { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_384] = unsafe { *(result.output.as_ptr() as *const [G; OUT_384]) }; __ret } } else { aiur_fn_384(__args, record, io_buffer, __cu)? } }; let __v_2: G = __r_arr[0]; let __loaded: [G; 3] = { let __mq = record.memory_queries.get_mut(&3).ok_or(ExecError::InvalidMemorySize(3))?; let __ptr_u64 = __v_2.as_canonical_u64(); let __ptr_usize = usize::try_from(__ptr_u64).ok().ok_or(ExecError::PointerTooLarge(__ptr_u64))?; let (__args, __mult) = __mq.get_index_mut(__ptr_usize).ok_or(ExecError::UnboundPointer { ptr: __ptr_u64, size: 3 })?; if !unconstrained { *__mult += G::ONE; } let __arr: [G; 3] = __args[..3].try_into().unwrap(); __arr }; let __v_3: G = __loaded[0]; @@ -34758,8 +34484,8 @@ fn aiur_fn_390( let __v_5: G = __loaded[2]; match __v_3.as_canonical_u64() { 1u64 => { - let __ret: [G; OUT_390] = [__v_2]; - if let Some(result) = record.function_queries[390].get_mut(&inp[..]) { debug_assert_eq!(result.output, &__ret[..]); if !unconstrained { *result.multiplicity += G::ONE; } } else { record.function_queries[390].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained)); }; + let __ret: [G; OUT_386] = [__v_2]; + if let Some(result) = record.function_queries[386].get_mut(&inp[..]) { debug_assert_eq!(result.output, &__ret[..]); if !unconstrained { *result.multiplicity += G::ONE; } } else { record.function_queries[386].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained)); }; return Ok(__ret); }, 0u64 => { @@ -34769,26 +34495,26 @@ fn aiur_fn_390( let __v_8: G = __loaded[2]; match __v_6.as_canonical_u64() { 1u64 => { - let __ret: [G; OUT_390] = [__v_2]; - if let Some(result) = record.function_queries[390].get_mut(&inp[..]) { debug_assert_eq!(result.output, &__ret[..]); if !unconstrained { *result.multiplicity += G::ONE; } } else { record.function_queries[390].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained)); }; + let __ret: [G; OUT_386] = [__v_2]; + if let Some(result) = record.function_queries[386].get_mut(&inp[..]) { debug_assert_eq!(result.output, &__ret[..]); if !unconstrained { *result.multiplicity += G::ONE; } } else { record.function_queries[386].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained)); }; return Ok(__ret); }, 0u64 => { let __r_arr: [G; OUT_111] = { let __args: [G; IN_111] = [__v_7]; let __cu = unconstrained; if let Some(result) = record.function_queries[111].get_mut(&__args[..]) { if !__cu && *result.multiplicity == G::ZERO { aiur_fn_111(__args, record, io_buffer, false)? } else { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_111] = unsafe { *(result.output.as_ptr() as *const [G; OUT_111]) }; __ret } } else { aiur_fn_111(__args, record, io_buffer, __cu)? } }; let __v_9: G = __r_arr[0]; let __v_10: G = __r_arr[1]; - let __r_arr: [G; OUT_388] = { let __args: [G; IN_388] = [__v_10, __v_1]; let __cu = unconstrained; if let Some(result) = record.function_queries[388].get_mut(&__args[..]) { if !__cu && *result.multiplicity == G::ZERO { aiur_fn_388(__args, record, io_buffer, false)? } else { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_388] = unsafe { *(result.output.as_ptr() as *const [G; OUT_388]) }; __ret } } else { aiur_fn_388(__args, record, io_buffer, __cu)? } }; + let __r_arr: [G; OUT_384] = { let __args: [G; IN_384] = [__v_10, __v_1]; let __cu = unconstrained; if let Some(result) = record.function_queries[384].get_mut(&__args[..]) { if !__cu && *result.multiplicity == G::ZERO { aiur_fn_384(__args, record, io_buffer, false)? } else { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_384] = unsafe { *(result.output.as_ptr() as *const [G; OUT_384]) }; __ret } } else { aiur_fn_384(__args, record, io_buffer, __cu)? } }; let __v_11: G = __r_arr[0]; - let __r_arr: [G; OUT_255] = { let __args: [G; IN_255] = [__v_9, __v_11]; let __cu = unconstrained; if let Some(result) = record.function_queries[255].get_mut(&__args[..]) { if !__cu && *result.multiplicity == G::ZERO { aiur_fn_255(__args, record, io_buffer, false)? } else { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_255] = unsafe { *(result.output.as_ptr() as *const [G; OUT_255]) }; __ret } } else { aiur_fn_255(__args, record, io_buffer, __cu)? } }; + let __r_arr: [G; OUT_251] = { let __args: [G; IN_251] = [__v_9, __v_11]; let __cu = unconstrained; if let Some(result) = record.function_queries[251].get_mut(&__args[..]) { if !__cu && *result.multiplicity == G::ZERO { aiur_fn_251(__args, record, io_buffer, false)? } else { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_251] = unsafe { *(result.output.as_ptr() as *const [G; OUT_251]) }; __ret } } else { aiur_fn_251(__args, record, io_buffer, __cu)? } }; let __v_12: G = __r_arr[0]; - let __r_arr: [G; OUT_418] = { let __args: [G; IN_418] = [__v_4, __v_1]; let __cu = unconstrained; if let Some(result) = record.function_queries[418].get_mut(&__args[..]) { if !__cu && *result.multiplicity == G::ZERO { aiur_fn_418(__args, record, io_buffer, false)? } else { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_418] = unsafe { *(result.output.as_ptr() as *const [G; OUT_418]) }; __ret } } else { aiur_fn_418(__args, record, io_buffer, __cu)? } }; + let __r_arr: [G; OUT_414] = { let __args: [G; IN_414] = [__v_4, __v_1]; let __cu = unconstrained; if let Some(result) = record.function_queries[414].get_mut(&__args[..]) { if !__cu && *result.multiplicity == G::ZERO { aiur_fn_414(__args, record, io_buffer, false)? } else { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_414] = unsafe { *(result.output.as_ptr() as *const [G; OUT_414]) }; __ret } } else { aiur_fn_414(__args, record, io_buffer, __cu)? } }; let __v_13: G = __r_arr[0]; let __v_14: G = G::from_u64(0); let __v_15: G = G::from_u64(0); let __v_16: G = { let __values: [G; 3] = [__v_15, __v_12, __v_8]; let __mq = record.memory_queries.get_mut(&3).ok_or(ExecError::InvalidMemorySize(3))?; if let Some(result) = __mq.get_mut(&__values[..]) { if !unconstrained { *result.multiplicity += G::ONE; } result.output[0] } else { let __ptr = G::from_usize(__mq.len()); __mq.insert(&__values[..], &[__ptr], G::from_bool(!unconstrained)); __ptr } }; let __v_17: G = { let __values: [G; 3] = [__v_14, __v_13, __v_16]; let __mq = record.memory_queries.get_mut(&3).ok_or(ExecError::InvalidMemorySize(3))?; if let Some(result) = __mq.get_mut(&__values[..]) { if !unconstrained { *result.multiplicity += G::ONE; } result.output[0] } else { let __ptr = G::from_usize(__mq.len()); __mq.insert(&__values[..], &[__ptr], G::from_bool(!unconstrained)); __ptr } }; - let __ret: [G; OUT_390] = [__v_17]; - if let Some(result) = record.function_queries[390].get_mut(&inp[..]) { debug_assert_eq!(result.output, &__ret[..]); if !unconstrained { *result.multiplicity += G::ONE; } } else { record.function_queries[390].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained)); }; + let __ret: [G; OUT_386] = [__v_17]; + if let Some(result) = record.function_queries[386].get_mut(&inp[..]) { debug_assert_eq!(result.output, &__ret[..]); if !unconstrained { *result.multiplicity += G::ONE; } } else { record.function_queries[386].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained)); }; return Ok(__ret); }, _ => { @@ -34803,15 +34529,15 @@ fn aiur_fn_390( }) } -const INPUT_SIZE_391: usize = 1; -const IN_391: usize = 1; -const OUT_391: usize = 1; -fn aiur_fn_391( - inp: [G; IN_391], +const INPUT_SIZE_387: usize = 1; +const IN_387: usize = 1; +const OUT_387: usize = 1; +fn aiur_fn_387( + inp: [G; IN_387], record: &mut QueryRecord, io_buffer: &mut IOBuffer, unconstrained: bool, -) -> Result<[G; OUT_391], ExecError> { +) -> Result<[G; OUT_387], ExecError> { stacker::maybe_grow(64 * 1024, 4 * 1024 * 1024, || { let __v_0: G = inp[0]; let __r_arr: [G; OUT_144] = { let __args: [G; IN_144] = []; let __cu = unconstrained; if let Some(result) = record.function_queries[144].get_mut(&__args[..]) { if !__cu && *result.multiplicity == G::ZERO { aiur_fn_144(__args, record, io_buffer, false)? } else { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_144] = unsafe { *(result.output.as_ptr() as *const [G; OUT_144]) }; __ret } } else { aiur_fn_144(__args, record, io_buffer, __cu)? } }; @@ -35013,64 +34739,64 @@ fn aiur_fn_391( match __v_3.as_canonical_u64() { 1u64 => { let __v_4: G = G::from_u64(1); - let __ret: [G; OUT_391] = [__v_4]; - if let Some(result) = record.function_queries[391].get_mut(&inp[..]) { debug_assert_eq!(result.output, &__ret[..]); if !unconstrained { *result.multiplicity += G::ONE; } } else { record.function_queries[391].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained)); }; + let __ret: [G; OUT_387] = [__v_4]; + if let Some(result) = record.function_queries[387].get_mut(&inp[..]) { debug_assert_eq!(result.output, &__ret[..]); if !unconstrained { *result.multiplicity += G::ONE; } } else { record.function_queries[387].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained)); }; return Ok(__ret); }, _ => { - let __r_arr: [G; OUT_219] = { let __args: [G; IN_219] = [__v_0]; let __cu = unconstrained; if let Some(result) = record.function_queries[219].get_mut(&__args[..]) { if !__cu && *result.multiplicity == G::ZERO { aiur_fn_219(__args, record, io_buffer, false)? } else { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_219] = unsafe { *(result.output.as_ptr() as *const [G; OUT_219]) }; __ret } } else { aiur_fn_219(__args, record, io_buffer, __cu)? } }; + let __r_arr: [G; OUT_215] = { let __args: [G; IN_215] = [__v_0]; let __cu = unconstrained; if let Some(result) = record.function_queries[215].get_mut(&__args[..]) { if !__cu && *result.multiplicity == G::ZERO { aiur_fn_215(__args, record, io_buffer, false)? } else { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_215] = unsafe { *(result.output.as_ptr() as *const [G; OUT_215]) }; __ret } } else { aiur_fn_215(__args, record, io_buffer, __cu)? } }; let __v_4: G = __r_arr[0]; match __v_4.as_canonical_u64() { 1u64 => { let __v_5: G = G::from_u64(2); - let __ret: [G; OUT_391] = [__v_5]; - if let Some(result) = record.function_queries[391].get_mut(&inp[..]) { debug_assert_eq!(result.output, &__ret[..]); if !unconstrained { *result.multiplicity += G::ONE; } } else { record.function_queries[391].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained)); }; + let __ret: [G; OUT_387] = [__v_5]; + if let Some(result) = record.function_queries[387].get_mut(&inp[..]) { debug_assert_eq!(result.output, &__ret[..]); if !unconstrained { *result.multiplicity += G::ONE; } } else { record.function_queries[387].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained)); }; return Ok(__ret); }, _ => { - let __r_arr: [G; OUT_197] = { let __args: [G; IN_197] = [__v_0]; let __cu = unconstrained; if let Some(result) = record.function_queries[197].get_mut(&__args[..]) { if !__cu && *result.multiplicity == G::ZERO { aiur_fn_197(__args, record, io_buffer, false)? } else { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_197] = unsafe { *(result.output.as_ptr() as *const [G; OUT_197]) }; __ret } } else { aiur_fn_197(__args, record, io_buffer, __cu)? } }; + let __r_arr: [G; OUT_193] = { let __args: [G; IN_193] = [__v_0]; let __cu = unconstrained; if let Some(result) = record.function_queries[193].get_mut(&__args[..]) { if !__cu && *result.multiplicity == G::ZERO { aiur_fn_193(__args, record, io_buffer, false)? } else { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_193] = unsafe { *(result.output.as_ptr() as *const [G; OUT_193]) }; __ret } } else { aiur_fn_193(__args, record, io_buffer, __cu)? } }; let __v_5: G = __r_arr[0]; match __v_5.as_canonical_u64() { 1u64 => { let __v_6: G = G::from_u64(3); - let __ret: [G; OUT_391] = [__v_6]; - if let Some(result) = record.function_queries[391].get_mut(&inp[..]) { debug_assert_eq!(result.output, &__ret[..]); if !unconstrained { *result.multiplicity += G::ONE; } } else { record.function_queries[391].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained)); }; + let __ret: [G; OUT_387] = [__v_6]; + if let Some(result) = record.function_queries[387].get_mut(&inp[..]) { debug_assert_eq!(result.output, &__ret[..]); if !unconstrained { *result.multiplicity += G::ONE; } } else { record.function_queries[387].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained)); }; return Ok(__ret); }, _ => { - let __r_arr: [G; OUT_183] = { let __args: [G; IN_183] = [__v_0]; let __cu = unconstrained; if let Some(result) = record.function_queries[183].get_mut(&__args[..]) { if !__cu && *result.multiplicity == G::ZERO { aiur_fn_183(__args, record, io_buffer, false)? } else { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_183] = unsafe { *(result.output.as_ptr() as *const [G; OUT_183]) }; __ret } } else { aiur_fn_183(__args, record, io_buffer, __cu)? } }; + let __r_arr: [G; OUT_180] = { let __args: [G; IN_180] = [__v_0]; let __cu = unconstrained; if let Some(result) = record.function_queries[180].get_mut(&__args[..]) { if !__cu && *result.multiplicity == G::ZERO { aiur_fn_180(__args, record, io_buffer, false)? } else { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_180] = unsafe { *(result.output.as_ptr() as *const [G; OUT_180]) }; __ret } } else { aiur_fn_180(__args, record, io_buffer, __cu)? } }; let __v_6: G = __r_arr[0]; match __v_6.as_canonical_u64() { 1u64 => { let __v_7: G = G::from_u64(4); - let __ret: [G; OUT_391] = [__v_7]; - if let Some(result) = record.function_queries[391].get_mut(&inp[..]) { debug_assert_eq!(result.output, &__ret[..]); if !unconstrained { *result.multiplicity += G::ONE; } } else { record.function_queries[391].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained)); }; + let __ret: [G; OUT_387] = [__v_7]; + if let Some(result) = record.function_queries[387].get_mut(&inp[..]) { debug_assert_eq!(result.output, &__ret[..]); if !unconstrained { *result.multiplicity += G::ONE; } } else { record.function_queries[387].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained)); }; return Ok(__ret); }, _ => { - let __r_arr: [G; OUT_515] = { let __args: [G; IN_515] = [__v_0]; let __cu = unconstrained; if let Some(result) = record.function_queries[515].get_mut(&__args[..]) { if !__cu && *result.multiplicity == G::ZERO { aiur_fn_515(__args, record, io_buffer, false)? } else { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_515] = unsafe { *(result.output.as_ptr() as *const [G; OUT_515]) }; __ret } } else { aiur_fn_515(__args, record, io_buffer, __cu)? } }; + let __r_arr: [G; OUT_511] = { let __args: [G; IN_511] = [__v_0]; let __cu = unconstrained; if let Some(result) = record.function_queries[511].get_mut(&__args[..]) { if !__cu && *result.multiplicity == G::ZERO { aiur_fn_511(__args, record, io_buffer, false)? } else { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_511] = unsafe { *(result.output.as_ptr() as *const [G; OUT_511]) }; __ret } } else { aiur_fn_511(__args, record, io_buffer, __cu)? } }; let __v_7: G = __r_arr[0]; match __v_7.as_canonical_u64() { 1u64 => { let __v_8: G = G::from_u64(5); - let __ret: [G; OUT_391] = [__v_8]; - if let Some(result) = record.function_queries[391].get_mut(&inp[..]) { debug_assert_eq!(result.output, &__ret[..]); if !unconstrained { *result.multiplicity += G::ONE; } } else { record.function_queries[391].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained)); }; + let __ret: [G; OUT_387] = [__v_8]; + if let Some(result) = record.function_queries[387].get_mut(&inp[..]) { debug_assert_eq!(result.output, &__ret[..]); if !unconstrained { *result.multiplicity += G::ONE; } } else { record.function_queries[387].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained)); }; return Ok(__ret); }, _ => { - let __r_arr: [G; OUT_242] = { let __args: [G; IN_242] = [__v_0]; let __cu = unconstrained; if let Some(result) = record.function_queries[242].get_mut(&__args[..]) { if !__cu && *result.multiplicity == G::ZERO { aiur_fn_242(__args, record, io_buffer, false)? } else { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_242] = unsafe { *(result.output.as_ptr() as *const [G; OUT_242]) }; __ret } } else { aiur_fn_242(__args, record, io_buffer, __cu)? } }; + let __r_arr: [G; OUT_238] = { let __args: [G; IN_238] = [__v_0]; let __cu = unconstrained; if let Some(result) = record.function_queries[238].get_mut(&__args[..]) { if !__cu && *result.multiplicity == G::ZERO { aiur_fn_238(__args, record, io_buffer, false)? } else { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_238] = unsafe { *(result.output.as_ptr() as *const [G; OUT_238]) }; __ret } } else { aiur_fn_238(__args, record, io_buffer, __cu)? } }; let __v_8: G = __r_arr[0]; match __v_8.as_canonical_u64() { 1u64 => { let __v_9: G = G::from_u64(6); - let __ret: [G; OUT_391] = [__v_9]; - if let Some(result) = record.function_queries[391].get_mut(&inp[..]) { debug_assert_eq!(result.output, &__ret[..]); if !unconstrained { *result.multiplicity += G::ONE; } } else { record.function_queries[391].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained)); }; + let __ret: [G; OUT_387] = [__v_9]; + if let Some(result) = record.function_queries[387].get_mut(&inp[..]) { debug_assert_eq!(result.output, &__ret[..]); if !unconstrained { *result.multiplicity += G::ONE; } } else { record.function_queries[387].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained)); }; return Ok(__ret); }, _ => { let __v_9: G = G::from_u64(0); - let __ret: [G; OUT_391] = [__v_9]; - if let Some(result) = record.function_queries[391].get_mut(&inp[..]) { debug_assert_eq!(result.output, &__ret[..]); if !unconstrained { *result.multiplicity += G::ONE; } } else { record.function_queries[391].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained)); }; + let __ret: [G; OUT_387] = [__v_9]; + if let Some(result) = record.function_queries[387].get_mut(&inp[..]) { debug_assert_eq!(result.output, &__ret[..]); if !unconstrained { *result.multiplicity += G::ONE; } } else { record.function_queries[387].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained)); }; return Ok(__ret); }, } @@ -35087,71 +34813,71 @@ fn aiur_fn_391( }) } -const INPUT_SIZE_392: usize = 4; -const IN_392: usize = 4; -const OUT_392: usize = 2; -fn aiur_fn_392( - inp: [G; IN_392], +const INPUT_SIZE_388: usize = 4; +const IN_388: usize = 4; +const OUT_388: usize = 2; +fn aiur_fn_388( + inp: [G; IN_388], record: &mut QueryRecord, io_buffer: &mut IOBuffer, unconstrained: bool, -) -> Result<[G; OUT_392], ExecError> { +) -> Result<[G; OUT_388], ExecError> { stacker::maybe_grow(64 * 1024, 4 * 1024 * 1024, || { let __v_0: G = inp[0]; let __v_1: G = inp[1]; let __v_2: G = inp[2]; let __v_3: G = inp[3]; - let __r_arr: [G; OUT_391] = { let __args: [G; IN_391] = [__v_0]; let __cu = unconstrained; if let Some(result) = record.function_queries[391].get_mut(&__args[..]) { if !__cu && *result.multiplicity == G::ZERO { aiur_fn_391(__args, record, io_buffer, false)? } else { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_391] = unsafe { *(result.output.as_ptr() as *const [G; OUT_391]) }; __ret } } else { aiur_fn_391(__args, record, io_buffer, __cu)? } }; + let __r_arr: [G; OUT_387] = { let __args: [G; IN_387] = [__v_0]; let __cu = unconstrained; if let Some(result) = record.function_queries[387].get_mut(&__args[..]) { if !__cu && *result.multiplicity == G::ZERO { aiur_fn_387(__args, record, io_buffer, false)? } else { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_387] = unsafe { *(result.output.as_ptr() as *const [G; OUT_387]) }; __ret } } else { aiur_fn_387(__args, record, io_buffer, __cu)? } }; let __v_4: G = __r_arr[0]; match __v_4.as_canonical_u64() { 1u64 => { - let __r_arr: [G; OUT_389] = { let __args: [G; IN_389] = [__v_0, __v_2, __v_3]; let __cu = unconstrained; if let Some(result) = record.function_queries[389].get_mut(&__args[..]) { if !__cu && *result.multiplicity == G::ZERO { aiur_fn_389(__args, record, io_buffer, false)? } else { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_389] = unsafe { *(result.output.as_ptr() as *const [G; OUT_389]) }; __ret } } else { aiur_fn_389(__args, record, io_buffer, __cu)? } }; + let __r_arr: [G; OUT_385] = { let __args: [G; IN_385] = [__v_0, __v_2, __v_3]; let __cu = unconstrained; if let Some(result) = record.function_queries[385].get_mut(&__args[..]) { if !__cu && *result.multiplicity == G::ZERO { aiur_fn_385(__args, record, io_buffer, false)? } else { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_385] = unsafe { *(result.output.as_ptr() as *const [G; OUT_385]) }; __ret } } else { aiur_fn_385(__args, record, io_buffer, __cu)? } }; let __v_5: G = __r_arr[0]; let __v_6: G = __r_arr[1]; - let __ret: [G; OUT_392] = [__v_5, __v_6]; - if let Some(result) = record.function_queries[392].get_mut(&inp[..]) { debug_assert_eq!(result.output, &__ret[..]); if !unconstrained { *result.multiplicity += G::ONE; } } else { record.function_queries[392].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained)); }; + let __ret: [G; OUT_388] = [__v_5, __v_6]; + if let Some(result) = record.function_queries[388].get_mut(&inp[..]) { debug_assert_eq!(result.output, &__ret[..]); if !unconstrained { *result.multiplicity += G::ONE; } } else { record.function_queries[388].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained)); }; return Ok(__ret); }, 2u64 => { - let __r_arr: [G; OUT_388] = { let __args: [G; IN_388] = [__v_2, __v_3]; let __cu = unconstrained; if let Some(result) = record.function_queries[388].get_mut(&__args[..]) { if !__cu && *result.multiplicity == G::ZERO { aiur_fn_388(__args, record, io_buffer, false)? } else { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_388] = unsafe { *(result.output.as_ptr() as *const [G; OUT_388]) }; __ret } } else { aiur_fn_388(__args, record, io_buffer, __cu)? } }; + let __r_arr: [G; OUT_384] = { let __args: [G; IN_384] = [__v_2, __v_3]; let __cu = unconstrained; if let Some(result) = record.function_queries[384].get_mut(&__args[..]) { if !__cu && *result.multiplicity == G::ZERO { aiur_fn_384(__args, record, io_buffer, false)? } else { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_384] = unsafe { *(result.output.as_ptr() as *const [G; OUT_384]) }; __ret } } else { aiur_fn_384(__args, record, io_buffer, __cu)? } }; let __v_5: G = __r_arr[0]; - let __r_arr: [G; OUT_220] = { let __args: [G; IN_220] = [__v_0, __v_5, __v_3]; let __cu = unconstrained; if let Some(result) = record.function_queries[220].get_mut(&__args[..]) { if !__cu && *result.multiplicity == G::ZERO { aiur_fn_220(__args, record, io_buffer, false)? } else { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_220] = unsafe { *(result.output.as_ptr() as *const [G; OUT_220]) }; __ret } } else { aiur_fn_220(__args, record, io_buffer, __cu)? } }; + let __r_arr: [G; OUT_216] = { let __args: [G; IN_216] = [__v_0, __v_5, __v_3]; let __cu = unconstrained; if let Some(result) = record.function_queries[216].get_mut(&__args[..]) { if !__cu && *result.multiplicity == G::ZERO { aiur_fn_216(__args, record, io_buffer, false)? } else { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_216] = unsafe { *(result.output.as_ptr() as *const [G; OUT_216]) }; __ret } } else { aiur_fn_216(__args, record, io_buffer, __cu)? } }; let __v_6: G = __r_arr[0]; let __v_7: G = __r_arr[1]; - let __ret: [G; OUT_392] = [__v_6, __v_7]; - if let Some(result) = record.function_queries[392].get_mut(&inp[..]) { debug_assert_eq!(result.output, &__ret[..]); if !unconstrained { *result.multiplicity += G::ONE; } } else { record.function_queries[392].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained)); }; + let __ret: [G; OUT_388] = [__v_6, __v_7]; + if let Some(result) = record.function_queries[388].get_mut(&inp[..]) { debug_assert_eq!(result.output, &__ret[..]); if !unconstrained { *result.multiplicity += G::ONE; } } else { record.function_queries[388].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained)); }; return Ok(__ret); }, 3u64 => { - let __r_arr: [G; OUT_203] = { let __args: [G; IN_203] = [__v_0, __v_2, __v_3]; let __cu = unconstrained; if let Some(result) = record.function_queries[203].get_mut(&__args[..]) { if !__cu && *result.multiplicity == G::ZERO { aiur_fn_203(__args, record, io_buffer, false)? } else { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_203] = unsafe { *(result.output.as_ptr() as *const [G; OUT_203]) }; __ret } } else { aiur_fn_203(__args, record, io_buffer, __cu)? } }; + let __r_arr: [G; OUT_199] = { let __args: [G; IN_199] = [__v_0, __v_2, __v_3]; let __cu = unconstrained; if let Some(result) = record.function_queries[199].get_mut(&__args[..]) { if !__cu && *result.multiplicity == G::ZERO { aiur_fn_199(__args, record, io_buffer, false)? } else { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_199] = unsafe { *(result.output.as_ptr() as *const [G; OUT_199]) }; __ret } } else { aiur_fn_199(__args, record, io_buffer, __cu)? } }; let __v_5: G = __r_arr[0]; let __v_6: G = __r_arr[1]; - let __ret: [G; OUT_392] = [__v_5, __v_6]; - if let Some(result) = record.function_queries[392].get_mut(&inp[..]) { debug_assert_eq!(result.output, &__ret[..]); if !unconstrained { *result.multiplicity += G::ONE; } } else { record.function_queries[392].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained)); }; + let __ret: [G; OUT_388] = [__v_5, __v_6]; + if let Some(result) = record.function_queries[388].get_mut(&inp[..]) { debug_assert_eq!(result.output, &__ret[..]); if !unconstrained { *result.multiplicity += G::ONE; } } else { record.function_queries[388].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained)); }; return Ok(__ret); }, 4u64 => { - let __r_arr: [G; OUT_186] = { let __args: [G; IN_186] = [__v_0, __v_2, __v_3]; let __cu = unconstrained; if let Some(result) = record.function_queries[186].get_mut(&__args[..]) { if !__cu && *result.multiplicity == G::ZERO { aiur_fn_186(__args, record, io_buffer, false)? } else { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_186] = unsafe { *(result.output.as_ptr() as *const [G; OUT_186]) }; __ret } } else { aiur_fn_186(__args, record, io_buffer, __cu)? } }; + let __r_arr: [G; OUT_183] = { let __args: [G; IN_183] = [__v_0, __v_2, __v_3]; let __cu = unconstrained; if let Some(result) = record.function_queries[183].get_mut(&__args[..]) { if !__cu && *result.multiplicity == G::ZERO { aiur_fn_183(__args, record, io_buffer, false)? } else { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_183] = unsafe { *(result.output.as_ptr() as *const [G; OUT_183]) }; __ret } } else { aiur_fn_183(__args, record, io_buffer, __cu)? } }; let __v_5: G = __r_arr[0]; let __v_6: G = __r_arr[1]; - let __ret: [G; OUT_392] = [__v_5, __v_6]; - if let Some(result) = record.function_queries[392].get_mut(&inp[..]) { debug_assert_eq!(result.output, &__ret[..]); if !unconstrained { *result.multiplicity += G::ONE; } } else { record.function_queries[392].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained)); }; + let __ret: [G; OUT_388] = [__v_5, __v_6]; + if let Some(result) = record.function_queries[388].get_mut(&inp[..]) { debug_assert_eq!(result.output, &__ret[..]); if !unconstrained { *result.multiplicity += G::ONE; } } else { record.function_queries[388].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained)); }; return Ok(__ret); }, 5u64 => { - let __r_arr: [G; OUT_521] = { let __args: [G; IN_521] = [__v_0, __v_1, __v_2, __v_3]; let __cu = unconstrained; if let Some(result) = record.function_queries[521].get_mut(&__args[..]) { if !__cu && *result.multiplicity == G::ZERO { aiur_fn_521(__args, record, io_buffer, false)? } else { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_521] = unsafe { *(result.output.as_ptr() as *const [G; OUT_521]) }; __ret } } else { aiur_fn_521(__args, record, io_buffer, __cu)? } }; + let __r_arr: [G; OUT_517] = { let __args: [G; IN_517] = [__v_0, __v_1, __v_2, __v_3]; let __cu = unconstrained; if let Some(result) = record.function_queries[517].get_mut(&__args[..]) { if !__cu && *result.multiplicity == G::ZERO { aiur_fn_517(__args, record, io_buffer, false)? } else { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_517] = unsafe { *(result.output.as_ptr() as *const [G; OUT_517]) }; __ret } } else { aiur_fn_517(__args, record, io_buffer, __cu)? } }; let __v_5: G = __r_arr[0]; let __v_6: G = __r_arr[1]; - let __ret: [G; OUT_392] = [__v_5, __v_6]; - if let Some(result) = record.function_queries[392].get_mut(&inp[..]) { debug_assert_eq!(result.output, &__ret[..]); if !unconstrained { *result.multiplicity += G::ONE; } } else { record.function_queries[392].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained)); }; + let __ret: [G; OUT_388] = [__v_5, __v_6]; + if let Some(result) = record.function_queries[388].get_mut(&inp[..]) { debug_assert_eq!(result.output, &__ret[..]); if !unconstrained { *result.multiplicity += G::ONE; } } else { record.function_queries[388].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained)); }; return Ok(__ret); }, 6u64 => { - let __r_arr: [G; OUT_253] = { let __args: [G; IN_253] = [__v_0, __v_2, __v_3]; let __cu = unconstrained; if let Some(result) = record.function_queries[253].get_mut(&__args[..]) { if !__cu && *result.multiplicity == G::ZERO { aiur_fn_253(__args, record, io_buffer, false)? } else { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_253] = unsafe { *(result.output.as_ptr() as *const [G; OUT_253]) }; __ret } } else { aiur_fn_253(__args, record, io_buffer, __cu)? } }; + let __r_arr: [G; OUT_249] = { let __args: [G; IN_249] = [__v_0, __v_2, __v_3]; let __cu = unconstrained; if let Some(result) = record.function_queries[249].get_mut(&__args[..]) { if !__cu && *result.multiplicity == G::ZERO { aiur_fn_249(__args, record, io_buffer, false)? } else { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_249] = unsafe { *(result.output.as_ptr() as *const [G; OUT_249]) }; __ret } } else { aiur_fn_249(__args, record, io_buffer, __cu)? } }; let __v_5: G = __r_arr[0]; let __v_6: G = __r_arr[1]; - let __ret: [G; OUT_392] = [__v_5, __v_6]; - if let Some(result) = record.function_queries[392].get_mut(&inp[..]) { debug_assert_eq!(result.output, &__ret[..]); if !unconstrained { *result.multiplicity += G::ONE; } } else { record.function_queries[392].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained)); }; + let __ret: [G; OUT_388] = [__v_5, __v_6]; + if let Some(result) = record.function_queries[388].get_mut(&inp[..]) { debug_assert_eq!(result.output, &__ret[..]); if !unconstrained { *result.multiplicity += G::ONE; } } else { record.function_queries[388].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained)); }; return Ok(__ret); }, _ => { @@ -35160,52 +34886,52 @@ fn aiur_fn_392( let __v_7: G = G::from_u64(0); let __v_8: G = G::from_u64(0); let __v_9: G = { let __values: [G; 4] = [__v_6, __v_7, __v_8, __v_8]; let __mq = record.memory_queries.get_mut(&4).ok_or(ExecError::InvalidMemorySize(4))?; if let Some(result) = __mq.get_mut(&__values[..]) { if !unconstrained { *result.multiplicity += G::ONE; } result.output[0] } else { let __ptr = G::from_usize(__mq.len()); __mq.insert(&__values[..], &[__ptr], G::from_bool(!unconstrained)); __ptr } }; - let __ret: [G; OUT_392] = [__v_5, __v_9]; - if let Some(result) = record.function_queries[392].get_mut(&inp[..]) { debug_assert_eq!(result.output, &__ret[..]); if !unconstrained { *result.multiplicity += G::ONE; } } else { record.function_queries[392].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained)); }; + let __ret: [G; OUT_388] = [__v_5, __v_9]; + if let Some(result) = record.function_queries[388].get_mut(&inp[..]) { debug_assert_eq!(result.output, &__ret[..]); if !unconstrained { *result.multiplicity += G::ONE; } } else { record.function_queries[388].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained)); }; return Ok(__ret); }, } }) } -const INPUT_SIZE_393: usize = 3; -const IN_393: usize = 3; -const OUT_393: usize = 2; -fn aiur_fn_393( - inp: [G; IN_393], +const INPUT_SIZE_389: usize = 3; +const IN_389: usize = 3; +const OUT_389: usize = 2; +fn aiur_fn_389( + inp: [G; IN_389], record: &mut QueryRecord, io_buffer: &mut IOBuffer, unconstrained: bool, -) -> Result<[G; OUT_393], ExecError> { +) -> Result<[G; OUT_389], ExecError> { stacker::maybe_grow(64 * 1024, 4 * 1024 * 1024, || { let __v_0: G = inp[0]; let __v_1: G = inp[1]; let __v_2: G = inp[2]; - let __r_arr: [G; OUT_384] = { let __args: [G; IN_384] = []; let __cu = unconstrained; if let Some(result) = record.function_queries[384].get_mut(&__args[..]) { if !__cu && *result.multiplicity == G::ZERO { aiur_fn_384(__args, record, io_buffer, false)? } else { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_384] = unsafe { *(result.output.as_ptr() as *const [G; OUT_384]) }; __ret } } else { aiur_fn_384(__args, record, io_buffer, __cu)? } }; + let __r_arr: [G; OUT_380] = { let __args: [G; IN_380] = []; let __cu = unconstrained; if let Some(result) = record.function_queries[380].get_mut(&__args[..]) { if !__cu && *result.multiplicity == G::ZERO { aiur_fn_380(__args, record, io_buffer, false)? } else { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_380] = unsafe { *(result.output.as_ptr() as *const [G; OUT_380]) }; __ret } } else { aiur_fn_380(__args, record, io_buffer, __cu)? } }; let __v_3: G = __r_arr[0]; let __r_arr: [G; OUT_1] = { let __args: [G; IN_1] = [__v_0, __v_3]; let __cu = unconstrained; if let Some(result) = record.function_queries[1].get_mut(&__args[..]) { if !__cu && *result.multiplicity == G::ZERO { aiur_fn_1(__args, record, io_buffer, false)? } else { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_1] = unsafe { *(result.output.as_ptr() as *const [G; OUT_1]) }; __ret } } else { aiur_fn_1(__args, record, io_buffer, __cu)? } }; let __v_4: G = __r_arr[0]; match __v_4.as_canonical_u64() { 1u64 => { - let __r_arr: [G; OUT_394] = { let __args: [G; IN_394] = [__v_1, __v_2]; let __cu = unconstrained; if let Some(result) = record.function_queries[394].get_mut(&__args[..]) { if !__cu && *result.multiplicity == G::ZERO { aiur_fn_394(__args, record, io_buffer, false)? } else { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_394] = unsafe { *(result.output.as_ptr() as *const [G; OUT_394]) }; __ret } } else { aiur_fn_394(__args, record, io_buffer, __cu)? } }; + let __r_arr: [G; OUT_390] = { let __args: [G; IN_390] = [__v_1, __v_2]; let __cu = unconstrained; if let Some(result) = record.function_queries[390].get_mut(&__args[..]) { if !__cu && *result.multiplicity == G::ZERO { aiur_fn_390(__args, record, io_buffer, false)? } else { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_390] = unsafe { *(result.output.as_ptr() as *const [G; OUT_390]) }; __ret } } else { aiur_fn_390(__args, record, io_buffer, __cu)? } }; let __v_5: G = __r_arr[0]; let __v_6: G = __r_arr[1]; - let __ret: [G; OUT_393] = [__v_5, __v_6]; - if let Some(result) = record.function_queries[393].get_mut(&inp[..]) { debug_assert_eq!(result.output, &__ret[..]); if !unconstrained { *result.multiplicity += G::ONE; } } else { record.function_queries[393].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained)); }; + let __ret: [G; OUT_389] = [__v_5, __v_6]; + if let Some(result) = record.function_queries[389].get_mut(&inp[..]) { debug_assert_eq!(result.output, &__ret[..]); if !unconstrained { *result.multiplicity += G::ONE; } } else { record.function_queries[389].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained)); }; return Ok(__ret); }, _ => { - let __r_arr: [G; OUT_385] = { let __args: [G; IN_385] = []; let __cu = unconstrained; if let Some(result) = record.function_queries[385].get_mut(&__args[..]) { if !__cu && *result.multiplicity == G::ZERO { aiur_fn_385(__args, record, io_buffer, false)? } else { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_385] = unsafe { *(result.output.as_ptr() as *const [G; OUT_385]) }; __ret } } else { aiur_fn_385(__args, record, io_buffer, __cu)? } }; + let __r_arr: [G; OUT_381] = { let __args: [G; IN_381] = []; let __cu = unconstrained; if let Some(result) = record.function_queries[381].get_mut(&__args[..]) { if !__cu && *result.multiplicity == G::ZERO { aiur_fn_381(__args, record, io_buffer, false)? } else { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_381] = unsafe { *(result.output.as_ptr() as *const [G; OUT_381]) }; __ret } } else { aiur_fn_381(__args, record, io_buffer, __cu)? } }; let __v_5: G = __r_arr[0]; let __r_arr: [G; OUT_1] = { let __args: [G; IN_1] = [__v_0, __v_5]; let __cu = unconstrained; if let Some(result) = record.function_queries[1].get_mut(&__args[..]) { if !__cu && *result.multiplicity == G::ZERO { aiur_fn_1(__args, record, io_buffer, false)? } else { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_1] = unsafe { *(result.output.as_ptr() as *const [G; OUT_1]) }; __ret } } else { aiur_fn_1(__args, record, io_buffer, __cu)? } }; let __v_6: G = __r_arr[0]; match __v_6.as_canonical_u64() { 1u64 => { - let __r_arr: [G; OUT_395] = { let __args: [G; IN_395] = [__v_1, __v_2]; let __cu = unconstrained; if let Some(result) = record.function_queries[395].get_mut(&__args[..]) { if !__cu && *result.multiplicity == G::ZERO { aiur_fn_395(__args, record, io_buffer, false)? } else { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_395] = unsafe { *(result.output.as_ptr() as *const [G; OUT_395]) }; __ret } } else { aiur_fn_395(__args, record, io_buffer, __cu)? } }; + let __r_arr: [G; OUT_391] = { let __args: [G; IN_391] = [__v_1, __v_2]; let __cu = unconstrained; if let Some(result) = record.function_queries[391].get_mut(&__args[..]) { if !__cu && *result.multiplicity == G::ZERO { aiur_fn_391(__args, record, io_buffer, false)? } else { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_391] = unsafe { *(result.output.as_ptr() as *const [G; OUT_391]) }; __ret } } else { aiur_fn_391(__args, record, io_buffer, __cu)? } }; let __v_7: G = __r_arr[0]; let __v_8: G = __r_arr[1]; - let __ret: [G; OUT_393] = [__v_7, __v_8]; - if let Some(result) = record.function_queries[393].get_mut(&inp[..]) { debug_assert_eq!(result.output, &__ret[..]); if !unconstrained { *result.multiplicity += G::ONE; } } else { record.function_queries[393].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained)); }; + let __ret: [G; OUT_389] = [__v_7, __v_8]; + if let Some(result) = record.function_queries[389].get_mut(&inp[..]) { debug_assert_eq!(result.output, &__ret[..]); if !unconstrained { *result.multiplicity += G::ONE; } } else { record.function_queries[389].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained)); }; return Ok(__ret); }, _ => { @@ -35214,8 +34940,8 @@ fn aiur_fn_393( let __v_9: G = G::from_u64(0); let __v_10: G = G::from_u64(0); let __v_11: G = { let __values: [G; 4] = [__v_8, __v_9, __v_10, __v_10]; let __mq = record.memory_queries.get_mut(&4).ok_or(ExecError::InvalidMemorySize(4))?; if let Some(result) = __mq.get_mut(&__values[..]) { if !unconstrained { *result.multiplicity += G::ONE; } result.output[0] } else { let __ptr = G::from_usize(__mq.len()); __mq.insert(&__values[..], &[__ptr], G::from_bool(!unconstrained)); __ptr } }; - let __ret: [G; OUT_393] = [__v_7, __v_11]; - if let Some(result) = record.function_queries[393].get_mut(&inp[..]) { debug_assert_eq!(result.output, &__ret[..]); if !unconstrained { *result.multiplicity += G::ONE; } } else { record.function_queries[393].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained)); }; + let __ret: [G; OUT_389] = [__v_7, __v_11]; + if let Some(result) = record.function_queries[389].get_mut(&inp[..]) { debug_assert_eq!(result.output, &__ret[..]); if !unconstrained { *result.multiplicity += G::ONE; } } else { record.function_queries[389].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained)); }; return Ok(__ret); }, } @@ -35224,19 +34950,19 @@ fn aiur_fn_393( }) } -const INPUT_SIZE_394: usize = 2; -const IN_394: usize = 2; -const OUT_394: usize = 2; -fn aiur_fn_394( - inp: [G; IN_394], +const INPUT_SIZE_390: usize = 2; +const IN_390: usize = 2; +const OUT_390: usize = 2; +fn aiur_fn_390( + inp: [G; IN_390], record: &mut QueryRecord, io_buffer: &mut IOBuffer, unconstrained: bool, -) -> Result<[G; OUT_394], ExecError> { +) -> Result<[G; OUT_390], ExecError> { stacker::maybe_grow(64 * 1024, 4 * 1024 * 1024, || { let __v_0: G = inp[0]; let __v_1: G = inp[1]; - let __r_arr: [G; OUT_764] = { let __args: [G; IN_764] = [__v_0]; let __cu = unconstrained; if let Some(result) = record.function_queries[764].get_mut(&__args[..]) { if !__cu && *result.multiplicity == G::ZERO { aiur_fn_764(__args, record, io_buffer, false)? } else { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_764] = unsafe { *(result.output.as_ptr() as *const [G; OUT_764]) }; __ret } } else { aiur_fn_764(__args, record, io_buffer, __cu)? } }; + let __r_arr: [G; OUT_760] = { let __args: [G; IN_760] = [__v_0]; let __cu = unconstrained; if let Some(result) = record.function_queries[760].get_mut(&__args[..]) { if !__cu && *result.multiplicity == G::ZERO { aiur_fn_760(__args, record, io_buffer, false)? } else { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_760] = unsafe { *(result.output.as_ptr() as *const [G; OUT_760]) }; __ret } } else { aiur_fn_760(__args, record, io_buffer, __cu)? } }; let __v_2: G = __r_arr[0]; let __v_3: G = G::from_u64(6); let __v_4: G = { let __a_val = __v_2.as_canonical_u64(); let __b_val = __v_3.as_canonical_u64(); let __a_u32 = u32::try_from(__a_val).ok().ok_or(ExecError::U32OutOfRange(__a_val))?; let __b_u32 = u32::try_from(__b_val).ok().ok_or(ExecError::U32OutOfRange(__b_val))?; let __result = G::from_bool(__a_u32 < __b_u32); if !unconstrained { let __x_bytes = __a_u32.to_le_bytes(); let __z_bytes = __b_u32.to_le_bytes(); let __c_u32 = __b_u32.wrapping_sub(__a_u32).wrapping_sub(1); let __y_bytes = __c_u32.to_le_bytes(); record.bytes2_queries.bump_range_check(&G::from_u8(__x_bytes[0]), &G::from_u8(__x_bytes[1])); record.bytes2_queries.bump_range_check(&G::from_u8(__x_bytes[2]), &G::from_u8(__x_bytes[3])); record.bytes2_queries.bump_range_check(&G::from_u8(__y_bytes[0]), &G::from_u8(__y_bytes[1])); record.bytes2_queries.bump_range_check(&G::from_u8(__y_bytes[2]), &G::from_u8(__y_bytes[3])); record.bytes2_queries.bump_range_check(&G::from_u8(__z_bytes[0]), &G::from_u8(__z_bytes[1])); record.bytes2_queries.bump_range_check(&G::from_u8(__z_bytes[2]), &G::from_u8(__z_bytes[3])); } __result }; @@ -35247,33 +34973,33 @@ fn aiur_fn_394( let __v_7: G = G::from_u64(0); let __v_8: G = G::from_u64(0); let __v_9: G = { let __values: [G; 4] = [__v_6, __v_7, __v_8, __v_8]; let __mq = record.memory_queries.get_mut(&4).ok_or(ExecError::InvalidMemorySize(4))?; if let Some(result) = __mq.get_mut(&__values[..]) { if !unconstrained { *result.multiplicity += G::ONE; } result.output[0] } else { let __ptr = G::from_usize(__mq.len()); __mq.insert(&__values[..], &[__ptr], G::from_bool(!unconstrained)); __ptr } }; - let __ret: [G; OUT_394] = [__v_5, __v_9]; - if let Some(result) = record.function_queries[394].get_mut(&inp[..]) { debug_assert_eq!(result.output, &__ret[..]); if !unconstrained { *result.multiplicity += G::ONE; } } else { record.function_queries[394].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained)); }; + let __ret: [G; OUT_390] = [__v_5, __v_9]; + if let Some(result) = record.function_queries[390].get_mut(&inp[..]) { debug_assert_eq!(result.output, &__ret[..]); if !unconstrained { *result.multiplicity += G::ONE; } } else { record.function_queries[390].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained)); }; return Ok(__ret); }, _ => { let __v_5: G = G::from_u64(3); - let __r_arr: [G; OUT_766] = { let __args: [G; IN_766] = [__v_0, __v_5]; let __cu = unconstrained; if let Some(result) = record.function_queries[766].get_mut(&__args[..]) { if !__cu && *result.multiplicity == G::ZERO { aiur_fn_766(__args, record, io_buffer, false)? } else { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_766] = unsafe { *(result.output.as_ptr() as *const [G; OUT_766]) }; __ret } } else { aiur_fn_766(__args, record, io_buffer, __cu)? } }; + let __r_arr: [G; OUT_762] = { let __args: [G; IN_762] = [__v_0, __v_5]; let __cu = unconstrained; if let Some(result) = record.function_queries[762].get_mut(&__args[..]) { if !__cu && *result.multiplicity == G::ZERO { aiur_fn_762(__args, record, io_buffer, false)? } else { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_762] = unsafe { *(result.output.as_ptr() as *const [G; OUT_762]) }; __ret } } else { aiur_fn_762(__args, record, io_buffer, __cu)? } }; let __v_6: G = __r_arr[0]; let __v_7: G = G::from_u64(5); - let __r_arr: [G; OUT_766] = { let __args: [G; IN_766] = [__v_0, __v_7]; let __cu = unconstrained; if let Some(result) = record.function_queries[766].get_mut(&__args[..]) { if !__cu && *result.multiplicity == G::ZERO { aiur_fn_766(__args, record, io_buffer, false)? } else { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_766] = unsafe { *(result.output.as_ptr() as *const [G; OUT_766]) }; __ret } } else { aiur_fn_766(__args, record, io_buffer, __cu)? } }; + let __r_arr: [G; OUT_762] = { let __args: [G; IN_762] = [__v_0, __v_7]; let __cu = unconstrained; if let Some(result) = record.function_queries[762].get_mut(&__args[..]) { if !__cu && *result.multiplicity == G::ZERO { aiur_fn_762(__args, record, io_buffer, false)? } else { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_762] = unsafe { *(result.output.as_ptr() as *const [G; OUT_762]) }; __ret } } else { aiur_fn_762(__args, record, io_buffer, __cu)? } }; let __v_8: G = __r_arr[0]; - let __r_arr: [G; OUT_396] = { let __args: [G; IN_396] = [__v_8, __v_1]; let __cu = unconstrained; if let Some(result) = record.function_queries[396].get_mut(&__args[..]) { if !__cu && *result.multiplicity == G::ZERO { aiur_fn_396(__args, record, io_buffer, false)? } else { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_396] = unsafe { *(result.output.as_ptr() as *const [G; OUT_396]) }; __ret } } else { aiur_fn_396(__args, record, io_buffer, __cu)? } }; + let __r_arr: [G; OUT_392] = { let __args: [G; IN_392] = [__v_8, __v_1]; let __cu = unconstrained; if let Some(result) = record.function_queries[392].get_mut(&__args[..]) { if !__cu && *result.multiplicity == G::ZERO { aiur_fn_392(__args, record, io_buffer, false)? } else { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_392] = unsafe { *(result.output.as_ptr() as *const [G; OUT_392]) }; __ret } } else { aiur_fn_392(__args, record, io_buffer, __cu)? } }; let __v_9: G = __r_arr[0]; let __v_10: G = __r_arr[1]; match __v_9.as_canonical_u64() { 1u64 => { let __v_11: G = G::from_u64(6); - let __r_arr: [G; OUT_775] = { let __args: [G; IN_775] = [__v_0, __v_11]; let __cu = unconstrained; if let Some(result) = record.function_queries[775].get_mut(&__args[..]) { if !__cu && *result.multiplicity == G::ZERO { aiur_fn_775(__args, record, io_buffer, false)? } else { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_775] = unsafe { *(result.output.as_ptr() as *const [G; OUT_775]) }; __ret } } else { aiur_fn_775(__args, record, io_buffer, __cu)? } }; + let __r_arr: [G; OUT_771] = { let __args: [G; IN_771] = [__v_0, __v_11]; let __cu = unconstrained; if let Some(result) = record.function_queries[771].get_mut(&__args[..]) { if !__cu && *result.multiplicity == G::ZERO { aiur_fn_771(__args, record, io_buffer, false)? } else { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_771] = unsafe { *(result.output.as_ptr() as *const [G; OUT_771]) }; __ret } } else { aiur_fn_771(__args, record, io_buffer, __cu)? } }; let __v_12: G = __r_arr[0]; let __v_13: G = G::from_u64(1); let __v_14: G = G::from_u64(3); let __v_15: G = G::from_u64(0); let __v_16: G = { let __values: [G; 4] = [__v_14, __v_6, __v_10, __v_15]; let __mq = record.memory_queries.get_mut(&4).ok_or(ExecError::InvalidMemorySize(4))?; if let Some(result) = __mq.get_mut(&__values[..]) { if !unconstrained { *result.multiplicity += G::ONE; } result.output[0] } else { let __ptr = G::from_usize(__mq.len()); __mq.insert(&__values[..], &[__ptr], G::from_bool(!unconstrained)); __ptr } }; - let __r_arr: [G; OUT_255] = { let __args: [G; IN_255] = [__v_16, __v_12]; let __cu = unconstrained; if let Some(result) = record.function_queries[255].get_mut(&__args[..]) { if !__cu && *result.multiplicity == G::ZERO { aiur_fn_255(__args, record, io_buffer, false)? } else { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_255] = unsafe { *(result.output.as_ptr() as *const [G; OUT_255]) }; __ret } } else { aiur_fn_255(__args, record, io_buffer, __cu)? } }; + let __r_arr: [G; OUT_251] = { let __args: [G; IN_251] = [__v_16, __v_12]; let __cu = unconstrained; if let Some(result) = record.function_queries[251].get_mut(&__args[..]) { if !__cu && *result.multiplicity == G::ZERO { aiur_fn_251(__args, record, io_buffer, false)? } else { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_251] = unsafe { *(result.output.as_ptr() as *const [G; OUT_251]) }; __ret } } else { aiur_fn_251(__args, record, io_buffer, __cu)? } }; let __v_17: G = __r_arr[0]; - let __ret: [G; OUT_394] = [__v_13, __v_17]; - if let Some(result) = record.function_queries[394].get_mut(&inp[..]) { debug_assert_eq!(result.output, &__ret[..]); if !unconstrained { *result.multiplicity += G::ONE; } } else { record.function_queries[394].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained)); }; + let __ret: [G; OUT_390] = [__v_13, __v_17]; + if let Some(result) = record.function_queries[390].get_mut(&inp[..]) { debug_assert_eq!(result.output, &__ret[..]); if !unconstrained { *result.multiplicity += G::ONE; } } else { record.function_queries[390].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained)); }; return Ok(__ret); }, _ => { @@ -35282,8 +35008,8 @@ fn aiur_fn_394( let __v_13: G = G::from_u64(0); let __v_14: G = G::from_u64(0); let __v_15: G = { let __values: [G; 4] = [__v_12, __v_13, __v_14, __v_14]; let __mq = record.memory_queries.get_mut(&4).ok_or(ExecError::InvalidMemorySize(4))?; if let Some(result) = __mq.get_mut(&__values[..]) { if !unconstrained { *result.multiplicity += G::ONE; } result.output[0] } else { let __ptr = G::from_usize(__mq.len()); __mq.insert(&__values[..], &[__ptr], G::from_bool(!unconstrained)); __ptr } }; - let __ret: [G; OUT_394] = [__v_11, __v_15]; - if let Some(result) = record.function_queries[394].get_mut(&inp[..]) { debug_assert_eq!(result.output, &__ret[..]); if !unconstrained { *result.multiplicity += G::ONE; } } else { record.function_queries[394].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained)); }; + let __ret: [G; OUT_390] = [__v_11, __v_15]; + if let Some(result) = record.function_queries[390].get_mut(&inp[..]) { debug_assert_eq!(result.output, &__ret[..]); if !unconstrained { *result.multiplicity += G::ONE; } } else { record.function_queries[390].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained)); }; return Ok(__ret); }, } @@ -35292,19 +35018,19 @@ fn aiur_fn_394( }) } -const INPUT_SIZE_395: usize = 2; -const IN_395: usize = 2; -const OUT_395: usize = 2; -fn aiur_fn_395( - inp: [G; IN_395], +const INPUT_SIZE_391: usize = 2; +const IN_391: usize = 2; +const OUT_391: usize = 2; +fn aiur_fn_391( + inp: [G; IN_391], record: &mut QueryRecord, io_buffer: &mut IOBuffer, unconstrained: bool, -) -> Result<[G; OUT_395], ExecError> { +) -> Result<[G; OUT_391], ExecError> { stacker::maybe_grow(64 * 1024, 4 * 1024 * 1024, || { let __v_0: G = inp[0]; let __v_1: G = inp[1]; - let __r_arr: [G; OUT_764] = { let __args: [G; IN_764] = [__v_0]; let __cu = unconstrained; if let Some(result) = record.function_queries[764].get_mut(&__args[..]) { if !__cu && *result.multiplicity == G::ZERO { aiur_fn_764(__args, record, io_buffer, false)? } else { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_764] = unsafe { *(result.output.as_ptr() as *const [G; OUT_764]) }; __ret } } else { aiur_fn_764(__args, record, io_buffer, __cu)? } }; + let __r_arr: [G; OUT_760] = { let __args: [G; IN_760] = [__v_0]; let __cu = unconstrained; if let Some(result) = record.function_queries[760].get_mut(&__args[..]) { if !__cu && *result.multiplicity == G::ZERO { aiur_fn_760(__args, record, io_buffer, false)? } else { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_760] = unsafe { *(result.output.as_ptr() as *const [G; OUT_760]) }; __ret } } else { aiur_fn_760(__args, record, io_buffer, __cu)? } }; let __v_2: G = __r_arr[0]; let __v_3: G = G::from_u64(5); let __v_4: G = { let __a_val = __v_2.as_canonical_u64(); let __b_val = __v_3.as_canonical_u64(); let __a_u32 = u32::try_from(__a_val).ok().ok_or(ExecError::U32OutOfRange(__a_val))?; let __b_u32 = u32::try_from(__b_val).ok().ok_or(ExecError::U32OutOfRange(__b_val))?; let __result = G::from_bool(__a_u32 < __b_u32); if !unconstrained { let __x_bytes = __a_u32.to_le_bytes(); let __z_bytes = __b_u32.to_le_bytes(); let __c_u32 = __b_u32.wrapping_sub(__a_u32).wrapping_sub(1); let __y_bytes = __c_u32.to_le_bytes(); record.bytes2_queries.bump_range_check(&G::from_u8(__x_bytes[0]), &G::from_u8(__x_bytes[1])); record.bytes2_queries.bump_range_check(&G::from_u8(__x_bytes[2]), &G::from_u8(__x_bytes[3])); record.bytes2_queries.bump_range_check(&G::from_u8(__y_bytes[0]), &G::from_u8(__y_bytes[1])); record.bytes2_queries.bump_range_check(&G::from_u8(__y_bytes[2]), &G::from_u8(__y_bytes[3])); record.bytes2_queries.bump_range_check(&G::from_u8(__z_bytes[0]), &G::from_u8(__z_bytes[1])); record.bytes2_queries.bump_range_check(&G::from_u8(__z_bytes[2]), &G::from_u8(__z_bytes[3])); } __result }; @@ -35315,33 +35041,33 @@ fn aiur_fn_395( let __v_7: G = G::from_u64(0); let __v_8: G = G::from_u64(0); let __v_9: G = { let __values: [G; 4] = [__v_6, __v_7, __v_8, __v_8]; let __mq = record.memory_queries.get_mut(&4).ok_or(ExecError::InvalidMemorySize(4))?; if let Some(result) = __mq.get_mut(&__values[..]) { if !unconstrained { *result.multiplicity += G::ONE; } result.output[0] } else { let __ptr = G::from_usize(__mq.len()); __mq.insert(&__values[..], &[__ptr], G::from_bool(!unconstrained)); __ptr } }; - let __ret: [G; OUT_395] = [__v_5, __v_9]; - if let Some(result) = record.function_queries[395].get_mut(&inp[..]) { debug_assert_eq!(result.output, &__ret[..]); if !unconstrained { *result.multiplicity += G::ONE; } } else { record.function_queries[395].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained)); }; + let __ret: [G; OUT_391] = [__v_5, __v_9]; + if let Some(result) = record.function_queries[391].get_mut(&inp[..]) { debug_assert_eq!(result.output, &__ret[..]); if !unconstrained { *result.multiplicity += G::ONE; } } else { record.function_queries[391].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained)); }; return Ok(__ret); }, _ => { let __v_5: G = G::from_u64(3); - let __r_arr: [G; OUT_766] = { let __args: [G; IN_766] = [__v_0, __v_5]; let __cu = unconstrained; if let Some(result) = record.function_queries[766].get_mut(&__args[..]) { if !__cu && *result.multiplicity == G::ZERO { aiur_fn_766(__args, record, io_buffer, false)? } else { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_766] = unsafe { *(result.output.as_ptr() as *const [G; OUT_766]) }; __ret } } else { aiur_fn_766(__args, record, io_buffer, __cu)? } }; + let __r_arr: [G; OUT_762] = { let __args: [G; IN_762] = [__v_0, __v_5]; let __cu = unconstrained; if let Some(result) = record.function_queries[762].get_mut(&__args[..]) { if !__cu && *result.multiplicity == G::ZERO { aiur_fn_762(__args, record, io_buffer, false)? } else { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_762] = unsafe { *(result.output.as_ptr() as *const [G; OUT_762]) }; __ret } } else { aiur_fn_762(__args, record, io_buffer, __cu)? } }; let __v_6: G = __r_arr[0]; let __v_7: G = G::from_u64(4); - let __r_arr: [G; OUT_766] = { let __args: [G; IN_766] = [__v_0, __v_7]; let __cu = unconstrained; if let Some(result) = record.function_queries[766].get_mut(&__args[..]) { if !__cu && *result.multiplicity == G::ZERO { aiur_fn_766(__args, record, io_buffer, false)? } else { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_766] = unsafe { *(result.output.as_ptr() as *const [G; OUT_766]) }; __ret } } else { aiur_fn_766(__args, record, io_buffer, __cu)? } }; + let __r_arr: [G; OUT_762] = { let __args: [G; IN_762] = [__v_0, __v_7]; let __cu = unconstrained; if let Some(result) = record.function_queries[762].get_mut(&__args[..]) { if !__cu && *result.multiplicity == G::ZERO { aiur_fn_762(__args, record, io_buffer, false)? } else { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_762] = unsafe { *(result.output.as_ptr() as *const [G; OUT_762]) }; __ret } } else { aiur_fn_762(__args, record, io_buffer, __cu)? } }; let __v_8: G = __r_arr[0]; - let __r_arr: [G; OUT_396] = { let __args: [G; IN_396] = [__v_8, __v_1]; let __cu = unconstrained; if let Some(result) = record.function_queries[396].get_mut(&__args[..]) { if !__cu && *result.multiplicity == G::ZERO { aiur_fn_396(__args, record, io_buffer, false)? } else { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_396] = unsafe { *(result.output.as_ptr() as *const [G; OUT_396]) }; __ret } } else { aiur_fn_396(__args, record, io_buffer, __cu)? } }; + let __r_arr: [G; OUT_392] = { let __args: [G; IN_392] = [__v_8, __v_1]; let __cu = unconstrained; if let Some(result) = record.function_queries[392].get_mut(&__args[..]) { if !__cu && *result.multiplicity == G::ZERO { aiur_fn_392(__args, record, io_buffer, false)? } else { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_392] = unsafe { *(result.output.as_ptr() as *const [G; OUT_392]) }; __ret } } else { aiur_fn_392(__args, record, io_buffer, __cu)? } }; let __v_9: G = __r_arr[0]; let __v_10: G = __r_arr[1]; match __v_9.as_canonical_u64() { 1u64 => { let __v_11: G = G::from_u64(5); - let __r_arr: [G; OUT_775] = { let __args: [G; IN_775] = [__v_0, __v_11]; let __cu = unconstrained; if let Some(result) = record.function_queries[775].get_mut(&__args[..]) { if !__cu && *result.multiplicity == G::ZERO { aiur_fn_775(__args, record, io_buffer, false)? } else { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_775] = unsafe { *(result.output.as_ptr() as *const [G; OUT_775]) }; __ret } } else { aiur_fn_775(__args, record, io_buffer, __cu)? } }; + let __r_arr: [G; OUT_771] = { let __args: [G; IN_771] = [__v_0, __v_11]; let __cu = unconstrained; if let Some(result) = record.function_queries[771].get_mut(&__args[..]) { if !__cu && *result.multiplicity == G::ZERO { aiur_fn_771(__args, record, io_buffer, false)? } else { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_771] = unsafe { *(result.output.as_ptr() as *const [G; OUT_771]) }; __ret } } else { aiur_fn_771(__args, record, io_buffer, __cu)? } }; let __v_12: G = __r_arr[0]; let __v_13: G = G::from_u64(1); let __v_14: G = G::from_u64(3); let __v_15: G = G::from_u64(0); let __v_16: G = { let __values: [G; 4] = [__v_14, __v_6, __v_10, __v_15]; let __mq = record.memory_queries.get_mut(&4).ok_or(ExecError::InvalidMemorySize(4))?; if let Some(result) = __mq.get_mut(&__values[..]) { if !unconstrained { *result.multiplicity += G::ONE; } result.output[0] } else { let __ptr = G::from_usize(__mq.len()); __mq.insert(&__values[..], &[__ptr], G::from_bool(!unconstrained)); __ptr } }; - let __r_arr: [G; OUT_255] = { let __args: [G; IN_255] = [__v_16, __v_12]; let __cu = unconstrained; if let Some(result) = record.function_queries[255].get_mut(&__args[..]) { if !__cu && *result.multiplicity == G::ZERO { aiur_fn_255(__args, record, io_buffer, false)? } else { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_255] = unsafe { *(result.output.as_ptr() as *const [G; OUT_255]) }; __ret } } else { aiur_fn_255(__args, record, io_buffer, __cu)? } }; + let __r_arr: [G; OUT_251] = { let __args: [G; IN_251] = [__v_16, __v_12]; let __cu = unconstrained; if let Some(result) = record.function_queries[251].get_mut(&__args[..]) { if !__cu && *result.multiplicity == G::ZERO { aiur_fn_251(__args, record, io_buffer, false)? } else { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_251] = unsafe { *(result.output.as_ptr() as *const [G; OUT_251]) }; __ret } } else { aiur_fn_251(__args, record, io_buffer, __cu)? } }; let __v_17: G = __r_arr[0]; - let __ret: [G; OUT_395] = [__v_13, __v_17]; - if let Some(result) = record.function_queries[395].get_mut(&inp[..]) { debug_assert_eq!(result.output, &__ret[..]); if !unconstrained { *result.multiplicity += G::ONE; } } else { record.function_queries[395].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained)); }; + let __ret: [G; OUT_391] = [__v_13, __v_17]; + if let Some(result) = record.function_queries[391].get_mut(&inp[..]) { debug_assert_eq!(result.output, &__ret[..]); if !unconstrained { *result.multiplicity += G::ONE; } } else { record.function_queries[391].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained)); }; return Ok(__ret); }, _ => { @@ -35350,8 +35076,8 @@ fn aiur_fn_395( let __v_13: G = G::from_u64(0); let __v_14: G = G::from_u64(0); let __v_15: G = { let __values: [G; 4] = [__v_12, __v_13, __v_14, __v_14]; let __mq = record.memory_queries.get_mut(&4).ok_or(ExecError::InvalidMemorySize(4))?; if let Some(result) = __mq.get_mut(&__values[..]) { if !unconstrained { *result.multiplicity += G::ONE; } result.output[0] } else { let __ptr = G::from_usize(__mq.len()); __mq.insert(&__values[..], &[__ptr], G::from_bool(!unconstrained)); __ptr } }; - let __ret: [G; OUT_395] = [__v_11, __v_15]; - if let Some(result) = record.function_queries[395].get_mut(&inp[..]) { debug_assert_eq!(result.output, &__ret[..]); if !unconstrained { *result.multiplicity += G::ONE; } } else { record.function_queries[395].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained)); }; + let __ret: [G; OUT_391] = [__v_11, __v_15]; + if let Some(result) = record.function_queries[391].get_mut(&inp[..]) { debug_assert_eq!(result.output, &__ret[..]); if !unconstrained { *result.multiplicity += G::ONE; } } else { record.function_queries[391].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained)); }; return Ok(__ret); }, } @@ -35360,19 +35086,19 @@ fn aiur_fn_395( }) } -const INPUT_SIZE_396: usize = 2; -const IN_396: usize = 2; -const OUT_396: usize = 2; -fn aiur_fn_396( - inp: [G; IN_396], +const INPUT_SIZE_392: usize = 2; +const IN_392: usize = 2; +const OUT_392: usize = 2; +fn aiur_fn_392( + inp: [G; IN_392], record: &mut QueryRecord, io_buffer: &mut IOBuffer, unconstrained: bool, -) -> Result<[G; OUT_396], ExecError> { +) -> Result<[G; OUT_392], ExecError> { stacker::maybe_grow(64 * 1024, 4 * 1024 * 1024, || { let __v_0: G = inp[0]; let __v_1: G = inp[1]; - let __r_arr: [G; OUT_418] = { let __args: [G; IN_418] = [__v_0, __v_1]; let __cu = unconstrained; if let Some(result) = record.function_queries[418].get_mut(&__args[..]) { if !__cu && *result.multiplicity == G::ZERO { aiur_fn_418(__args, record, io_buffer, false)? } else { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_418] = unsafe { *(result.output.as_ptr() as *const [G; OUT_418]) }; __ret } } else { aiur_fn_418(__args, record, io_buffer, __cu)? } }; + let __r_arr: [G; OUT_414] = { let __args: [G; IN_414] = [__v_0, __v_1]; let __cu = unconstrained; if let Some(result) = record.function_queries[414].get_mut(&__args[..]) { if !__cu && *result.multiplicity == G::ZERO { aiur_fn_414(__args, record, io_buffer, false)? } else { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_414] = unsafe { *(result.output.as_ptr() as *const [G; OUT_414]) }; __ret } } else { aiur_fn_414(__args, record, io_buffer, __cu)? } }; let __v_2: G = __r_arr[0]; let __r_arr: [G; OUT_111] = { let __args: [G; IN_111] = [__v_2]; let __cu = unconstrained; if let Some(result) = record.function_queries[111].get_mut(&__args[..]) { if !__cu && *result.multiplicity == G::ZERO { aiur_fn_111(__args, record, io_buffer, false)? } else { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_111] = unsafe { *(result.output.as_ptr() as *const [G; OUT_111]) }; __ret } } else { aiur_fn_111(__args, record, io_buffer, __cu)? } }; let __v_3: G = __r_arr[0]; @@ -35384,13 +35110,13 @@ fn aiur_fn_396( let __v_8: G = __loaded[3]; match __v_5.as_canonical_u64() { 2u64 => { - let __r_arr: [G; OUT_383] = { let __args: [G; IN_383] = []; let __cu = unconstrained; if let Some(result) = record.function_queries[383].get_mut(&__args[..]) { if !__cu && *result.multiplicity == G::ZERO { aiur_fn_383(__args, record, io_buffer, false)? } else { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_383] = unsafe { *(result.output.as_ptr() as *const [G; OUT_383]) }; __ret } } else { aiur_fn_383(__args, record, io_buffer, __cu)? } }; + let __r_arr: [G; OUT_379] = { let __args: [G; IN_379] = []; let __cu = unconstrained; if let Some(result) = record.function_queries[379].get_mut(&__args[..]) { if !__cu && *result.multiplicity == G::ZERO { aiur_fn_379(__args, record, io_buffer, false)? } else { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_379] = unsafe { *(result.output.as_ptr() as *const [G; OUT_379]) }; __ret } } else { aiur_fn_379(__args, record, io_buffer, __cu)? } }; let __v_9: G = __r_arr[0]; let __r_arr: [G; OUT_1] = { let __args: [G; IN_1] = [__v_6, __v_9]; let __cu = unconstrained; if let Some(result) = record.function_queries[1].get_mut(&__args[..]) { if !__cu && *result.multiplicity == G::ZERO { aiur_fn_1(__args, record, io_buffer, false)? } else { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_1] = unsafe { *(result.output.as_ptr() as *const [G; OUT_1]) }; __ret } } else { aiur_fn_1(__args, record, io_buffer, __cu)? } }; let __v_10: G = __r_arr[0]; match __v_10.as_canonical_u64() { 1u64 => { - let __r_arr: [G; OUT_764] = { let __args: [G; IN_764] = [__v_4]; let __cu = unconstrained; if let Some(result) = record.function_queries[764].get_mut(&__args[..]) { if !__cu && *result.multiplicity == G::ZERO { aiur_fn_764(__args, record, io_buffer, false)? } else { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_764] = unsafe { *(result.output.as_ptr() as *const [G; OUT_764]) }; __ret } } else { aiur_fn_764(__args, record, io_buffer, __cu)? } }; + let __r_arr: [G; OUT_760] = { let __args: [G; IN_760] = [__v_4]; let __cu = unconstrained; if let Some(result) = record.function_queries[760].get_mut(&__args[..]) { if !__cu && *result.multiplicity == G::ZERO { aiur_fn_760(__args, record, io_buffer, false)? } else { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_760] = unsafe { *(result.output.as_ptr() as *const [G; OUT_760]) }; __ret } } else { aiur_fn_760(__args, record, io_buffer, __cu)? } }; let __v_11: G = __r_arr[0]; let __v_12: G = G::from_u64(3); let __v_13: G = (__v_11 - __v_12); @@ -35398,10 +35124,10 @@ fn aiur_fn_396( 0u64 => { let __v_14: G = G::from_u64(1); let __v_15: G = G::from_u64(2); - let __r_arr: [G; OUT_766] = { let __args: [G; IN_766] = [__v_4, __v_15]; let __cu = unconstrained; if let Some(result) = record.function_queries[766].get_mut(&__args[..]) { if !__cu && *result.multiplicity == G::ZERO { aiur_fn_766(__args, record, io_buffer, false)? } else { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_766] = unsafe { *(result.output.as_ptr() as *const [G; OUT_766]) }; __ret } } else { aiur_fn_766(__args, record, io_buffer, __cu)? } }; + let __r_arr: [G; OUT_762] = { let __args: [G; IN_762] = [__v_4, __v_15]; let __cu = unconstrained; if let Some(result) = record.function_queries[762].get_mut(&__args[..]) { if !__cu && *result.multiplicity == G::ZERO { aiur_fn_762(__args, record, io_buffer, false)? } else { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_762] = unsafe { *(result.output.as_ptr() as *const [G; OUT_762]) }; __ret } } else { aiur_fn_762(__args, record, io_buffer, __cu)? } }; let __v_16: G = __r_arr[0]; - let __ret: [G; OUT_396] = [__v_14, __v_16]; - if let Some(result) = record.function_queries[396].get_mut(&inp[..]) { debug_assert_eq!(result.output, &__ret[..]); if !unconstrained { *result.multiplicity += G::ONE; } } else { record.function_queries[396].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained)); }; + let __ret: [G; OUT_392] = [__v_14, __v_16]; + if let Some(result) = record.function_queries[392].get_mut(&inp[..]) { debug_assert_eq!(result.output, &__ret[..]); if !unconstrained { *result.multiplicity += G::ONE; } } else { record.function_queries[392].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained)); }; return Ok(__ret); }, _ => { @@ -35410,8 +35136,8 @@ fn aiur_fn_396( let __v_16: G = G::from_u64(0); let __v_17: G = G::from_u64(0); let __v_18: G = { let __values: [G; 4] = [__v_15, __v_16, __v_17, __v_17]; let __mq = record.memory_queries.get_mut(&4).ok_or(ExecError::InvalidMemorySize(4))?; if let Some(result) = __mq.get_mut(&__values[..]) { if !unconstrained { *result.multiplicity += G::ONE; } result.output[0] } else { let __ptr = G::from_usize(__mq.len()); __mq.insert(&__values[..], &[__ptr], G::from_bool(!unconstrained)); __ptr } }; - let __ret: [G; OUT_396] = [__v_14, __v_18]; - if let Some(result) = record.function_queries[396].get_mut(&inp[..]) { debug_assert_eq!(result.output, &__ret[..]); if !unconstrained { *result.multiplicity += G::ONE; } } else { record.function_queries[396].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained)); }; + let __ret: [G; OUT_392] = [__v_14, __v_18]; + if let Some(result) = record.function_queries[392].get_mut(&inp[..]) { debug_assert_eq!(result.output, &__ret[..]); if !unconstrained { *result.multiplicity += G::ONE; } } else { record.function_queries[392].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained)); }; return Ok(__ret); }, } @@ -35422,8 +35148,8 @@ fn aiur_fn_396( let __v_13: G = G::from_u64(0); let __v_14: G = G::from_u64(0); let __v_15: G = { let __values: [G; 4] = [__v_12, __v_13, __v_14, __v_14]; let __mq = record.memory_queries.get_mut(&4).ok_or(ExecError::InvalidMemorySize(4))?; if let Some(result) = __mq.get_mut(&__values[..]) { if !unconstrained { *result.multiplicity += G::ONE; } result.output[0] } else { let __ptr = G::from_usize(__mq.len()); __mq.insert(&__values[..], &[__ptr], G::from_bool(!unconstrained)); __ptr } }; - let __ret: [G; OUT_396] = [__v_11, __v_15]; - if let Some(result) = record.function_queries[396].get_mut(&inp[..]) { debug_assert_eq!(result.output, &__ret[..]); if !unconstrained { *result.multiplicity += G::ONE; } } else { record.function_queries[396].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained)); }; + let __ret: [G; OUT_392] = [__v_11, __v_15]; + if let Some(result) = record.function_queries[392].get_mut(&inp[..]) { debug_assert_eq!(result.output, &__ret[..]); if !unconstrained { *result.multiplicity += G::ONE; } } else { record.function_queries[392].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained)); }; return Ok(__ret); }, } @@ -35434,47 +35160,47 @@ fn aiur_fn_396( let __v_11: G = G::from_u64(0); let __v_12: G = G::from_u64(0); let __v_13: G = { let __values: [G; 4] = [__v_10, __v_11, __v_12, __v_12]; let __mq = record.memory_queries.get_mut(&4).ok_or(ExecError::InvalidMemorySize(4))?; if let Some(result) = __mq.get_mut(&__values[..]) { if !unconstrained { *result.multiplicity += G::ONE; } result.output[0] } else { let __ptr = G::from_usize(__mq.len()); __mq.insert(&__values[..], &[__ptr], G::from_bool(!unconstrained)); __ptr } }; - let __ret: [G; OUT_396] = [__v_9, __v_13]; - if let Some(result) = record.function_queries[396].get_mut(&inp[..]) { debug_assert_eq!(result.output, &__ret[..]); if !unconstrained { *result.multiplicity += G::ONE; } } else { record.function_queries[396].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained)); }; + let __ret: [G; OUT_392] = [__v_9, __v_13]; + if let Some(result) = record.function_queries[392].get_mut(&inp[..]) { debug_assert_eq!(result.output, &__ret[..]); if !unconstrained { *result.multiplicity += G::ONE; } } else { record.function_queries[392].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained)); }; return Ok(__ret); }, } }) } -const INPUT_SIZE_397: usize = 5; -const IN_397: usize = 5; -const OUT_397: usize = 1; -fn aiur_fn_397( - inp: [G; IN_397], +const INPUT_SIZE_393: usize = 5; +const IN_393: usize = 5; +const OUT_393: usize = 1; +fn aiur_fn_393( + inp: [G; IN_393], record: &mut QueryRecord, io_buffer: &mut IOBuffer, unconstrained: bool, -) -> Result<[G; OUT_397], ExecError> { +) -> Result<[G; OUT_393], ExecError> { stacker::maybe_grow(64 * 1024, 4 * 1024 * 1024, || { let __v_0: G = inp[0]; let __v_1: G = inp[1]; let __v_2: G = inp[2]; let __v_3: G = inp[3]; let __v_4: G = inp[4]; - let __r_arr: [G; OUT_392] = { let __args: [G; IN_392] = [__v_0, __v_1, __v_3, __v_4]; let __cu = unconstrained; if let Some(result) = record.function_queries[392].get_mut(&__args[..]) { if !__cu && *result.multiplicity == G::ZERO { aiur_fn_392(__args, record, io_buffer, false)? } else { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_392] = unsafe { *(result.output.as_ptr() as *const [G; OUT_392]) }; __ret } } else { aiur_fn_392(__args, record, io_buffer, __cu)? } }; + let __r_arr: [G; OUT_388] = { let __args: [G; IN_388] = [__v_0, __v_1, __v_3, __v_4]; let __cu = unconstrained; if let Some(result) = record.function_queries[388].get_mut(&__args[..]) { if !__cu && *result.multiplicity == G::ZERO { aiur_fn_388(__args, record, io_buffer, false)? } else { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_388] = unsafe { *(result.output.as_ptr() as *const [G; OUT_388]) }; __ret } } else { aiur_fn_388(__args, record, io_buffer, __cu)? } }; let __v_5: G = __r_arr[0]; let __v_6: G = __r_arr[1]; match __v_5.as_canonical_u64() { 1u64 => { - let __r_arr: [G; OUT_418] = { let __args: [G; IN_418] = [__v_6, __v_4]; let __cu = unconstrained; if let Some(result) = record.function_queries[418].get_mut(&__args[..]) { if !__cu && *result.multiplicity == G::ZERO { aiur_fn_418(__args, record, io_buffer, false)? } else { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_418] = unsafe { *(result.output.as_ptr() as *const [G; OUT_418]) }; __ret } } else { aiur_fn_418(__args, record, io_buffer, __cu)? } }; + let __r_arr: [G; OUT_414] = { let __args: [G; IN_414] = [__v_6, __v_4]; let __cu = unconstrained; if let Some(result) = record.function_queries[414].get_mut(&__args[..]) { if !__cu && *result.multiplicity == G::ZERO { aiur_fn_414(__args, record, io_buffer, false)? } else { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_414] = unsafe { *(result.output.as_ptr() as *const [G; OUT_414]) }; __ret } } else { aiur_fn_414(__args, record, io_buffer, __cu)? } }; let __v_7: G = __r_arr[0]; - let __ret: [G; OUT_397] = [__v_7]; - if let Some(result) = record.function_queries[397].get_mut(&inp[..]) { debug_assert_eq!(result.output, &__ret[..]); if !unconstrained { *result.multiplicity += G::ONE; } } else { record.function_queries[397].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained)); }; + let __ret: [G; OUT_393] = [__v_7]; + if let Some(result) = record.function_queries[393].get_mut(&inp[..]) { debug_assert_eq!(result.output, &__ret[..]); if !unconstrained { *result.multiplicity += G::ONE; } } else { record.function_queries[393].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained)); }; return Ok(__ret); }, 2u64 => { - let __ret: [G; OUT_397] = [__v_6]; - if let Some(result) = record.function_queries[397].get_mut(&inp[..]) { debug_assert_eq!(result.output, &__ret[..]); if !unconstrained { *result.multiplicity += G::ONE; } } else { record.function_queries[397].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained)); }; + let __ret: [G; OUT_393] = [__v_6]; + if let Some(result) = record.function_queries[393].get_mut(&inp[..]) { debug_assert_eq!(result.output, &__ret[..]); if !unconstrained { *result.multiplicity += G::ONE; } } else { record.function_queries[393].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained)); }; return Ok(__ret); }, _ => { - let __r_arr: [G; OUT_287] = { let __args: [G; IN_287] = [__v_0]; let __cu = unconstrained; if let Some(result) = record.function_queries[287].get_mut(&__args[..]) { if !__cu && *result.multiplicity == G::ZERO { aiur_fn_287(__args, record, io_buffer, false)? } else { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_287] = unsafe { *(result.output.as_ptr() as *const [G; OUT_287]) }; __ret } } else { aiur_fn_287(__args, record, io_buffer, __cu)? } }; + let __r_arr: [G; OUT_283] = { let __args: [G; IN_283] = [__v_0]; let __cu = unconstrained; if let Some(result) = record.function_queries[283].get_mut(&__args[..]) { if !__cu && *result.multiplicity == G::ZERO { aiur_fn_283(__args, record, io_buffer, false)? } else { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_283] = unsafe { *(result.output.as_ptr() as *const [G; OUT_283]) }; __ret } } else { aiur_fn_283(__args, record, io_buffer, __cu)? } }; let __v_7: G = __r_arr[0]; let __loaded: [G; 12] = { let __mq = record.memory_queries.get_mut(&12).ok_or(ExecError::InvalidMemorySize(12))?; let __ptr_u64 = __v_7.as_canonical_u64(); let __ptr_usize = usize::try_from(__ptr_u64).ok().ok_or(ExecError::PointerTooLarge(__ptr_u64))?; let (__args, __mult) = __mq.get_index_mut(__ptr_usize).ok_or(ExecError::UnboundPointer { ptr: __ptr_u64, size: 12 })?; if !unconstrained { *__mult += G::ONE; } let __arr: [G; 12] = __args[..12].try_into().unwrap(); __arr }; let __v_8: G = __loaded[0]; @@ -35491,52 +35217,52 @@ fn aiur_fn_397( let __v_19: G = __loaded[11]; match __v_8.as_canonical_u64() { 1u64 => { - let __r_arr: [G; OUT_398] = { let __args: [G; IN_398] = [__v_11, __v_3]; let __cu = unconstrained; if let Some(result) = record.function_queries[398].get_mut(&__args[..]) { if !__cu && *result.multiplicity == G::ZERO { aiur_fn_398(__args, record, io_buffer, false)? } else { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_398] = unsafe { *(result.output.as_ptr() as *const [G; OUT_398]) }; __ret } } else { aiur_fn_398(__args, record, io_buffer, __cu)? } }; + let __r_arr: [G; OUT_394] = { let __args: [G; IN_394] = [__v_11, __v_3]; let __cu = unconstrained; if let Some(result) = record.function_queries[394].get_mut(&__args[..]) { if !__cu && *result.multiplicity == G::ZERO { aiur_fn_394(__args, record, io_buffer, false)? } else { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_394] = unsafe { *(result.output.as_ptr() as *const [G; OUT_394]) }; __ret } } else { aiur_fn_394(__args, record, io_buffer, __cu)? } }; let __v_20: G = __r_arr[0]; let __v_21: G = __r_arr[1]; match __v_20.as_canonical_u64() { 1u64 => { - let __r_arr: [G; OUT_418] = { let __args: [G; IN_418] = [__v_21, __v_4]; let __cu = unconstrained; if let Some(result) = record.function_queries[418].get_mut(&__args[..]) { if !__cu && *result.multiplicity == G::ZERO { aiur_fn_418(__args, record, io_buffer, false)? } else { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_418] = unsafe { *(result.output.as_ptr() as *const [G; OUT_418]) }; __ret } } else { aiur_fn_418(__args, record, io_buffer, __cu)? } }; + let __r_arr: [G; OUT_414] = { let __args: [G; IN_414] = [__v_21, __v_4]; let __cu = unconstrained; if let Some(result) = record.function_queries[414].get_mut(&__args[..]) { if !__cu && *result.multiplicity == G::ZERO { aiur_fn_414(__args, record, io_buffer, false)? } else { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_414] = unsafe { *(result.output.as_ptr() as *const [G; OUT_414]) }; __ret } } else { aiur_fn_414(__args, record, io_buffer, __cu)? } }; let __v_22: G = __r_arr[0]; - let __ret: [G; OUT_397] = [__v_22]; - if let Some(result) = record.function_queries[397].get_mut(&inp[..]) { debug_assert_eq!(result.output, &__ret[..]); if !unconstrained { *result.multiplicity += G::ONE; } } else { record.function_queries[397].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained)); }; + let __ret: [G; OUT_393] = [__v_22]; + if let Some(result) = record.function_queries[393].get_mut(&inp[..]) { debug_assert_eq!(result.output, &__ret[..]); if !unconstrained { *result.multiplicity += G::ONE; } } else { record.function_queries[393].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained)); }; return Ok(__ret); }, _ => { - let __r_arr: [G; OUT_336] = { let __args: [G; IN_336] = [__v_11, __v_1]; let __cu = unconstrained; if let Some(result) = record.function_queries[336].get_mut(&__args[..]) { if !__cu && *result.multiplicity == G::ZERO { aiur_fn_336(__args, record, io_buffer, false)? } else { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_336] = unsafe { *(result.output.as_ptr() as *const [G; OUT_336]) }; __ret } } else { aiur_fn_336(__args, record, io_buffer, __cu)? } }; + let __r_arr: [G; OUT_332] = { let __args: [G; IN_332] = [__v_11, __v_1]; let __cu = unconstrained; if let Some(result) = record.function_queries[332].get_mut(&__args[..]) { if !__cu && *result.multiplicity == G::ZERO { aiur_fn_332(__args, record, io_buffer, false)? } else { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_332] = unsafe { *(result.output.as_ptr() as *const [G; OUT_332]) }; __ret } } else { aiur_fn_332(__args, record, io_buffer, __cu)? } }; let __v_22: G = __r_arr[0]; - let __r_arr: [G; OUT_378] = { let __args: [G; IN_378] = [__v_22, __v_3, __v_4]; let __cu = unconstrained; if let Some(result) = record.function_queries[378].get_mut(&__args[..]) { if !__cu && *result.multiplicity == G::ZERO { aiur_fn_378(__args, record, io_buffer, false)? } else { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_378] = unsafe { *(result.output.as_ptr() as *const [G; OUT_378]) }; __ret } } else { aiur_fn_378(__args, record, io_buffer, __cu)? } }; + let __r_arr: [G; OUT_374] = { let __args: [G; IN_374] = [__v_22, __v_3, __v_4]; let __cu = unconstrained; if let Some(result) = record.function_queries[374].get_mut(&__args[..]) { if !__cu && *result.multiplicity == G::ZERO { aiur_fn_374(__args, record, io_buffer, false)? } else { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_374] = unsafe { *(result.output.as_ptr() as *const [G; OUT_374]) }; __ret } } else { aiur_fn_374(__args, record, io_buffer, __cu)? } }; let __v_23: G = __r_arr[0]; - let __ret: [G; OUT_397] = [__v_23]; - if let Some(result) = record.function_queries[397].get_mut(&inp[..]) { debug_assert_eq!(result.output, &__ret[..]); if !unconstrained { *result.multiplicity += G::ONE; } } else { record.function_queries[397].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained)); }; + let __ret: [G; OUT_393] = [__v_23]; + if let Some(result) = record.function_queries[393].get_mut(&inp[..]) { debug_assert_eq!(result.output, &__ret[..]); if !unconstrained { *result.multiplicity += G::ONE; } } else { record.function_queries[393].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained)); }; return Ok(__ret); }, } }, 2u64 => { - let __r_arr: [G; OUT_255] = { let __args: [G; IN_255] = [__v_2, __v_3]; let __cu = unconstrained; if let Some(result) = record.function_queries[255].get_mut(&__args[..]) { if !__cu && *result.multiplicity == G::ZERO { aiur_fn_255(__args, record, io_buffer, false)? } else { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_255] = unsafe { *(result.output.as_ptr() as *const [G; OUT_255]) }; __ret } } else { aiur_fn_255(__args, record, io_buffer, __cu)? } }; + let __r_arr: [G; OUT_251] = { let __args: [G; IN_251] = [__v_2, __v_3]; let __cu = unconstrained; if let Some(result) = record.function_queries[251].get_mut(&__args[..]) { if !__cu && *result.multiplicity == G::ZERO { aiur_fn_251(__args, record, io_buffer, false)? } else { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_251] = unsafe { *(result.output.as_ptr() as *const [G; OUT_251]) }; __ret } } else { aiur_fn_251(__args, record, io_buffer, __cu)? } }; let __v_20: G = __r_arr[0]; - let __ret: [G; OUT_397] = [__v_20]; - if let Some(result) = record.function_queries[397].get_mut(&inp[..]) { debug_assert_eq!(result.output, &__ret[..]); if !unconstrained { *result.multiplicity += G::ONE; } } else { record.function_queries[397].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained)); }; + let __ret: [G; OUT_393] = [__v_20]; + if let Some(result) = record.function_queries[393].get_mut(&inp[..]) { debug_assert_eq!(result.output, &__ret[..]); if !unconstrained { *result.multiplicity += G::ONE; } } else { record.function_queries[393].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained)); }; return Ok(__ret); }, 4u64 => { - let __r_arr: [G; OUT_393] = { let __args: [G; IN_393] = [__v_0, __v_3, __v_4]; let __cu = unconstrained; if let Some(result) = record.function_queries[393].get_mut(&__args[..]) { if !__cu && *result.multiplicity == G::ZERO { aiur_fn_393(__args, record, io_buffer, false)? } else { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_393] = unsafe { *(result.output.as_ptr() as *const [G; OUT_393]) }; __ret } } else { aiur_fn_393(__args, record, io_buffer, __cu)? } }; + let __r_arr: [G; OUT_389] = { let __args: [G; IN_389] = [__v_0, __v_3, __v_4]; let __cu = unconstrained; if let Some(result) = record.function_queries[389].get_mut(&__args[..]) { if !__cu && *result.multiplicity == G::ZERO { aiur_fn_389(__args, record, io_buffer, false)? } else { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_389] = unsafe { *(result.output.as_ptr() as *const [G; OUT_389]) }; __ret } } else { aiur_fn_389(__args, record, io_buffer, __cu)? } }; let __v_20: G = __r_arr[0]; let __v_21: G = __r_arr[1]; match __v_20.as_canonical_u64() { 1u64 => { - let __r_arr: [G; OUT_418] = { let __args: [G; IN_418] = [__v_21, __v_4]; let __cu = unconstrained; if let Some(result) = record.function_queries[418].get_mut(&__args[..]) { if !__cu && *result.multiplicity == G::ZERO { aiur_fn_418(__args, record, io_buffer, false)? } else { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_418] = unsafe { *(result.output.as_ptr() as *const [G; OUT_418]) }; __ret } } else { aiur_fn_418(__args, record, io_buffer, __cu)? } }; + let __r_arr: [G; OUT_414] = { let __args: [G; IN_414] = [__v_21, __v_4]; let __cu = unconstrained; if let Some(result) = record.function_queries[414].get_mut(&__args[..]) { if !__cu && *result.multiplicity == G::ZERO { aiur_fn_414(__args, record, io_buffer, false)? } else { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_414] = unsafe { *(result.output.as_ptr() as *const [G; OUT_414]) }; __ret } } else { aiur_fn_414(__args, record, io_buffer, __cu)? } }; let __v_22: G = __r_arr[0]; - let __ret: [G; OUT_397] = [__v_22]; - if let Some(result) = record.function_queries[397].get_mut(&inp[..]) { debug_assert_eq!(result.output, &__ret[..]); if !unconstrained { *result.multiplicity += G::ONE; } } else { record.function_queries[397].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained)); }; + let __ret: [G; OUT_393] = [__v_22]; + if let Some(result) = record.function_queries[393].get_mut(&inp[..]) { debug_assert_eq!(result.output, &__ret[..]); if !unconstrained { *result.multiplicity += G::ONE; } } else { record.function_queries[393].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained)); }; return Ok(__ret); }, _ => { - let __r_arr: [G; OUT_255] = { let __args: [G; IN_255] = [__v_2, __v_3]; let __cu = unconstrained; if let Some(result) = record.function_queries[255].get_mut(&__args[..]) { if !__cu && *result.multiplicity == G::ZERO { aiur_fn_255(__args, record, io_buffer, false)? } else { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_255] = unsafe { *(result.output.as_ptr() as *const [G; OUT_255]) }; __ret } } else { aiur_fn_255(__args, record, io_buffer, __cu)? } }; + let __r_arr: [G; OUT_251] = { let __args: [G; IN_251] = [__v_2, __v_3]; let __cu = unconstrained; if let Some(result) = record.function_queries[251].get_mut(&__args[..]) { if !__cu && *result.multiplicity == G::ZERO { aiur_fn_251(__args, record, io_buffer, false)? } else { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_251] = unsafe { *(result.output.as_ptr() as *const [G; OUT_251]) }; __ret } } else { aiur_fn_251(__args, record, io_buffer, __cu)? } }; let __v_22: G = __r_arr[0]; - let __ret: [G; OUT_397] = [__v_22]; - if let Some(result) = record.function_queries[397].get_mut(&inp[..]) { debug_assert_eq!(result.output, &__ret[..]); if !unconstrained { *result.multiplicity += G::ONE; } } else { record.function_queries[397].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained)); }; + let __ret: [G; OUT_393] = [__v_22]; + if let Some(result) = record.function_queries[393].get_mut(&inp[..]) { debug_assert_eq!(result.output, &__ret[..]); if !unconstrained { *result.multiplicity += G::ONE; } } else { record.function_queries[393].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained)); }; return Ok(__ret); }, } @@ -35547,10 +35273,10 @@ fn aiur_fn_397( let __v_22: G = (__v_21 + __v_12); let __mc_out___mc_0: [G; 2] = '__mc_0: { match __v_16.as_canonical_u64() { 1u64 => { - let __r_arr: [G; OUT_409] = { let __args: [G; IN_409] = [__v_10, __v_22]; let __cu = unconstrained; if let Some(result) = record.function_queries[409].get_mut(&__args[..]) { if !__cu && *result.multiplicity == G::ZERO { aiur_fn_409(__args, record, io_buffer, false)? } else { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_409] = unsafe { *(result.output.as_ptr() as *const [G; OUT_409]) }; __ret } } else { aiur_fn_409(__args, record, io_buffer, __cu)? } }; + let __r_arr: [G; OUT_405] = { let __args: [G; IN_405] = [__v_10, __v_22]; let __cu = unconstrained; if let Some(result) = record.function_queries[405].get_mut(&__args[..]) { if !__cu && *result.multiplicity == G::ZERO { aiur_fn_405(__args, record, io_buffer, false)? } else { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_405] = unsafe { *(result.output.as_ptr() as *const [G; OUT_405]) }; __ret } } else { aiur_fn_405(__args, record, io_buffer, __cu)? } }; let __v_23: G = __r_arr[0]; let __v_24: G = __r_arr[1]; - let __r_arr: [G; OUT_401] = { let __args: [G; IN_401] = [__v_1, __v_3, __v_11, __v_13, __v_14, __v_12, __v_15, __v_24, __v_4]; let __cu = unconstrained; if let Some(result) = record.function_queries[401].get_mut(&__args[..]) { if !__cu && *result.multiplicity == G::ZERO { aiur_fn_401(__args, record, io_buffer, false)? } else { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_401] = unsafe { *(result.output.as_ptr() as *const [G; OUT_401]) }; __ret } } else { aiur_fn_401(__args, record, io_buffer, __cu)? } }; + let __r_arr: [G; OUT_397] = { let __args: [G; IN_397] = [__v_1, __v_3, __v_11, __v_13, __v_14, __v_12, __v_15, __v_24, __v_4]; let __cu = unconstrained; if let Some(result) = record.function_queries[397].get_mut(&__args[..]) { if !__cu && *result.multiplicity == G::ZERO { aiur_fn_397(__args, record, io_buffer, false)? } else { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_397] = unsafe { *(result.output.as_ptr() as *const [G; OUT_397]) }; __ret } } else { aiur_fn_397(__args, record, io_buffer, __cu)? } }; let __v_25: G = __r_arr[0]; let __v_26: G = __r_arr[1]; break '__mc_0 [__v_25, __v_26]; @@ -35565,46 +35291,46 @@ fn aiur_fn_397( let __v_24: G = __mc_out___mc_0[1]; match __v_23.as_canonical_u64() { 1u64 => { - let __ret: [G; OUT_397] = [__v_24]; - if let Some(result) = record.function_queries[397].get_mut(&inp[..]) { debug_assert_eq!(result.output, &__ret[..]); if !unconstrained { *result.multiplicity += G::ONE; } } else { record.function_queries[397].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained)); }; + let __ret: [G; OUT_393] = [__v_24]; + if let Some(result) = record.function_queries[393].get_mut(&inp[..]) { debug_assert_eq!(result.output, &__ret[..]); if !unconstrained { *result.multiplicity += G::ONE; } } else { record.function_queries[393].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained)); }; return Ok(__ret); }, _ => { - let __r_arr: [G; OUT_623] = { let __args: [G; IN_623] = [__v_10, __v_11, __v_13, __v_14, __v_12]; let __cu = unconstrained; if let Some(result) = record.function_queries[623].get_mut(&__args[..]) { if !__cu && *result.multiplicity == G::ZERO { aiur_fn_623(__args, record, io_buffer, false)? } else { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_623] = unsafe { *(result.output.as_ptr() as *const [G; OUT_623]) }; __ret } } else { aiur_fn_623(__args, record, io_buffer, __cu)? } }; + let __r_arr: [G; OUT_619] = { let __args: [G; IN_619] = [__v_10, __v_11, __v_13, __v_14, __v_12]; let __cu = unconstrained; if let Some(result) = record.function_queries[619].get_mut(&__args[..]) { if !__cu && *result.multiplicity == G::ZERO { aiur_fn_619(__args, record, io_buffer, false)? } else { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_619] = unsafe { *(result.output.as_ptr() as *const [G; OUT_619]) }; __ret } } else { aiur_fn_619(__args, record, io_buffer, __cu)? } }; let __v_25: G = __r_arr[0]; - let __r_arr: [G; OUT_405] = { let __args: [G; IN_405] = [__v_1, __v_3, __v_11, __v_13, __v_14, __v_12, __v_15, __v_4, __v_2, __v_25]; let __cu = unconstrained; if let Some(result) = record.function_queries[405].get_mut(&__args[..]) { if !__cu && *result.multiplicity == G::ZERO { aiur_fn_405(__args, record, io_buffer, false)? } else { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_405] = unsafe { *(result.output.as_ptr() as *const [G; OUT_405]) }; __ret } } else { aiur_fn_405(__args, record, io_buffer, __cu)? } }; + let __r_arr: [G; OUT_401] = { let __args: [G; IN_401] = [__v_1, __v_3, __v_11, __v_13, __v_14, __v_12, __v_15, __v_4, __v_2, __v_25]; let __cu = unconstrained; if let Some(result) = record.function_queries[401].get_mut(&__args[..]) { if !__cu && *result.multiplicity == G::ZERO { aiur_fn_401(__args, record, io_buffer, false)? } else { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_401] = unsafe { *(result.output.as_ptr() as *const [G; OUT_401]) }; __ret } } else { aiur_fn_401(__args, record, io_buffer, __cu)? } }; let __v_26: G = __r_arr[0]; let __v_27: G = __r_arr[1]; match __v_26.as_canonical_u64() { 1u64 => { - let __r_arr: [G; OUT_418] = { let __args: [G; IN_418] = [__v_27, __v_4]; let __cu = unconstrained; if let Some(result) = record.function_queries[418].get_mut(&__args[..]) { if !__cu && *result.multiplicity == G::ZERO { aiur_fn_418(__args, record, io_buffer, false)? } else { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_418] = unsafe { *(result.output.as_ptr() as *const [G; OUT_418]) }; __ret } } else { aiur_fn_418(__args, record, io_buffer, __cu)? } }; + let __r_arr: [G; OUT_414] = { let __args: [G; IN_414] = [__v_27, __v_4]; let __cu = unconstrained; if let Some(result) = record.function_queries[414].get_mut(&__args[..]) { if !__cu && *result.multiplicity == G::ZERO { aiur_fn_414(__args, record, io_buffer, false)? } else { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_414] = unsafe { *(result.output.as_ptr() as *const [G; OUT_414]) }; __ret } } else { aiur_fn_414(__args, record, io_buffer, __cu)? } }; let __v_28: G = __r_arr[0]; - let __ret: [G; OUT_397] = [__v_28]; - if let Some(result) = record.function_queries[397].get_mut(&inp[..]) { debug_assert_eq!(result.output, &__ret[..]); if !unconstrained { *result.multiplicity += G::ONE; } } else { record.function_queries[397].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained)); }; + let __ret: [G; OUT_393] = [__v_28]; + if let Some(result) = record.function_queries[393].get_mut(&inp[..]) { debug_assert_eq!(result.output, &__ret[..]); if !unconstrained { *result.multiplicity += G::ONE; } } else { record.function_queries[393].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained)); }; return Ok(__ret); }, 2u64 => { match __v_16.as_canonical_u64() { 1u64 => { - let __ret: [G; OUT_397] = [__v_27]; - if let Some(result) = record.function_queries[397].get_mut(&inp[..]) { debug_assert_eq!(result.output, &__ret[..]); if !unconstrained { *result.multiplicity += G::ONE; } } else { record.function_queries[397].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained)); }; + let __ret: [G; OUT_393] = [__v_27]; + if let Some(result) = record.function_queries[393].get_mut(&inp[..]) { debug_assert_eq!(result.output, &__ret[..]); if !unconstrained { *result.multiplicity += G::ONE; } } else { record.function_queries[393].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained)); }; return Ok(__ret); }, _ => { - let __r_arr: [G; OUT_408] = { let __args: [G; IN_408] = [__v_10, __v_1, __v_3, __v_11, __v_13, __v_14, __v_12, __v_15, __v_4]; let __cu = unconstrained; if let Some(result) = record.function_queries[408].get_mut(&__args[..]) { if !__cu && *result.multiplicity == G::ZERO { aiur_fn_408(__args, record, io_buffer, false)? } else { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_408] = unsafe { *(result.output.as_ptr() as *const [G; OUT_408]) }; __ret } } else { aiur_fn_408(__args, record, io_buffer, __cu)? } }; + let __r_arr: [G; OUT_404] = { let __args: [G; IN_404] = [__v_10, __v_1, __v_3, __v_11, __v_13, __v_14, __v_12, __v_15, __v_4]; let __cu = unconstrained; if let Some(result) = record.function_queries[404].get_mut(&__args[..]) { if !__cu && *result.multiplicity == G::ZERO { aiur_fn_404(__args, record, io_buffer, false)? } else { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_404] = unsafe { *(result.output.as_ptr() as *const [G; OUT_404]) }; __ret } } else { aiur_fn_404(__args, record, io_buffer, __cu)? } }; let __v_28: G = __r_arr[0]; let __v_29: G = __r_arr[1]; match __v_28.as_canonical_u64() { 1u64 => { - let __r_arr: [G; OUT_418] = { let __args: [G; IN_418] = [__v_29, __v_4]; let __cu = unconstrained; if let Some(result) = record.function_queries[418].get_mut(&__args[..]) { if !__cu && *result.multiplicity == G::ZERO { aiur_fn_418(__args, record, io_buffer, false)? } else { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_418] = unsafe { *(result.output.as_ptr() as *const [G; OUT_418]) }; __ret } } else { aiur_fn_418(__args, record, io_buffer, __cu)? } }; + let __r_arr: [G; OUT_414] = { let __args: [G; IN_414] = [__v_29, __v_4]; let __cu = unconstrained; if let Some(result) = record.function_queries[414].get_mut(&__args[..]) { if !__cu && *result.multiplicity == G::ZERO { aiur_fn_414(__args, record, io_buffer, false)? } else { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_414] = unsafe { *(result.output.as_ptr() as *const [G; OUT_414]) }; __ret } } else { aiur_fn_414(__args, record, io_buffer, __cu)? } }; let __v_30: G = __r_arr[0]; - let __ret: [G; OUT_397] = [__v_30]; - if let Some(result) = record.function_queries[397].get_mut(&inp[..]) { debug_assert_eq!(result.output, &__ret[..]); if !unconstrained { *result.multiplicity += G::ONE; } } else { record.function_queries[397].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained)); }; + let __ret: [G; OUT_393] = [__v_30]; + if let Some(result) = record.function_queries[393].get_mut(&inp[..]) { debug_assert_eq!(result.output, &__ret[..]); if !unconstrained { *result.multiplicity += G::ONE; } } else { record.function_queries[393].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained)); }; return Ok(__ret); }, _ => { - let __ret: [G; OUT_397] = [__v_27]; - if let Some(result) = record.function_queries[397].get_mut(&inp[..]) { debug_assert_eq!(result.output, &__ret[..]); if !unconstrained { *result.multiplicity += G::ONE; } } else { record.function_queries[397].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained)); }; + let __ret: [G; OUT_393] = [__v_27]; + if let Some(result) = record.function_queries[393].get_mut(&inp[..]) { debug_assert_eq!(result.output, &__ret[..]); if !unconstrained { *result.multiplicity += G::ONE; } } else { record.function_queries[393].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained)); }; return Ok(__ret); }, } @@ -35612,10 +35338,10 @@ fn aiur_fn_397( } }, _ => { - let __r_arr: [G; OUT_255] = { let __args: [G; IN_255] = [__v_2, __v_3]; let __cu = unconstrained; if let Some(result) = record.function_queries[255].get_mut(&__args[..]) { if !__cu && *result.multiplicity == G::ZERO { aiur_fn_255(__args, record, io_buffer, false)? } else { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_255] = unsafe { *(result.output.as_ptr() as *const [G; OUT_255]) }; __ret } } else { aiur_fn_255(__args, record, io_buffer, __cu)? } }; + let __r_arr: [G; OUT_251] = { let __args: [G; IN_251] = [__v_2, __v_3]; let __cu = unconstrained; if let Some(result) = record.function_queries[251].get_mut(&__args[..]) { if !__cu && *result.multiplicity == G::ZERO { aiur_fn_251(__args, record, io_buffer, false)? } else { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_251] = unsafe { *(result.output.as_ptr() as *const [G; OUT_251]) }; __ret } } else { aiur_fn_251(__args, record, io_buffer, __cu)? } }; let __v_28: G = __r_arr[0]; - let __ret: [G; OUT_397] = [__v_28]; - if let Some(result) = record.function_queries[397].get_mut(&inp[..]) { debug_assert_eq!(result.output, &__ret[..]); if !unconstrained { *result.multiplicity += G::ONE; } } else { record.function_queries[397].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained)); }; + let __ret: [G; OUT_393] = [__v_28]; + if let Some(result) = record.function_queries[393].get_mut(&inp[..]) { debug_assert_eq!(result.output, &__ret[..]); if !unconstrained { *result.multiplicity += G::ONE; } } else { record.function_queries[393].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained)); }; return Ok(__ret); }, } @@ -35623,10 +35349,10 @@ fn aiur_fn_397( } }, _ => { - let __r_arr: [G; OUT_255] = { let __args: [G; IN_255] = [__v_2, __v_3]; let __cu = unconstrained; if let Some(result) = record.function_queries[255].get_mut(&__args[..]) { if !__cu && *result.multiplicity == G::ZERO { aiur_fn_255(__args, record, io_buffer, false)? } else { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_255] = unsafe { *(result.output.as_ptr() as *const [G; OUT_255]) }; __ret } } else { aiur_fn_255(__args, record, io_buffer, __cu)? } }; + let __r_arr: [G; OUT_251] = { let __args: [G; IN_251] = [__v_2, __v_3]; let __cu = unconstrained; if let Some(result) = record.function_queries[251].get_mut(&__args[..]) { if !__cu && *result.multiplicity == G::ZERO { aiur_fn_251(__args, record, io_buffer, false)? } else { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_251] = unsafe { *(result.output.as_ptr() as *const [G; OUT_251]) }; __ret } } else { aiur_fn_251(__args, record, io_buffer, __cu)? } }; let __v_20: G = __r_arr[0]; - let __ret: [G; OUT_397] = [__v_20]; - if let Some(result) = record.function_queries[397].get_mut(&inp[..]) { debug_assert_eq!(result.output, &__ret[..]); if !unconstrained { *result.multiplicity += G::ONE; } } else { record.function_queries[397].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained)); }; + let __ret: [G; OUT_393] = [__v_20]; + if let Some(result) = record.function_queries[393].get_mut(&inp[..]) { debug_assert_eq!(result.output, &__ret[..]); if !unconstrained { *result.multiplicity += G::ONE; } } else { record.function_queries[393].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained)); }; return Ok(__ret); }, } @@ -35635,20 +35361,20 @@ fn aiur_fn_397( }) } -const INPUT_SIZE_398: usize = 2; -const IN_398: usize = 2; -const OUT_398: usize = 2; -fn aiur_fn_398( - inp: [G; IN_398], +const INPUT_SIZE_394: usize = 2; +const IN_394: usize = 2; +const OUT_394: usize = 2; +fn aiur_fn_394( + inp: [G; IN_394], record: &mut QueryRecord, io_buffer: &mut IOBuffer, unconstrained: bool, -) -> Result<[G; OUT_398], ExecError> { +) -> Result<[G; OUT_394], ExecError> { stacker::maybe_grow(64 * 1024, 4 * 1024 * 1024, || { let __v_0: G = inp[0]; let __v_1: G = inp[1]; let __v_2: G = G::from_u64(0); - let __r_arr: [G; OUT_399] = { let __args: [G; IN_399] = [__v_0, __v_2]; let __cu = unconstrained; if let Some(result) = record.function_queries[399].get_mut(&__args[..]) { if !__cu && *result.multiplicity == G::ZERO { aiur_fn_399(__args, record, io_buffer, false)? } else { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_399] = unsafe { *(result.output.as_ptr() as *const [G; OUT_399]) }; __ret } } else { aiur_fn_399(__args, record, io_buffer, __cu)? } }; + let __r_arr: [G; OUT_395] = { let __args: [G; IN_395] = [__v_0, __v_2]; let __cu = unconstrained; if let Some(result) = record.function_queries[395].get_mut(&__args[..]) { if !__cu && *result.multiplicity == G::ZERO { aiur_fn_395(__args, record, io_buffer, false)? } else { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_395] = unsafe { *(result.output.as_ptr() as *const [G; OUT_395]) }; __ret } } else { aiur_fn_395(__args, record, io_buffer, __cu)? } }; let __v_3: G = __r_arr[0]; let __v_4: G = __r_arr[1]; let __v_5: G = __r_arr[2]; @@ -35656,7 +35382,7 @@ fn aiur_fn_398( let __v_7: G = __r_arr[4]; match __v_3.as_canonical_u64() { 1u64 => { - let __r_arr: [G; OUT_764] = { let __args: [G; IN_764] = [__v_1]; let __cu = unconstrained; if let Some(result) = record.function_queries[764].get_mut(&__args[..]) { if !__cu && *result.multiplicity == G::ZERO { aiur_fn_764(__args, record, io_buffer, false)? } else { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_764] = unsafe { *(result.output.as_ptr() as *const [G; OUT_764]) }; __ret } } else { aiur_fn_764(__args, record, io_buffer, __cu)? } }; + let __r_arr: [G; OUT_760] = { let __args: [G; IN_760] = [__v_1]; let __cu = unconstrained; if let Some(result) = record.function_queries[760].get_mut(&__args[..]) { if !__cu && *result.multiplicity == G::ZERO { aiur_fn_760(__args, record, io_buffer, false)? } else { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_760] = unsafe { *(result.output.as_ptr() as *const [G; OUT_760]) }; __ret } } else { aiur_fn_760(__args, record, io_buffer, __cu)? } }; let __v_8: G = __r_arr[0]; let __v_9: G = { let __a_val = __v_8.as_canonical_u64(); let __b_val = __v_4.as_canonical_u64(); let __a_u32 = u32::try_from(__a_val).ok().ok_or(ExecError::U32OutOfRange(__a_val))?; let __b_u32 = u32::try_from(__b_val).ok().ok_or(ExecError::U32OutOfRange(__b_val))?; let __result = G::from_bool(__a_u32 < __b_u32); if !unconstrained { let __x_bytes = __a_u32.to_le_bytes(); let __z_bytes = __b_u32.to_le_bytes(); let __c_u32 = __b_u32.wrapping_sub(__a_u32).wrapping_sub(1); let __y_bytes = __c_u32.to_le_bytes(); record.bytes2_queries.bump_range_check(&G::from_u8(__x_bytes[0]), &G::from_u8(__x_bytes[1])); record.bytes2_queries.bump_range_check(&G::from_u8(__x_bytes[2]), &G::from_u8(__x_bytes[3])); record.bytes2_queries.bump_range_check(&G::from_u8(__y_bytes[0]), &G::from_u8(__y_bytes[1])); record.bytes2_queries.bump_range_check(&G::from_u8(__y_bytes[2]), &G::from_u8(__y_bytes[3])); record.bytes2_queries.bump_range_check(&G::from_u8(__z_bytes[0]), &G::from_u8(__z_bytes[1])); record.bytes2_queries.bump_range_check(&G::from_u8(__z_bytes[2]), &G::from_u8(__z_bytes[3])); } __result }; match __v_9.as_canonical_u64() { @@ -35666,22 +35392,22 @@ fn aiur_fn_398( let __v_12: G = G::from_u64(0); let __v_13: G = G::from_u64(0); let __v_14: G = { let __values: [G; 4] = [__v_11, __v_12, __v_13, __v_13]; let __mq = record.memory_queries.get_mut(&4).ok_or(ExecError::InvalidMemorySize(4))?; if let Some(result) = __mq.get_mut(&__values[..]) { if !unconstrained { *result.multiplicity += G::ONE; } result.output[0] } else { let __ptr = G::from_usize(__mq.len()); __mq.insert(&__values[..], &[__ptr], G::from_bool(!unconstrained)); __ptr } }; - let __ret: [G; OUT_398] = [__v_10, __v_14]; - if let Some(result) = record.function_queries[398].get_mut(&inp[..]) { debug_assert_eq!(result.output, &__ret[..]); if !unconstrained { *result.multiplicity += G::ONE; } } else { record.function_queries[398].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained)); }; + let __ret: [G; OUT_394] = [__v_10, __v_14]; + if let Some(result) = record.function_queries[394].get_mut(&inp[..]) { debug_assert_eq!(result.output, &__ret[..]); if !unconstrained { *result.multiplicity += G::ONE; } } else { record.function_queries[394].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained)); }; return Ok(__ret); }, _ => { - let __r_arr: [G; OUT_766] = { let __args: [G; IN_766] = [__v_1, __v_7]; let __cu = unconstrained; if let Some(result) = record.function_queries[766].get_mut(&__args[..]) { if !__cu && *result.multiplicity == G::ZERO { aiur_fn_766(__args, record, io_buffer, false)? } else { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_766] = unsafe { *(result.output.as_ptr() as *const [G; OUT_766]) }; __ret } } else { aiur_fn_766(__args, record, io_buffer, __cu)? } }; + let __r_arr: [G; OUT_762] = { let __args: [G; IN_762] = [__v_1, __v_7]; let __cu = unconstrained; if let Some(result) = record.function_queries[762].get_mut(&__args[..]) { if !__cu && *result.multiplicity == G::ZERO { aiur_fn_762(__args, record, io_buffer, false)? } else { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_762] = unsafe { *(result.output.as_ptr() as *const [G; OUT_762]) }; __ret } } else { aiur_fn_762(__args, record, io_buffer, __cu)? } }; let __v_10: G = __r_arr[0]; let __v_11: G = G::from_u64(8); let __v_12: G = { let __values: [G; 4] = [__v_11, __v_5, __v_6, __v_10]; let __mq = record.memory_queries.get_mut(&4).ok_or(ExecError::InvalidMemorySize(4))?; if let Some(result) = __mq.get_mut(&__values[..]) { if !unconstrained { *result.multiplicity += G::ONE; } result.output[0] } else { let __ptr = G::from_usize(__mq.len()); __mq.insert(&__values[..], &[__ptr], G::from_bool(!unconstrained)); __ptr } }; - let __r_arr: [G; OUT_775] = { let __args: [G; IN_775] = [__v_1, __v_4]; let __cu = unconstrained; if let Some(result) = record.function_queries[775].get_mut(&__args[..]) { if !__cu && *result.multiplicity == G::ZERO { aiur_fn_775(__args, record, io_buffer, false)? } else { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_775] = unsafe { *(result.output.as_ptr() as *const [G; OUT_775]) }; __ret } } else { aiur_fn_775(__args, record, io_buffer, __cu)? } }; + let __r_arr: [G; OUT_771] = { let __args: [G; IN_771] = [__v_1, __v_4]; let __cu = unconstrained; if let Some(result) = record.function_queries[771].get_mut(&__args[..]) { if !__cu && *result.multiplicity == G::ZERO { aiur_fn_771(__args, record, io_buffer, false)? } else { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_771] = unsafe { *(result.output.as_ptr() as *const [G; OUT_771]) }; __ret } } else { aiur_fn_771(__args, record, io_buffer, __cu)? } }; let __v_13: G = __r_arr[0]; let __v_14: G = G::from_u64(1); - let __r_arr: [G; OUT_255] = { let __args: [G; IN_255] = [__v_12, __v_13]; let __cu = unconstrained; if let Some(result) = record.function_queries[255].get_mut(&__args[..]) { if !__cu && *result.multiplicity == G::ZERO { aiur_fn_255(__args, record, io_buffer, false)? } else { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_255] = unsafe { *(result.output.as_ptr() as *const [G; OUT_255]) }; __ret } } else { aiur_fn_255(__args, record, io_buffer, __cu)? } }; + let __r_arr: [G; OUT_251] = { let __args: [G; IN_251] = [__v_12, __v_13]; let __cu = unconstrained; if let Some(result) = record.function_queries[251].get_mut(&__args[..]) { if !__cu && *result.multiplicity == G::ZERO { aiur_fn_251(__args, record, io_buffer, false)? } else { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_251] = unsafe { *(result.output.as_ptr() as *const [G; OUT_251]) }; __ret } } else { aiur_fn_251(__args, record, io_buffer, __cu)? } }; let __v_15: G = __r_arr[0]; - let __ret: [G; OUT_398] = [__v_14, __v_15]; - if let Some(result) = record.function_queries[398].get_mut(&inp[..]) { debug_assert_eq!(result.output, &__ret[..]); if !unconstrained { *result.multiplicity += G::ONE; } } else { record.function_queries[398].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained)); }; + let __ret: [G; OUT_394] = [__v_14, __v_15]; + if let Some(result) = record.function_queries[394].get_mut(&inp[..]) { debug_assert_eq!(result.output, &__ret[..]); if !unconstrained { *result.multiplicity += G::ONE; } } else { record.function_queries[394].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained)); }; return Ok(__ret); }, } @@ -35692,23 +35418,23 @@ fn aiur_fn_398( let __v_10: G = G::from_u64(0); let __v_11: G = G::from_u64(0); let __v_12: G = { let __values: [G; 4] = [__v_9, __v_10, __v_11, __v_11]; let __mq = record.memory_queries.get_mut(&4).ok_or(ExecError::InvalidMemorySize(4))?; if let Some(result) = __mq.get_mut(&__values[..]) { if !unconstrained { *result.multiplicity += G::ONE; } result.output[0] } else { let __ptr = G::from_usize(__mq.len()); __mq.insert(&__values[..], &[__ptr], G::from_bool(!unconstrained)); __ptr } }; - let __ret: [G; OUT_398] = [__v_8, __v_12]; - if let Some(result) = record.function_queries[398].get_mut(&inp[..]) { debug_assert_eq!(result.output, &__ret[..]); if !unconstrained { *result.multiplicity += G::ONE; } } else { record.function_queries[398].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained)); }; + let __ret: [G; OUT_394] = [__v_8, __v_12]; + if let Some(result) = record.function_queries[394].get_mut(&inp[..]) { debug_assert_eq!(result.output, &__ret[..]); if !unconstrained { *result.multiplicity += G::ONE; } } else { record.function_queries[394].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained)); }; return Ok(__ret); }, } }) } -const INPUT_SIZE_399: usize = 2; -const IN_399: usize = 2; -const OUT_399: usize = 5; -fn aiur_fn_399( - inp: [G; IN_399], +const INPUT_SIZE_395: usize = 2; +const IN_395: usize = 2; +const OUT_395: usize = 5; +fn aiur_fn_395( + inp: [G; IN_395], record: &mut QueryRecord, io_buffer: &mut IOBuffer, unconstrained: bool, -) -> Result<[G; OUT_399], ExecError> { +) -> Result<[G; OUT_395], ExecError> { stacker::maybe_grow(64 * 1024, 4 * 1024 * 1024, || { let __v_0: G = inp[0]; let __v_1: G = inp[1]; @@ -35721,14 +35447,14 @@ fn aiur_fn_399( 4u64 => { let __v_6: G = G::from_u64(1); let __v_7: G = (__v_1 + __v_6); - let __r_arr: [G; OUT_399] = { let __args: [G; IN_399] = [__v_4, __v_7]; let __cu = unconstrained; if let Some(result) = record.function_queries[399].get_mut(&__args[..]) { if !__cu && *result.multiplicity == G::ZERO { aiur_fn_399(__args, record, io_buffer, false)? } else { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_399] = unsafe { *(result.output.as_ptr() as *const [G; OUT_399]) }; __ret } } else { aiur_fn_399(__args, record, io_buffer, __cu)? } }; + let __r_arr: [G; OUT_395] = { let __args: [G; IN_395] = [__v_4, __v_7]; let __cu = unconstrained; if let Some(result) = record.function_queries[395].get_mut(&__args[..]) { if !__cu && *result.multiplicity == G::ZERO { aiur_fn_395(__args, record, io_buffer, false)? } else { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_395] = unsafe { *(result.output.as_ptr() as *const [G; OUT_395]) }; __ret } } else { aiur_fn_395(__args, record, io_buffer, __cu)? } }; let __v_8: G = __r_arr[0]; let __v_9: G = __r_arr[1]; let __v_10: G = __r_arr[2]; let __v_11: G = __r_arr[3]; let __v_12: G = __r_arr[4]; - let __ret: [G; OUT_399] = [__v_8, __v_9, __v_10, __v_11, __v_12]; - if let Some(result) = record.function_queries[399].get_mut(&inp[..]) { debug_assert_eq!(result.output, &__ret[..]); if !unconstrained { *result.multiplicity += G::ONE; } } else { record.function_queries[399].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained)); }; + let __ret: [G; OUT_395] = [__v_8, __v_9, __v_10, __v_11, __v_12]; + if let Some(result) = record.function_queries[395].get_mut(&inp[..]) { debug_assert_eq!(result.output, &__ret[..]); if !unconstrained { *result.multiplicity += G::ONE; } } else { record.function_queries[395].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained)); }; return Ok(__ret); }, 8u64 => { @@ -35746,8 +35472,8 @@ fn aiur_fn_399( let __v_12: G = G::from_u64(1); let __v_13: G = (__v_1 - __v_12); let __v_14: G = (__v_13 - __v_7); - let __ret: [G; OUT_399] = [__v_11, __v_1, __v_3, __v_4, __v_14]; - if let Some(result) = record.function_queries[399].get_mut(&inp[..]) { debug_assert_eq!(result.output, &__ret[..]); if !unconstrained { *result.multiplicity += G::ONE; } } else { record.function_queries[399].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained)); }; + let __ret: [G; OUT_395] = [__v_11, __v_1, __v_3, __v_4, __v_14]; + if let Some(result) = record.function_queries[395].get_mut(&inp[..]) { debug_assert_eq!(result.output, &__ret[..]); if !unconstrained { *result.multiplicity += G::ONE; } } else { record.function_queries[395].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained)); }; return Ok(__ret); }, _ => { @@ -35788,8 +35514,8 @@ fn aiur_fn_399( let __v_45: G = { let __values: [G; 32] = [__v_13, __v_14, __v_15, __v_16, __v_17, __v_18, __v_19, __v_20, __v_21, __v_22, __v_23, __v_24, __v_25, __v_26, __v_27, __v_28, __v_29, __v_30, __v_31, __v_32, __v_33, __v_34, __v_35, __v_36, __v_37, __v_38, __v_39, __v_40, __v_41, __v_42, __v_43, __v_44]; let __mq = record.memory_queries.get_mut(&32).ok_or(ExecError::InvalidMemorySize(32))?; if let Some(result) = __mq.get_mut(&__values[..]) { if !unconstrained { *result.multiplicity += G::ONE; } result.output[0] } else { let __ptr = G::from_usize(__mq.len()); __mq.insert(&__values[..], &[__ptr], G::from_bool(!unconstrained)); __ptr } }; let __v_46: G = G::from_u64(0); let __v_47: G = G::from_u64(0); - let __ret: [G; OUT_399] = [__v_11, __v_12, __v_45, __v_46, __v_47]; - if let Some(result) = record.function_queries[399].get_mut(&inp[..]) { debug_assert_eq!(result.output, &__ret[..]); if !unconstrained { *result.multiplicity += G::ONE; } } else { record.function_queries[399].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained)); }; + let __ret: [G; OUT_395] = [__v_11, __v_12, __v_45, __v_46, __v_47]; + if let Some(result) = record.function_queries[395].get_mut(&inp[..]) { debug_assert_eq!(result.output, &__ret[..]); if !unconstrained { *result.multiplicity += G::ONE; } } else { record.function_queries[395].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained)); }; return Ok(__ret); }, } @@ -35832,8 +35558,8 @@ fn aiur_fn_399( let __v_44: G = { let __values: [G; 32] = [__v_12, __v_13, __v_14, __v_15, __v_16, __v_17, __v_18, __v_19, __v_20, __v_21, __v_22, __v_23, __v_24, __v_25, __v_26, __v_27, __v_28, __v_29, __v_30, __v_31, __v_32, __v_33, __v_34, __v_35, __v_36, __v_37, __v_38, __v_39, __v_40, __v_41, __v_42, __v_43]; let __mq = record.memory_queries.get_mut(&32).ok_or(ExecError::InvalidMemorySize(32))?; if let Some(result) = __mq.get_mut(&__values[..]) { if !unconstrained { *result.multiplicity += G::ONE; } result.output[0] } else { let __ptr = G::from_usize(__mq.len()); __mq.insert(&__values[..], &[__ptr], G::from_bool(!unconstrained)); __ptr } }; let __v_45: G = G::from_u64(0); let __v_46: G = G::from_u64(0); - let __ret: [G; OUT_399] = [__v_10, __v_11, __v_44, __v_45, __v_46]; - if let Some(result) = record.function_queries[399].get_mut(&inp[..]) { debug_assert_eq!(result.output, &__ret[..]); if !unconstrained { *result.multiplicity += G::ONE; } } else { record.function_queries[399].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained)); }; + let __ret: [G; OUT_395] = [__v_10, __v_11, __v_44, __v_45, __v_46]; + if let Some(result) = record.function_queries[395].get_mut(&inp[..]) { debug_assert_eq!(result.output, &__ret[..]); if !unconstrained { *result.multiplicity += G::ONE; } } else { record.function_queries[395].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained)); }; return Ok(__ret); }, } @@ -35876,23 +35602,23 @@ fn aiur_fn_399( let __v_40: G = { let __values: [G; 32] = [__v_8, __v_9, __v_10, __v_11, __v_12, __v_13, __v_14, __v_15, __v_16, __v_17, __v_18, __v_19, __v_20, __v_21, __v_22, __v_23, __v_24, __v_25, __v_26, __v_27, __v_28, __v_29, __v_30, __v_31, __v_32, __v_33, __v_34, __v_35, __v_36, __v_37, __v_38, __v_39]; let __mq = record.memory_queries.get_mut(&32).ok_or(ExecError::InvalidMemorySize(32))?; if let Some(result) = __mq.get_mut(&__values[..]) { if !unconstrained { *result.multiplicity += G::ONE; } result.output[0] } else { let __ptr = G::from_usize(__mq.len()); __mq.insert(&__values[..], &[__ptr], G::from_bool(!unconstrained)); __ptr } }; let __v_41: G = G::from_u64(0); let __v_42: G = G::from_u64(0); - let __ret: [G; OUT_399] = [__v_6, __v_7, __v_40, __v_41, __v_42]; - if let Some(result) = record.function_queries[399].get_mut(&inp[..]) { debug_assert_eq!(result.output, &__ret[..]); if !unconstrained { *result.multiplicity += G::ONE; } } else { record.function_queries[399].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained)); }; + let __ret: [G; OUT_395] = [__v_6, __v_7, __v_40, __v_41, __v_42]; + if let Some(result) = record.function_queries[395].get_mut(&inp[..]) { debug_assert_eq!(result.output, &__ret[..]); if !unconstrained { *result.multiplicity += G::ONE; } } else { record.function_queries[395].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained)); }; return Ok(__ret); }, } }) } -const INPUT_SIZE_400: usize = 1; -const IN_400: usize = 1; -const OUT_400: usize = 1; -fn aiur_fn_400( - inp: [G; IN_400], +const INPUT_SIZE_396: usize = 1; +const IN_396: usize = 1; +const OUT_396: usize = 1; +fn aiur_fn_396( + inp: [G; IN_396], record: &mut QueryRecord, io_buffer: &mut IOBuffer, unconstrained: bool, -) -> Result<[G; OUT_400], ExecError> { +) -> Result<[G; OUT_396], ExecError> { stacker::maybe_grow(64 * 1024, 4 * 1024 * 1024, || { let __v_0: G = inp[0]; let __loaded: [G; 4] = { let __mq = record.memory_queries.get_mut(&4).ok_or(ExecError::InvalidMemorySize(4))?; let __ptr_u64 = __v_0.as_canonical_u64(); let __ptr_usize = usize::try_from(__ptr_u64).ok().ok_or(ExecError::PointerTooLarge(__ptr_u64))?; let (__args, __mult) = __mq.get_index_mut(__ptr_usize).ok_or(ExecError::UnboundPointer { ptr: __ptr_u64, size: 4 })?; if !unconstrained { *__mult += G::ONE; } let __arr: [G; 4] = __args[..4].try_into().unwrap(); __arr }; @@ -35916,8 +35642,8 @@ fn aiur_fn_400( let __v_10: G = { let __values: [G; 3] = [__v_8, __v_9, __v_9]; let __mq = record.memory_queries.get_mut(&3).ok_or(ExecError::InvalidMemorySize(3))?; if let Some(result) = __mq.get_mut(&__values[..]) { if !unconstrained { *result.multiplicity += G::ONE; } result.output[0] } else { let __ptr = G::from_usize(__mq.len()); __mq.insert(&__values[..], &[__ptr], G::from_bool(!unconstrained)); __ptr } }; let __v_11: G = G::from_u64(0); let __v_12: G = { let __values: [G; 4] = [__v_6, __v_7, __v_10, __v_11]; let __mq = record.memory_queries.get_mut(&4).ok_or(ExecError::InvalidMemorySize(4))?; if let Some(result) = __mq.get_mut(&__values[..]) { if !unconstrained { *result.multiplicity += G::ONE; } result.output[0] } else { let __ptr = G::from_usize(__mq.len()); __mq.insert(&__values[..], &[__ptr], G::from_bool(!unconstrained)); __ptr } }; - let __ret: [G; OUT_400] = [__v_12]; - if let Some(result) = record.function_queries[400].get_mut(&inp[..]) { debug_assert_eq!(result.output, &__ret[..]); if !unconstrained { *result.multiplicity += G::ONE; } } else { record.function_queries[400].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained)); }; + let __ret: [G; OUT_396] = [__v_12]; + if let Some(result) = record.function_queries[396].get_mut(&inp[..]) { debug_assert_eq!(result.output, &__ret[..]); if !unconstrained { *result.multiplicity += G::ONE; } } else { record.function_queries[396].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained)); }; return Ok(__ret); }, _ => { @@ -35940,37 +35666,37 @@ fn aiur_fn_400( let __v_19: G = G::from_u64(3); let __v_20: G = G::from_u64(0); let __v_21: G = { let __values: [G; 4] = [__v_19, __v_18, __v_11, __v_20]; let __mq = record.memory_queries.get_mut(&4).ok_or(ExecError::InvalidMemorySize(4))?; if let Some(result) = __mq.get_mut(&__values[..]) { if !unconstrained { *result.multiplicity += G::ONE; } result.output[0] } else { let __ptr = G::from_usize(__mq.len()); __mq.insert(&__values[..], &[__ptr], G::from_bool(!unconstrained)); __ptr } }; - let __ret: [G; OUT_400] = [__v_21]; - if let Some(result) = record.function_queries[400].get_mut(&inp[..]) { debug_assert_eq!(result.output, &__ret[..]); if !unconstrained { *result.multiplicity += G::ONE; } } else { record.function_queries[400].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained)); }; + let __ret: [G; OUT_396] = [__v_21]; + if let Some(result) = record.function_queries[396].get_mut(&inp[..]) { debug_assert_eq!(result.output, &__ret[..]); if !unconstrained { *result.multiplicity += G::ONE; } } else { record.function_queries[396].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained)); }; return Ok(__ret); }, } }, _ => { - let __ret: [G; OUT_400] = [__v_0]; - if let Some(result) = record.function_queries[400].get_mut(&inp[..]) { debug_assert_eq!(result.output, &__ret[..]); if !unconstrained { *result.multiplicity += G::ONE; } } else { record.function_queries[400].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained)); }; + let __ret: [G; OUT_396] = [__v_0]; + if let Some(result) = record.function_queries[396].get_mut(&inp[..]) { debug_assert_eq!(result.output, &__ret[..]); if !unconstrained { *result.multiplicity += G::ONE; } } else { record.function_queries[396].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained)); }; return Ok(__ret); }, } }, _ => { - let __ret: [G; OUT_400] = [__v_0]; - if let Some(result) = record.function_queries[400].get_mut(&inp[..]) { debug_assert_eq!(result.output, &__ret[..]); if !unconstrained { *result.multiplicity += G::ONE; } } else { record.function_queries[400].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained)); }; + let __ret: [G; OUT_396] = [__v_0]; + if let Some(result) = record.function_queries[396].get_mut(&inp[..]) { debug_assert_eq!(result.output, &__ret[..]); if !unconstrained { *result.multiplicity += G::ONE; } } else { record.function_queries[396].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained)); }; return Ok(__ret); }, } }) } -const INPUT_SIZE_401: usize = 9; -const IN_401: usize = 9; -const OUT_401: usize = 2; -fn aiur_fn_401( - inp: [G; IN_401], +const INPUT_SIZE_397: usize = 9; +const IN_397: usize = 9; +const OUT_397: usize = 2; +fn aiur_fn_397( + inp: [G; IN_397], record: &mut QueryRecord, io_buffer: &mut IOBuffer, unconstrained: bool, -) -> Result<[G; OUT_401], ExecError> { +) -> Result<[G; OUT_397], ExecError> { stacker::maybe_grow(64 * 1024, 4 * 1024 * 1024, || { let __v_0: G = inp[0]; let __v_1: G = inp[1]; @@ -35994,9 +35720,9 @@ fn aiur_fn_401( let __v_14: G = (__v_4 + __v_5); let __v_15: G = (__v_3 + __v_14); let __v_16: G = (__v_2 + __v_15); - let __r_arr: [G; OUT_764] = { let __args: [G; IN_764] = [__v_1]; let __cu = unconstrained; if let Some(result) = record.function_queries[764].get_mut(&__args[..]) { if !__cu && *result.multiplicity == G::ZERO { aiur_fn_764(__args, record, io_buffer, false)? } else { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_764] = unsafe { *(result.output.as_ptr() as *const [G; OUT_764]) }; __ret } } else { aiur_fn_764(__args, record, io_buffer, __cu)? } }; + let __r_arr: [G; OUT_760] = { let __args: [G; IN_760] = [__v_1]; let __cu = unconstrained; if let Some(result) = record.function_queries[760].get_mut(&__args[..]) { if !__cu && *result.multiplicity == G::ZERO { aiur_fn_760(__args, record, io_buffer, false)? } else { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_760] = unsafe { *(result.output.as_ptr() as *const [G; OUT_760]) }; __ret } } else { aiur_fn_760(__args, record, io_buffer, __cu)? } }; let __v_17: G = __r_arr[0]; - let __r_arr: [G; OUT_346] = { let __args: [G; IN_346] = [__v_16, __v_17]; let __cu = unconstrained; if let Some(result) = record.function_queries[346].get_mut(&__args[..]) { if !__cu && *result.multiplicity == G::ZERO { aiur_fn_346(__args, record, io_buffer, false)? } else { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_346] = unsafe { *(result.output.as_ptr() as *const [G; OUT_346]) }; __ret } } else { aiur_fn_346(__args, record, io_buffer, __cu)? } }; + let __r_arr: [G; OUT_342] = { let __args: [G; IN_342] = [__v_16, __v_17]; let __cu = unconstrained; if let Some(result) = record.function_queries[342].get_mut(&__args[..]) { if !__cu && *result.multiplicity == G::ZERO { aiur_fn_342(__args, record, io_buffer, false)? } else { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_342] = unsafe { *(result.output.as_ptr() as *const [G; OUT_342]) }; __ret } } else { aiur_fn_342(__args, record, io_buffer, __cu)? } }; let __v_18: G = __r_arr[0]; match __v_18.as_canonical_u64() { 0u64 => { @@ -36005,14 +35731,14 @@ fn aiur_fn_401( let __v_21: G = G::from_u64(0); let __v_22: G = G::from_u64(0); let __v_23: G = { let __values: [G; 4] = [__v_20, __v_21, __v_22, __v_22]; let __mq = record.memory_queries.get_mut(&4).ok_or(ExecError::InvalidMemorySize(4))?; if let Some(result) = __mq.get_mut(&__values[..]) { if !unconstrained { *result.multiplicity += G::ONE; } result.output[0] } else { let __ptr = G::from_usize(__mq.len()); __mq.insert(&__values[..], &[__ptr], G::from_bool(!unconstrained)); __ptr } }; - let __ret: [G; OUT_401] = [__v_19, __v_23]; - if let Some(result) = record.function_queries[401].get_mut(&inp[..]) { debug_assert_eq!(result.output, &__ret[..]); if !unconstrained { *result.multiplicity += G::ONE; } } else { record.function_queries[401].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained)); }; + let __ret: [G; OUT_397] = [__v_19, __v_23]; + if let Some(result) = record.function_queries[397].get_mut(&inp[..]) { debug_assert_eq!(result.output, &__ret[..]); if !unconstrained { *result.multiplicity += G::ONE; } } else { record.function_queries[397].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained)); }; return Ok(__ret); }, _ => { - let __r_arr: [G; OUT_766] = { let __args: [G; IN_766] = [__v_1, __v_16]; let __cu = unconstrained; if let Some(result) = record.function_queries[766].get_mut(&__args[..]) { if !__cu && *result.multiplicity == G::ZERO { aiur_fn_766(__args, record, io_buffer, false)? } else { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_766] = unsafe { *(result.output.as_ptr() as *const [G; OUT_766]) }; __ret } } else { aiur_fn_766(__args, record, io_buffer, __cu)? } }; + let __r_arr: [G; OUT_762] = { let __args: [G; IN_762] = [__v_1, __v_16]; let __cu = unconstrained; if let Some(result) = record.function_queries[762].get_mut(&__args[..]) { if !__cu && *result.multiplicity == G::ZERO { aiur_fn_762(__args, record, io_buffer, false)? } else { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_762] = unsafe { *(result.output.as_ptr() as *const [G; OUT_762]) }; __ret } } else { aiur_fn_762(__args, record, io_buffer, __cu)? } }; let __v_19: G = __r_arr[0]; - let __r_arr: [G; OUT_402] = { let __args: [G; IN_402] = [__v_19, __v_10, __v_2, __v_7, __v_8]; let __cu = unconstrained; if let Some(result) = record.function_queries[402].get_mut(&__args[..]) { if !__cu && *result.multiplicity == G::ZERO { aiur_fn_402(__args, record, io_buffer, false)? } else { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_402] = unsafe { *(result.output.as_ptr() as *const [G; OUT_402]) }; __ret } } else { aiur_fn_402(__args, record, io_buffer, __cu)? } }; + let __r_arr: [G; OUT_398] = { let __args: [G; IN_398] = [__v_19, __v_10, __v_2, __v_7, __v_8]; let __cu = unconstrained; if let Some(result) = record.function_queries[398].get_mut(&__args[..]) { if !__cu && *result.multiplicity == G::ZERO { aiur_fn_398(__args, record, io_buffer, false)? } else { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_398] = unsafe { *(result.output.as_ptr() as *const [G; OUT_398]) }; __ret } } else { aiur_fn_398(__args, record, io_buffer, __cu)? } }; let __v_20: G = __r_arr[0]; match __v_20.as_canonical_u64() { 0u64 => { @@ -36021,30 +35747,30 @@ fn aiur_fn_401( let __v_23: G = G::from_u64(0); let __v_24: G = G::from_u64(0); let __v_25: G = { let __values: [G; 4] = [__v_22, __v_23, __v_24, __v_24]; let __mq = record.memory_queries.get_mut(&4).ok_or(ExecError::InvalidMemorySize(4))?; if let Some(result) = __mq.get_mut(&__values[..]) { if !unconstrained { *result.multiplicity += G::ONE; } result.output[0] } else { let __ptr = G::from_usize(__mq.len()); __mq.insert(&__values[..], &[__ptr], G::from_bool(!unconstrained)); __ptr } }; - let __ret: [G; OUT_401] = [__v_21, __v_25]; - if let Some(result) = record.function_queries[401].get_mut(&inp[..]) { debug_assert_eq!(result.output, &__ret[..]); if !unconstrained { *result.multiplicity += G::ONE; } } else { record.function_queries[401].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained)); }; + let __ret: [G; OUT_397] = [__v_21, __v_25]; + if let Some(result) = record.function_queries[397].get_mut(&inp[..]) { debug_assert_eq!(result.output, &__ret[..]); if !unconstrained { *result.multiplicity += G::ONE; } } else { record.function_queries[397].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained)); }; return Ok(__ret); }, _ => { - let __r_arr: [G; OUT_336] = { let __args: [G; IN_336] = [__v_12, __v_0]; let __cu = unconstrained; if let Some(result) = record.function_queries[336].get_mut(&__args[..]) { if !__cu && *result.multiplicity == G::ZERO { aiur_fn_336(__args, record, io_buffer, false)? } else { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_336] = unsafe { *(result.output.as_ptr() as *const [G; OUT_336]) }; __ret } } else { aiur_fn_336(__args, record, io_buffer, __cu)? } }; + let __r_arr: [G; OUT_332] = { let __args: [G; IN_332] = [__v_12, __v_0]; let __cu = unconstrained; if let Some(result) = record.function_queries[332].get_mut(&__args[..]) { if !__cu && *result.multiplicity == G::ZERO { aiur_fn_332(__args, record, io_buffer, false)? } else { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_332] = unsafe { *(result.output.as_ptr() as *const [G; OUT_332]) }; __ret } } else { aiur_fn_332(__args, record, io_buffer, __cu)? } }; let __v_21: G = __r_arr[0]; let __v_22: G = (__v_3 + __v_4); let __v_23: G = (__v_2 + __v_22); - let __r_arr: [G; OUT_774] = { let __args: [G; IN_774] = [__v_1, __v_23]; let __cu = unconstrained; if let Some(result) = record.function_queries[774].get_mut(&__args[..]) { if !__cu && *result.multiplicity == G::ZERO { aiur_fn_774(__args, record, io_buffer, false)? } else { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_774] = unsafe { *(result.output.as_ptr() as *const [G; OUT_774]) }; __ret } } else { aiur_fn_774(__args, record, io_buffer, __cu)? } }; + let __r_arr: [G; OUT_770] = { let __args: [G; IN_770] = [__v_1, __v_23]; let __cu = unconstrained; if let Some(result) = record.function_queries[770].get_mut(&__args[..]) { if !__cu && *result.multiplicity == G::ZERO { aiur_fn_770(__args, record, io_buffer, false)? } else { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_770] = unsafe { *(result.output.as_ptr() as *const [G; OUT_770]) }; __ret } } else { aiur_fn_770(__args, record, io_buffer, __cu)? } }; let __v_24: G = __r_arr[0]; let __v_25: G = G::from_u64(1); let __v_26: G = (__v_16 + __v_25); - let __r_arr: [G; OUT_775] = { let __args: [G; IN_775] = [__v_1, __v_26]; let __cu = unconstrained; if let Some(result) = record.function_queries[775].get_mut(&__args[..]) { if !__cu && *result.multiplicity == G::ZERO { aiur_fn_775(__args, record, io_buffer, false)? } else { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_775] = unsafe { *(result.output.as_ptr() as *const [G; OUT_775]) }; __ret } } else { aiur_fn_775(__args, record, io_buffer, __cu)? } }; + let __r_arr: [G; OUT_771] = { let __args: [G; IN_771] = [__v_1, __v_26]; let __cu = unconstrained; if let Some(result) = record.function_queries[771].get_mut(&__args[..]) { if !__cu && *result.multiplicity == G::ZERO { aiur_fn_771(__args, record, io_buffer, false)? } else { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_771] = unsafe { *(result.output.as_ptr() as *const [G; OUT_771]) }; __ret } } else { aiur_fn_771(__args, record, io_buffer, __cu)? } }; let __v_27: G = __r_arr[0]; - let __r_arr: [G; OUT_255] = { let __args: [G; IN_255] = [__v_21, __v_24]; let __cu = unconstrained; if let Some(result) = record.function_queries[255].get_mut(&__args[..]) { if !__cu && *result.multiplicity == G::ZERO { aiur_fn_255(__args, record, io_buffer, false)? } else { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_255] = unsafe { *(result.output.as_ptr() as *const [G; OUT_255]) }; __ret } } else { aiur_fn_255(__args, record, io_buffer, __cu)? } }; + let __r_arr: [G; OUT_251] = { let __args: [G; IN_251] = [__v_21, __v_24]; let __cu = unconstrained; if let Some(result) = record.function_queries[251].get_mut(&__args[..]) { if !__cu && *result.multiplicity == G::ZERO { aiur_fn_251(__args, record, io_buffer, false)? } else { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_251] = unsafe { *(result.output.as_ptr() as *const [G; OUT_251]) }; __ret } } else { aiur_fn_251(__args, record, io_buffer, __cu)? } }; let __v_28: G = __r_arr[0]; - let __r_arr: [G; OUT_255] = { let __args: [G; IN_255] = [__v_28, __v_27]; let __cu = unconstrained; if let Some(result) = record.function_queries[255].get_mut(&__args[..]) { if !__cu && *result.multiplicity == G::ZERO { aiur_fn_255(__args, record, io_buffer, false)? } else { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_255] = unsafe { *(result.output.as_ptr() as *const [G; OUT_255]) }; __ret } } else { aiur_fn_255(__args, record, io_buffer, __cu)? } }; + let __r_arr: [G; OUT_251] = { let __args: [G; IN_251] = [__v_28, __v_27]; let __cu = unconstrained; if let Some(result) = record.function_queries[251].get_mut(&__args[..]) { if !__cu && *result.multiplicity == G::ZERO { aiur_fn_251(__args, record, io_buffer, false)? } else { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_251] = unsafe { *(result.output.as_ptr() as *const [G; OUT_251]) }; __ret } } else { aiur_fn_251(__args, record, io_buffer, __cu)? } }; let __v_29: G = __r_arr[0]; let __v_30: G = G::from_u64(1); - let __r_arr: [G; OUT_418] = { let __args: [G; IN_418] = [__v_29, __v_8]; let __cu = unconstrained; if let Some(result) = record.function_queries[418].get_mut(&__args[..]) { if !__cu && *result.multiplicity == G::ZERO { aiur_fn_418(__args, record, io_buffer, false)? } else { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_418] = unsafe { *(result.output.as_ptr() as *const [G; OUT_418]) }; __ret } } else { aiur_fn_418(__args, record, io_buffer, __cu)? } }; + let __r_arr: [G; OUT_414] = { let __args: [G; IN_414] = [__v_29, __v_8]; let __cu = unconstrained; if let Some(result) = record.function_queries[414].get_mut(&__args[..]) { if !__cu && *result.multiplicity == G::ZERO { aiur_fn_414(__args, record, io_buffer, false)? } else { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_414] = unsafe { *(result.output.as_ptr() as *const [G; OUT_414]) }; __ret } } else { aiur_fn_414(__args, record, io_buffer, __cu)? } }; let __v_31: G = __r_arr[0]; - let __ret: [G; OUT_401] = [__v_30, __v_31]; - if let Some(result) = record.function_queries[401].get_mut(&inp[..]) { debug_assert_eq!(result.output, &__ret[..]); if !unconstrained { *result.multiplicity += G::ONE; } } else { record.function_queries[401].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained)); }; + let __ret: [G; OUT_397] = [__v_30, __v_31]; + if let Some(result) = record.function_queries[397].get_mut(&inp[..]) { debug_assert_eq!(result.output, &__ret[..]); if !unconstrained { *result.multiplicity += G::ONE; } } else { record.function_queries[397].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained)); }; return Ok(__ret); }, } @@ -36059,32 +35785,32 @@ fn aiur_fn_401( let __v_16: G = G::from_u64(0); let __v_17: G = G::from_u64(0); let __v_18: G = { let __values: [G; 4] = [__v_15, __v_16, __v_17, __v_17]; let __mq = record.memory_queries.get_mut(&4).ok_or(ExecError::InvalidMemorySize(4))?; if let Some(result) = __mq.get_mut(&__values[..]) { if !unconstrained { *result.multiplicity += G::ONE; } result.output[0] } else { let __ptr = G::from_usize(__mq.len()); __mq.insert(&__values[..], &[__ptr], G::from_bool(!unconstrained)); __ptr } }; - let __ret: [G; OUT_401] = [__v_14, __v_18]; - if let Some(result) = record.function_queries[401].get_mut(&inp[..]) { debug_assert_eq!(result.output, &__ret[..]); if !unconstrained { *result.multiplicity += G::ONE; } } else { record.function_queries[401].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained)); }; + let __ret: [G; OUT_397] = [__v_14, __v_18]; + if let Some(result) = record.function_queries[397].get_mut(&inp[..]) { debug_assert_eq!(result.output, &__ret[..]); if !unconstrained { *result.multiplicity += G::ONE; } } else { record.function_queries[397].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained)); }; return Ok(__ret); }, } }) } -const INPUT_SIZE_402: usize = 5; -const IN_402: usize = 5; -const OUT_402: usize = 1; -fn aiur_fn_402( - inp: [G; IN_402], +const INPUT_SIZE_398: usize = 5; +const IN_398: usize = 5; +const OUT_398: usize = 1; +fn aiur_fn_398( + inp: [G; IN_398], record: &mut QueryRecord, io_buffer: &mut IOBuffer, unconstrained: bool, -) -> Result<[G; OUT_402], ExecError> { +) -> Result<[G; OUT_398], ExecError> { stacker::maybe_grow(64 * 1024, 4 * 1024 * 1024, || { let __v_0: G = inp[0]; let __v_1: G = inp[1]; let __v_2: G = inp[2]; let __v_3: G = inp[3]; let __v_4: G = inp[4]; - let __r_arr: [G; OUT_488] = { let __args: [G; IN_488] = [__v_0, __v_4]; let __cu = unconstrained; if let Some(result) = record.function_queries[488].get_mut(&__args[..]) { if !__cu && *result.multiplicity == G::ZERO { aiur_fn_488(__args, record, io_buffer, false)? } else { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_488] = unsafe { *(result.output.as_ptr() as *const [G; OUT_488]) }; __ret } } else { aiur_fn_488(__args, record, io_buffer, __cu)? } }; + let __r_arr: [G; OUT_484] = { let __args: [G; IN_484] = [__v_0, __v_4]; let __cu = unconstrained; if let Some(result) = record.function_queries[484].get_mut(&__args[..]) { if !__cu && *result.multiplicity == G::ZERO { aiur_fn_484(__args, record, io_buffer, false)? } else { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_484] = unsafe { *(result.output.as_ptr() as *const [G; OUT_484]) }; __ret } } else { aiur_fn_484(__args, record, io_buffer, __cu)? } }; let __v_5: G = __r_arr[0]; - let __r_arr: [G; OUT_418] = { let __args: [G; IN_418] = [__v_5, __v_4]; let __cu = unconstrained; if let Some(result) = record.function_queries[418].get_mut(&__args[..]) { if !__cu && *result.multiplicity == G::ZERO { aiur_fn_418(__args, record, io_buffer, false)? } else { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_418] = unsafe { *(result.output.as_ptr() as *const [G; OUT_418]) }; __ret } } else { aiur_fn_418(__args, record, io_buffer, __cu)? } }; + let __r_arr: [G; OUT_414] = { let __args: [G; IN_414] = [__v_5, __v_4]; let __cu = unconstrained; if let Some(result) = record.function_queries[414].get_mut(&__args[..]) { if !__cu && *result.multiplicity == G::ZERO { aiur_fn_414(__args, record, io_buffer, false)? } else { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_414] = unsafe { *(result.output.as_ptr() as *const [G; OUT_414]) }; __ret } } else { aiur_fn_414(__args, record, io_buffer, __cu)? } }; let __v_6: G = __r_arr[0]; let __r_arr: [G; OUT_111] = { let __args: [G; IN_111] = [__v_6]; let __cu = unconstrained; if let Some(result) = record.function_queries[111].get_mut(&__args[..]) { if !__cu && *result.multiplicity == G::ZERO { aiur_fn_111(__args, record, io_buffer, false)? } else { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_111] = unsafe { *(result.output.as_ptr() as *const [G; OUT_111]) }; __ret } } else { aiur_fn_111(__args, record, io_buffer, __cu)? } }; let __v_7: G = __r_arr[0]; @@ -36101,12 +35827,12 @@ fn aiur_fn_402( match __v_13.as_canonical_u64() { 0u64 => { let __v_14: G = G::from_u64(0); - let __ret: [G; OUT_402] = [__v_14]; - if let Some(result) = record.function_queries[402].get_mut(&inp[..]) { debug_assert_eq!(result.output, &__ret[..]); if !unconstrained { *result.multiplicity += G::ONE; } } else { record.function_queries[402].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained)); }; + let __ret: [G; OUT_398] = [__v_14]; + if let Some(result) = record.function_queries[398].get_mut(&inp[..]) { debug_assert_eq!(result.output, &__ret[..]); if !unconstrained { *result.multiplicity += G::ONE; } } else { record.function_queries[398].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained)); }; return Ok(__ret); }, _ => { - let __r_arr: [G; OUT_287] = { let __args: [G; IN_287] = [__v_10]; let __cu = unconstrained; if let Some(result) = record.function_queries[287].get_mut(&__args[..]) { if !__cu && *result.multiplicity == G::ZERO { aiur_fn_287(__args, record, io_buffer, false)? } else { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_287] = unsafe { *(result.output.as_ptr() as *const [G; OUT_287]) }; __ret } } else { aiur_fn_287(__args, record, io_buffer, __cu)? } }; + let __r_arr: [G; OUT_283] = { let __args: [G; IN_283] = [__v_10]; let __cu = unconstrained; if let Some(result) = record.function_queries[283].get_mut(&__args[..]) { if !__cu && *result.multiplicity == G::ZERO { aiur_fn_283(__args, record, io_buffer, false)? } else { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_283] = unsafe { *(result.output.as_ptr() as *const [G; OUT_283]) }; __ret } } else { aiur_fn_283(__args, record, io_buffer, __cu)? } }; let __v_14: G = __r_arr[0]; let __loaded: [G; 12] = { let __mq = record.memory_queries.get_mut(&12).ok_or(ExecError::InvalidMemorySize(12))?; let __ptr_u64 = __v_14.as_canonical_u64(); let __ptr_usize = usize::try_from(__ptr_u64).ok().ok_or(ExecError::PointerTooLarge(__ptr_u64))?; let (__args, __mult) = __mq.get_index_mut(__ptr_usize).ok_or(ExecError::UnboundPointer { ptr: __ptr_u64, size: 12 })?; if !unconstrained { *__mult += G::ONE; } let __arr: [G; 12] = __args[..12].try_into().unwrap(); __arr }; let __v_15: G = __loaded[0]; @@ -36123,27 +35849,27 @@ fn aiur_fn_402( let __v_26: G = __loaded[11]; match __v_15.as_canonical_u64() { 5u64 => { - let __r_arr: [G; OUT_555] = { let __args: [G; IN_555] = [__v_22, __v_23, __v_1]; let __cu = unconstrained; if let Some(result) = record.function_queries[555].get_mut(&__args[..]) { if !__cu && *result.multiplicity == G::ZERO { aiur_fn_555(__args, record, io_buffer, false)? } else { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_555] = unsafe { *(result.output.as_ptr() as *const [G; OUT_555]) }; __ret } } else { aiur_fn_555(__args, record, io_buffer, __cu)? } }; + let __r_arr: [G; OUT_551] = { let __args: [G; IN_551] = [__v_22, __v_23, __v_1]; let __cu = unconstrained; if let Some(result) = record.function_queries[551].get_mut(&__args[..]) { if !__cu && *result.multiplicity == G::ZERO { aiur_fn_551(__args, record, io_buffer, false)? } else { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_551] = unsafe { *(result.output.as_ptr() as *const [G; OUT_551]) }; __ret } } else { aiur_fn_551(__args, record, io_buffer, __cu)? } }; let __v_27: G = __r_arr[0]; let __v_28: G = G::from_u64(2); let __v_29: G = G::from_u64(0); let __v_30: G = { let __values: [G; 4] = [__v_28, __v_27, __v_11, __v_29]; let __mq = record.memory_queries.get_mut(&4).ok_or(ExecError::InvalidMemorySize(4))?; if let Some(result) = __mq.get_mut(&__values[..]) { if !unconstrained { *result.multiplicity += G::ONE; } result.output[0] } else { let __ptr = G::from_usize(__mq.len()); __mq.insert(&__values[..], &[__ptr], G::from_bool(!unconstrained)); __ptr } }; - let __r_arr: [G; OUT_774] = { let __args: [G; IN_774] = [__v_8, __v_2]; let __cu = unconstrained; if let Some(result) = record.function_queries[774].get_mut(&__args[..]) { if !__cu && *result.multiplicity == G::ZERO { aiur_fn_774(__args, record, io_buffer, false)? } else { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_774] = unsafe { *(result.output.as_ptr() as *const [G; OUT_774]) }; __ret } } else { aiur_fn_774(__args, record, io_buffer, __cu)? } }; + let __r_arr: [G; OUT_770] = { let __args: [G; IN_770] = [__v_8, __v_2]; let __cu = unconstrained; if let Some(result) = record.function_queries[770].get_mut(&__args[..]) { if !__cu && *result.multiplicity == G::ZERO { aiur_fn_770(__args, record, io_buffer, false)? } else { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_770] = unsafe { *(result.output.as_ptr() as *const [G; OUT_770]) }; __ret } } else { aiur_fn_770(__args, record, io_buffer, __cu)? } }; let __v_31: G = __r_arr[0]; - let __r_arr: [G; OUT_255] = { let __args: [G; IN_255] = [__v_30, __v_31]; let __cu = unconstrained; if let Some(result) = record.function_queries[255].get_mut(&__args[..]) { if !__cu && *result.multiplicity == G::ZERO { aiur_fn_255(__args, record, io_buffer, false)? } else { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_255] = unsafe { *(result.output.as_ptr() as *const [G; OUT_255]) }; __ret } } else { aiur_fn_255(__args, record, io_buffer, __cu)? } }; + let __r_arr: [G; OUT_251] = { let __args: [G; IN_251] = [__v_30, __v_31]; let __cu = unconstrained; if let Some(result) = record.function_queries[251].get_mut(&__args[..]) { if !__cu && *result.multiplicity == G::ZERO { aiur_fn_251(__args, record, io_buffer, false)? } else { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_251] = unsafe { *(result.output.as_ptr() as *const [G; OUT_251]) }; __ret } } else { aiur_fn_251(__args, record, io_buffer, __cu)? } }; let __v_32: G = __r_arr[0]; - let __r_arr: [G; OUT_488] = { let __args: [G; IN_488] = [__v_32, __v_4]; let __cu = unconstrained; if let Some(result) = record.function_queries[488].get_mut(&__args[..]) { if !__cu && *result.multiplicity == G::ZERO { aiur_fn_488(__args, record, io_buffer, false)? } else { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_488] = unsafe { *(result.output.as_ptr() as *const [G; OUT_488]) }; __ret } } else { aiur_fn_488(__args, record, io_buffer, __cu)? } }; + let __r_arr: [G; OUT_484] = { let __args: [G; IN_484] = [__v_32, __v_4]; let __cu = unconstrained; if let Some(result) = record.function_queries[484].get_mut(&__args[..]) { if !__cu && *result.multiplicity == G::ZERO { aiur_fn_484(__args, record, io_buffer, false)? } else { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_484] = unsafe { *(result.output.as_ptr() as *const [G; OUT_484]) }; __ret } } else { aiur_fn_484(__args, record, io_buffer, __cu)? } }; let __v_33: G = __r_arr[0]; - let __r_arr: [G; OUT_439] = { let __args: [G; IN_439] = [__v_6, __v_33, __v_4]; let __cu = unconstrained; if let Some(result) = record.function_queries[439].get_mut(&__args[..]) { if !__cu && *result.multiplicity == G::ZERO { aiur_fn_439(__args, record, io_buffer, false)? } else { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_439] = unsafe { *(result.output.as_ptr() as *const [G; OUT_439]) }; __ret } } else { aiur_fn_439(__args, record, io_buffer, __cu)? } }; + let __r_arr: [G; OUT_435] = { let __args: [G; IN_435] = [__v_6, __v_33, __v_4]; let __cu = unconstrained; if let Some(result) = record.function_queries[435].get_mut(&__args[..]) { if !__cu && *result.multiplicity == G::ZERO { aiur_fn_435(__args, record, io_buffer, false)? } else { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_435] = unsafe { *(result.output.as_ptr() as *const [G; OUT_435]) }; __ret } } else { aiur_fn_435(__args, record, io_buffer, __cu)? } }; let __v_34: G = __r_arr[0]; - let __ret: [G; OUT_402] = [__v_34]; - if let Some(result) = record.function_queries[402].get_mut(&inp[..]) { debug_assert_eq!(result.output, &__ret[..]); if !unconstrained { *result.multiplicity += G::ONE; } } else { record.function_queries[402].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained)); }; + let __ret: [G; OUT_398] = [__v_34]; + if let Some(result) = record.function_queries[398].get_mut(&inp[..]) { debug_assert_eq!(result.output, &__ret[..]); if !unconstrained { *result.multiplicity += G::ONE; } } else { record.function_queries[398].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained)); }; return Ok(__ret); }, _ => { let __v_27: G = G::from_u64(0); - let __ret: [G; OUT_402] = [__v_27]; - if let Some(result) = record.function_queries[402].get_mut(&inp[..]) { debug_assert_eq!(result.output, &__ret[..]); if !unconstrained { *result.multiplicity += G::ONE; } } else { record.function_queries[402].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained)); }; + let __ret: [G; OUT_398] = [__v_27]; + if let Some(result) = record.function_queries[398].get_mut(&inp[..]) { debug_assert_eq!(result.output, &__ret[..]); if !unconstrained { *result.multiplicity += G::ONE; } } else { record.function_queries[398].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained)); }; return Ok(__ret); }, } @@ -36152,61 +35878,61 @@ fn aiur_fn_402( }, _ => { let __v_13: G = G::from_u64(0); - let __ret: [G; OUT_402] = [__v_13]; - if let Some(result) = record.function_queries[402].get_mut(&inp[..]) { debug_assert_eq!(result.output, &__ret[..]); if !unconstrained { *result.multiplicity += G::ONE; } } else { record.function_queries[402].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained)); }; + let __ret: [G; OUT_398] = [__v_13]; + if let Some(result) = record.function_queries[398].get_mut(&inp[..]) { debug_assert_eq!(result.output, &__ret[..]); if !unconstrained { *result.multiplicity += G::ONE; } } else { record.function_queries[398].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained)); }; return Ok(__ret); }, } }) } -const INPUT_SIZE_403: usize = 3; -const IN_403: usize = 3; -const OUT_403: usize = 1; -fn aiur_fn_403( - inp: [G; IN_403], +const INPUT_SIZE_399: usize = 3; +const IN_399: usize = 3; +const OUT_399: usize = 1; +fn aiur_fn_399( + inp: [G; IN_399], record: &mut QueryRecord, io_buffer: &mut IOBuffer, unconstrained: bool, -) -> Result<[G; OUT_403], ExecError> { +) -> Result<[G; OUT_399], ExecError> { stacker::maybe_grow(64 * 1024, 4 * 1024 * 1024, || { let __v_0: G = inp[0]; let __v_1: G = inp[1]; let __v_2: G = inp[2]; - let __r_arr: [G; OUT_774] = { let __args: [G; IN_774] = [__v_0, __v_1]; let __cu = unconstrained; if let Some(result) = record.function_queries[774].get_mut(&__args[..]) { if !__cu && *result.multiplicity == G::ZERO { aiur_fn_774(__args, record, io_buffer, false)? } else { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_774] = unsafe { *(result.output.as_ptr() as *const [G; OUT_774]) }; __ret } } else { aiur_fn_774(__args, record, io_buffer, __cu)? } }; + let __r_arr: [G; OUT_770] = { let __args: [G; IN_770] = [__v_0, __v_1]; let __cu = unconstrained; if let Some(result) = record.function_queries[770].get_mut(&__args[..]) { if !__cu && *result.multiplicity == G::ZERO { aiur_fn_770(__args, record, io_buffer, false)? } else { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_770] = unsafe { *(result.output.as_ptr() as *const [G; OUT_770]) }; __ret } } else { aiur_fn_770(__args, record, io_buffer, __cu)? } }; let __v_3: G = __r_arr[0]; let __v_4: G = G::from_u64(1); let __v_5: G = (__v_1 + __v_4); - let __r_arr: [G; OUT_775] = { let __args: [G; IN_775] = [__v_0, __v_5]; let __cu = unconstrained; if let Some(result) = record.function_queries[775].get_mut(&__args[..]) { if !__cu && *result.multiplicity == G::ZERO { aiur_fn_775(__args, record, io_buffer, false)? } else { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_775] = unsafe { *(result.output.as_ptr() as *const [G; OUT_775]) }; __ret } } else { aiur_fn_775(__args, record, io_buffer, __cu)? } }; + let __r_arr: [G; OUT_771] = { let __args: [G; IN_771] = [__v_0, __v_5]; let __cu = unconstrained; if let Some(result) = record.function_queries[771].get_mut(&__args[..]) { if !__cu && *result.multiplicity == G::ZERO { aiur_fn_771(__args, record, io_buffer, false)? } else { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_771] = unsafe { *(result.output.as_ptr() as *const [G; OUT_771]) }; __ret } } else { aiur_fn_771(__args, record, io_buffer, __cu)? } }; let __v_6: G = __r_arr[0]; let __v_7: G = G::from_u64(0); let __v_8: G = G::from_u64(1); let __v_9: G = G::from_u64(1); let __v_10: G = { let __values: [G; 3] = [__v_8, __v_9, __v_9]; let __mq = record.memory_queries.get_mut(&3).ok_or(ExecError::InvalidMemorySize(3))?; if let Some(result) = __mq.get_mut(&__values[..]) { if !unconstrained { *result.multiplicity += G::ONE; } result.output[0] } else { let __ptr = G::from_usize(__mq.len()); __mq.insert(&__values[..], &[__ptr], G::from_bool(!unconstrained)); __ptr } }; let __v_11: G = { let __values: [G; 3] = [__v_7, __v_2, __v_10]; let __mq = record.memory_queries.get_mut(&3).ok_or(ExecError::InvalidMemorySize(3))?; if let Some(result) = __mq.get_mut(&__values[..]) { if !unconstrained { *result.multiplicity += G::ONE; } result.output[0] } else { let __ptr = G::from_usize(__mq.len()); __mq.insert(&__values[..], &[__ptr], G::from_bool(!unconstrained)); __ptr } }; - let __r_arr: [G; OUT_763] = { let __args: [G; IN_763] = [__v_3, __v_11]; let __cu = unconstrained; if let Some(result) = record.function_queries[763].get_mut(&__args[..]) { if !__cu && *result.multiplicity == G::ZERO { aiur_fn_763(__args, record, io_buffer, false)? } else { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_763] = unsafe { *(result.output.as_ptr() as *const [G; OUT_763]) }; __ret } } else { aiur_fn_763(__args, record, io_buffer, __cu)? } }; + let __r_arr: [G; OUT_759] = { let __args: [G; IN_759] = [__v_3, __v_11]; let __cu = unconstrained; if let Some(result) = record.function_queries[759].get_mut(&__args[..]) { if !__cu && *result.multiplicity == G::ZERO { aiur_fn_759(__args, record, io_buffer, false)? } else { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_759] = unsafe { *(result.output.as_ptr() as *const [G; OUT_759]) }; __ret } } else { aiur_fn_759(__args, record, io_buffer, __cu)? } }; let __v_12: G = __r_arr[0]; - let __r_arr: [G; OUT_763] = { let __args: [G; IN_763] = [__v_12, __v_6]; let __cu = unconstrained; if let Some(result) = record.function_queries[763].get_mut(&__args[..]) { if !__cu && *result.multiplicity == G::ZERO { aiur_fn_763(__args, record, io_buffer, false)? } else { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_763] = unsafe { *(result.output.as_ptr() as *const [G; OUT_763]) }; __ret } } else { aiur_fn_763(__args, record, io_buffer, __cu)? } }; + let __r_arr: [G; OUT_759] = { let __args: [G; IN_759] = [__v_12, __v_6]; let __cu = unconstrained; if let Some(result) = record.function_queries[759].get_mut(&__args[..]) { if !__cu && *result.multiplicity == G::ZERO { aiur_fn_759(__args, record, io_buffer, false)? } else { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_759] = unsafe { *(result.output.as_ptr() as *const [G; OUT_759]) }; __ret } } else { aiur_fn_759(__args, record, io_buffer, __cu)? } }; let __v_13: G = __r_arr[0]; - let __ret: [G; OUT_403] = [__v_13]; - if let Some(result) = record.function_queries[403].get_mut(&inp[..]) { debug_assert_eq!(result.output, &__ret[..]); if !unconstrained { *result.multiplicity += G::ONE; } } else { record.function_queries[403].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained)); }; + let __ret: [G; OUT_399] = [__v_13]; + if let Some(result) = record.function_queries[399].get_mut(&inp[..]) { debug_assert_eq!(result.output, &__ret[..]); if !unconstrained { *result.multiplicity += G::ONE; } } else { record.function_queries[399].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained)); }; return Ok(__ret); }) } -const INPUT_SIZE_404: usize = 2; -const IN_404: usize = 2; -const OUT_404: usize = 1; -fn aiur_fn_404( - inp: [G; IN_404], +const INPUT_SIZE_400: usize = 2; +const IN_400: usize = 2; +const OUT_400: usize = 1; +fn aiur_fn_400( + inp: [G; IN_400], record: &mut QueryRecord, io_buffer: &mut IOBuffer, unconstrained: bool, -) -> Result<[G; OUT_404], ExecError> { +) -> Result<[G; OUT_400], ExecError> { stacker::maybe_grow(64 * 1024, 4 * 1024 * 1024, || { let __v_0: G = inp[0]; let __v_1: G = inp[1]; - let __r_arr: [G; OUT_418] = { let __args: [G; IN_418] = [__v_0, __v_1]; let __cu = unconstrained; if let Some(result) = record.function_queries[418].get_mut(&__args[..]) { if !__cu && *result.multiplicity == G::ZERO { aiur_fn_418(__args, record, io_buffer, false)? } else { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_418] = unsafe { *(result.output.as_ptr() as *const [G; OUT_418]) }; __ret } } else { aiur_fn_418(__args, record, io_buffer, __cu)? } }; + let __r_arr: [G; OUT_414] = { let __args: [G; IN_414] = [__v_0, __v_1]; let __cu = unconstrained; if let Some(result) = record.function_queries[414].get_mut(&__args[..]) { if !__cu && *result.multiplicity == G::ZERO { aiur_fn_414(__args, record, io_buffer, false)? } else { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_414] = unsafe { *(result.output.as_ptr() as *const [G; OUT_414]) }; __ret } } else { aiur_fn_414(__args, record, io_buffer, __cu)? } }; let __v_2: G = __r_arr[0]; let __r_arr: [G; OUT_111] = { let __args: [G; IN_111] = [__v_2]; let __cu = unconstrained; if let Some(result) = record.function_queries[111].get_mut(&__args[..]) { if !__cu && *result.multiplicity == G::ZERO { aiur_fn_111(__args, record, io_buffer, false)? } else { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_111] = unsafe { *(result.output.as_ptr() as *const [G; OUT_111]) }; __ret } } else { aiur_fn_111(__args, record, io_buffer, __cu)? } }; let __v_3: G = __r_arr[0]; @@ -36218,7 +35944,7 @@ fn aiur_fn_404( let __v_8: G = __loaded[3]; match __v_5.as_canonical_u64() { 2u64 => { - let __r_arr: [G; OUT_287] = { let __args: [G; IN_287] = [__v_6]; let __cu = unconstrained; if let Some(result) = record.function_queries[287].get_mut(&__args[..]) { if !__cu && *result.multiplicity == G::ZERO { aiur_fn_287(__args, record, io_buffer, false)? } else { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_287] = unsafe { *(result.output.as_ptr() as *const [G; OUT_287]) }; __ret } } else { aiur_fn_287(__args, record, io_buffer, __cu)? } }; + let __r_arr: [G; OUT_283] = { let __args: [G; IN_283] = [__v_6]; let __cu = unconstrained; if let Some(result) = record.function_queries[283].get_mut(&__args[..]) { if !__cu && *result.multiplicity == G::ZERO { aiur_fn_283(__args, record, io_buffer, false)? } else { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_283] = unsafe { *(result.output.as_ptr() as *const [G; OUT_283]) }; __ret } } else { aiur_fn_283(__args, record, io_buffer, __cu)? } }; let __v_9: G = __r_arr[0]; let __loaded: [G; 12] = { let __mq = record.memory_queries.get_mut(&12).ok_or(ExecError::InvalidMemorySize(12))?; let __ptr_u64 = __v_9.as_canonical_u64(); let __ptr_usize = usize::try_from(__ptr_u64).ok().ok_or(ExecError::PointerTooLarge(__ptr_u64))?; let (__args, __mult) = __mq.get_index_mut(__ptr_usize).ok_or(ExecError::UnboundPointer { ptr: __ptr_u64, size: 12 })?; if !unconstrained { *__mult += G::ONE; } let __arr: [G; 12] = __args[..12].try_into().unwrap(); __arr }; let __v_10: G = __loaded[0]; @@ -36235,41 +35961,41 @@ fn aiur_fn_404( let __v_21: G = __loaded[11]; match __v_10.as_canonical_u64() { 2u64 => { - let __r_arr: [G; OUT_336] = { let __args: [G; IN_336] = [__v_13, __v_7]; let __cu = unconstrained; if let Some(result) = record.function_queries[336].get_mut(&__args[..]) { if !__cu && *result.multiplicity == G::ZERO { aiur_fn_336(__args, record, io_buffer, false)? } else { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_336] = unsafe { *(result.output.as_ptr() as *const [G; OUT_336]) }; __ret } } else { aiur_fn_336(__args, record, io_buffer, __cu)? } }; + let __r_arr: [G; OUT_332] = { let __args: [G; IN_332] = [__v_13, __v_7]; let __cu = unconstrained; if let Some(result) = record.function_queries[332].get_mut(&__args[..]) { if !__cu && *result.multiplicity == G::ZERO { aiur_fn_332(__args, record, io_buffer, false)? } else { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_332] = unsafe { *(result.output.as_ptr() as *const [G; OUT_332]) }; __ret } } else { aiur_fn_332(__args, record, io_buffer, __cu)? } }; let __v_22: G = __r_arr[0]; - let __r_arr: [G; OUT_378] = { let __args: [G; IN_378] = [__v_22, __v_4, __v_1]; let __cu = unconstrained; if let Some(result) = record.function_queries[378].get_mut(&__args[..]) { if !__cu && *result.multiplicity == G::ZERO { aiur_fn_378(__args, record, io_buffer, false)? } else { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_378] = unsafe { *(result.output.as_ptr() as *const [G; OUT_378]) }; __ret } } else { aiur_fn_378(__args, record, io_buffer, __cu)? } }; + let __r_arr: [G; OUT_374] = { let __args: [G; IN_374] = [__v_22, __v_4, __v_1]; let __cu = unconstrained; if let Some(result) = record.function_queries[374].get_mut(&__args[..]) { if !__cu && *result.multiplicity == G::ZERO { aiur_fn_374(__args, record, io_buffer, false)? } else { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_374] = unsafe { *(result.output.as_ptr() as *const [G; OUT_374]) }; __ret } } else { aiur_fn_374(__args, record, io_buffer, __cu)? } }; let __v_23: G = __r_arr[0]; - let __r_arr: [G; OUT_404] = { let __args: [G; IN_404] = [__v_23, __v_1]; let __cu = unconstrained; if let Some(result) = record.function_queries[404].get_mut(&__args[..]) { if !__cu && *result.multiplicity == G::ZERO { aiur_fn_404(__args, record, io_buffer, false)? } else { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_404] = unsafe { *(result.output.as_ptr() as *const [G; OUT_404]) }; __ret } } else { aiur_fn_404(__args, record, io_buffer, __cu)? } }; + let __r_arr: [G; OUT_400] = { let __args: [G; IN_400] = [__v_23, __v_1]; let __cu = unconstrained; if let Some(result) = record.function_queries[400].get_mut(&__args[..]) { if !__cu && *result.multiplicity == G::ZERO { aiur_fn_400(__args, record, io_buffer, false)? } else { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_400] = unsafe { *(result.output.as_ptr() as *const [G; OUT_400]) }; __ret } } else { aiur_fn_400(__args, record, io_buffer, __cu)? } }; let __v_24: G = __r_arr[0]; - let __ret: [G; OUT_404] = [__v_24]; - if let Some(result) = record.function_queries[404].get_mut(&inp[..]) { debug_assert_eq!(result.output, &__ret[..]); if !unconstrained { *result.multiplicity += G::ONE; } } else { record.function_queries[404].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained)); }; + let __ret: [G; OUT_400] = [__v_24]; + if let Some(result) = record.function_queries[400].get_mut(&inp[..]) { debug_assert_eq!(result.output, &__ret[..]); if !unconstrained { *result.multiplicity += G::ONE; } } else { record.function_queries[400].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained)); }; return Ok(__ret); }, _ => { - let __ret: [G; OUT_404] = [__v_2]; - if let Some(result) = record.function_queries[404].get_mut(&inp[..]) { debug_assert_eq!(result.output, &__ret[..]); if !unconstrained { *result.multiplicity += G::ONE; } } else { record.function_queries[404].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained)); }; + let __ret: [G; OUT_400] = [__v_2]; + if let Some(result) = record.function_queries[400].get_mut(&inp[..]) { debug_assert_eq!(result.output, &__ret[..]); if !unconstrained { *result.multiplicity += G::ONE; } } else { record.function_queries[400].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained)); }; return Ok(__ret); }, } }, _ => { - let __ret: [G; OUT_404] = [__v_2]; - if let Some(result) = record.function_queries[404].get_mut(&inp[..]) { debug_assert_eq!(result.output, &__ret[..]); if !unconstrained { *result.multiplicity += G::ONE; } } else { record.function_queries[404].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained)); }; + let __ret: [G; OUT_400] = [__v_2]; + if let Some(result) = record.function_queries[400].get_mut(&inp[..]) { debug_assert_eq!(result.output, &__ret[..]); if !unconstrained { *result.multiplicity += G::ONE; } } else { record.function_queries[400].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained)); }; return Ok(__ret); }, } }) } -const INPUT_SIZE_405: usize = 10; -const IN_405: usize = 10; -const OUT_405: usize = 2; -fn aiur_fn_405( - inp: [G; IN_405], +const INPUT_SIZE_401: usize = 10; +const IN_401: usize = 10; +const OUT_401: usize = 2; +fn aiur_fn_401( + inp: [G; IN_401], record: &mut QueryRecord, io_buffer: &mut IOBuffer, unconstrained: bool, -) -> Result<[G; OUT_405], ExecError> { +) -> Result<[G; OUT_401], ExecError> { stacker::maybe_grow(64 * 1024, 4 * 1024 * 1024, || { let __v_0: G = inp[0]; let __v_1: G = inp[1]; @@ -36284,7 +36010,7 @@ fn aiur_fn_405( let __v_10: G = (__v_4 + __v_5); let __v_11: G = (__v_3 + __v_10); let __v_12: G = (__v_2 + __v_11); - let __r_arr: [G; OUT_764] = { let __args: [G; IN_764] = [__v_1]; let __cu = unconstrained; if let Some(result) = record.function_queries[764].get_mut(&__args[..]) { if !__cu && *result.multiplicity == G::ZERO { aiur_fn_764(__args, record, io_buffer, false)? } else { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_764] = unsafe { *(result.output.as_ptr() as *const [G; OUT_764]) }; __ret } } else { aiur_fn_764(__args, record, io_buffer, __cu)? } }; + let __r_arr: [G; OUT_760] = { let __args: [G; IN_760] = [__v_1]; let __cu = unconstrained; if let Some(result) = record.function_queries[760].get_mut(&__args[..]) { if !__cu && *result.multiplicity == G::ZERO { aiur_fn_760(__args, record, io_buffer, false)? } else { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_760] = unsafe { *(result.output.as_ptr() as *const [G; OUT_760]) }; __ret } } else { aiur_fn_760(__args, record, io_buffer, __cu)? } }; let __v_13: G = __r_arr[0]; let __v_14: G = { let __a_val = __v_12.as_canonical_u64(); let __b_val = __v_13.as_canonical_u64(); let __a_u32 = u32::try_from(__a_val).ok().ok_or(ExecError::U32OutOfRange(__a_val))?; let __b_u32 = u32::try_from(__b_val).ok().ok_or(ExecError::U32OutOfRange(__b_val))?; let __result = G::from_bool(__a_u32 < __b_u32); if !unconstrained { let __x_bytes = __a_u32.to_le_bytes(); let __z_bytes = __b_u32.to_le_bytes(); let __c_u32 = __b_u32.wrapping_sub(__a_u32).wrapping_sub(1); let __y_bytes = __c_u32.to_le_bytes(); record.bytes2_queries.bump_range_check(&G::from_u8(__x_bytes[0]), &G::from_u8(__x_bytes[1])); record.bytes2_queries.bump_range_check(&G::from_u8(__x_bytes[2]), &G::from_u8(__x_bytes[3])); record.bytes2_queries.bump_range_check(&G::from_u8(__y_bytes[0]), &G::from_u8(__y_bytes[1])); record.bytes2_queries.bump_range_check(&G::from_u8(__y_bytes[2]), &G::from_u8(__y_bytes[3])); record.bytes2_queries.bump_range_check(&G::from_u8(__z_bytes[0]), &G::from_u8(__z_bytes[1])); record.bytes2_queries.bump_range_check(&G::from_u8(__z_bytes[2]), &G::from_u8(__z_bytes[3])); } __result }; match __v_14.as_canonical_u64() { @@ -36294,40 +36020,40 @@ fn aiur_fn_405( let __v_17: G = G::from_u64(0); let __v_18: G = G::from_u64(0); let __v_19: G = { let __values: [G; 4] = [__v_16, __v_17, __v_18, __v_18]; let __mq = record.memory_queries.get_mut(&4).ok_or(ExecError::InvalidMemorySize(4))?; if let Some(result) = __mq.get_mut(&__values[..]) { if !unconstrained { *result.multiplicity += G::ONE; } result.output[0] } else { let __ptr = G::from_usize(__mq.len()); __mq.insert(&__values[..], &[__ptr], G::from_bool(!unconstrained)); __ptr } }; - let __ret: [G; OUT_405] = [__v_15, __v_19]; - if let Some(result) = record.function_queries[405].get_mut(&inp[..]) { debug_assert_eq!(result.output, &__ret[..]); if !unconstrained { *result.multiplicity += G::ONE; } } else { record.function_queries[405].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained)); }; + let __ret: [G; OUT_401] = [__v_15, __v_19]; + if let Some(result) = record.function_queries[401].get_mut(&inp[..]) { debug_assert_eq!(result.output, &__ret[..]); if !unconstrained { *result.multiplicity += G::ONE; } } else { record.function_queries[401].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained)); }; return Ok(__ret); }, _ => { - let __r_arr: [G; OUT_262] = { let __args: [G; IN_262] = [__v_1, __v_2, __v_3, __v_4, __v_12]; let __cu = unconstrained; if let Some(result) = record.function_queries[262].get_mut(&__args[..]) { if !__cu && *result.multiplicity == G::ZERO { aiur_fn_262(__args, record, io_buffer, false)? } else { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_262] = unsafe { *(result.output.as_ptr() as *const [G; OUT_262]) }; __ret } } else { aiur_fn_262(__args, record, io_buffer, __cu)? } }; + let __r_arr: [G; OUT_258] = { let __args: [G; IN_258] = [__v_1, __v_2, __v_3, __v_4, __v_12]; let __cu = unconstrained; if let Some(result) = record.function_queries[258].get_mut(&__args[..]) { if !__cu && *result.multiplicity == G::ZERO { aiur_fn_258(__args, record, io_buffer, false)? } else { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_258] = unsafe { *(result.output.as_ptr() as *const [G; OUT_258]) }; __ret } } else { aiur_fn_258(__args, record, io_buffer, __cu)? } }; let __v_15: G = __r_arr[0]; let __v_16: G = __r_arr[1]; match __v_15.as_canonical_u64() { 1u64 => { let __v_17: G = G::from_u64(1); - let __ret: [G; OUT_405] = [__v_17, __v_16]; - if let Some(result) = record.function_queries[405].get_mut(&inp[..]) { debug_assert_eq!(result.output, &__ret[..]); if !unconstrained { *result.multiplicity += G::ONE; } } else { record.function_queries[405].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained)); }; + let __ret: [G; OUT_401] = [__v_17, __v_16]; + if let Some(result) = record.function_queries[401].get_mut(&inp[..]) { debug_assert_eq!(result.output, &__ret[..]); if !unconstrained { *result.multiplicity += G::ONE; } } else { record.function_queries[401].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained)); }; return Ok(__ret); }, _ => { - let __r_arr: [G; OUT_766] = { let __args: [G; IN_766] = [__v_1, __v_12]; let __cu = unconstrained; if let Some(result) = record.function_queries[766].get_mut(&__args[..]) { if !__cu && *result.multiplicity == G::ZERO { aiur_fn_766(__args, record, io_buffer, false)? } else { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_766] = unsafe { *(result.output.as_ptr() as *const [G; OUT_766]) }; __ret } } else { aiur_fn_766(__args, record, io_buffer, __cu)? } }; + let __r_arr: [G; OUT_762] = { let __args: [G; IN_762] = [__v_1, __v_12]; let __cu = unconstrained; if let Some(result) = record.function_queries[762].get_mut(&__args[..]) { if !__cu && *result.multiplicity == G::ZERO { aiur_fn_762(__args, record, io_buffer, false)? } else { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_762] = unsafe { *(result.output.as_ptr() as *const [G; OUT_762]) }; __ret } } else { aiur_fn_762(__args, record, io_buffer, __cu)? } }; let __v_17: G = __r_arr[0]; - let __r_arr: [G; OUT_259] = { let __args: [G; IN_259] = [__v_17]; let __cu = unconstrained; if let Some(result) = record.function_queries[259].get_mut(&__args[..]) { if !__cu && *result.multiplicity == G::ZERO { aiur_fn_259(__args, record, io_buffer, false)? } else { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_259] = unsafe { *(result.output.as_ptr() as *const [G; OUT_259]) }; __ret } } else { aiur_fn_259(__args, record, io_buffer, __cu)? } }; + let __r_arr: [G; OUT_255] = { let __args: [G; IN_255] = [__v_17]; let __cu = unconstrained; if let Some(result) = record.function_queries[255].get_mut(&__args[..]) { if !__cu && *result.multiplicity == G::ZERO { aiur_fn_255(__args, record, io_buffer, false)? } else { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_255] = unsafe { *(result.output.as_ptr() as *const [G; OUT_255]) }; __ret } } else { aiur_fn_255(__args, record, io_buffer, __cu)? } }; let __v_18: G = __r_arr[0]; - let __r_arr: [G; OUT_404] = { let __args: [G; IN_404] = [__v_18, __v_7]; let __cu = unconstrained; if let Some(result) = record.function_queries[404].get_mut(&__args[..]) { if !__cu && *result.multiplicity == G::ZERO { aiur_fn_404(__args, record, io_buffer, false)? } else { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_404] = unsafe { *(result.output.as_ptr() as *const [G; OUT_404]) }; __ret } } else { aiur_fn_404(__args, record, io_buffer, __cu)? } }; + let __r_arr: [G; OUT_400] = { let __args: [G; IN_400] = [__v_18, __v_7]; let __cu = unconstrained; if let Some(result) = record.function_queries[400].get_mut(&__args[..]) { if !__cu && *result.multiplicity == G::ZERO { aiur_fn_400(__args, record, io_buffer, false)? } else { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_400] = unsafe { *(result.output.as_ptr() as *const [G; OUT_400]) }; __ret } } else { aiur_fn_400(__args, record, io_buffer, __cu)? } }; let __v_19: G = __r_arr[0]; - let __r_arr: [G; OUT_259] = { let __args: [G; IN_259] = [__v_19]; let __cu = unconstrained; if let Some(result) = record.function_queries[259].get_mut(&__args[..]) { if !__cu && *result.multiplicity == G::ZERO { aiur_fn_259(__args, record, io_buffer, false)? } else { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_259] = unsafe { *(result.output.as_ptr() as *const [G; OUT_259]) }; __ret } } else { aiur_fn_259(__args, record, io_buffer, __cu)? } }; + let __r_arr: [G; OUT_255] = { let __args: [G; IN_255] = [__v_19]; let __cu = unconstrained; if let Some(result) = record.function_queries[255].get_mut(&__args[..]) { if !__cu && *result.multiplicity == G::ZERO { aiur_fn_255(__args, record, io_buffer, false)? } else { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_255] = unsafe { *(result.output.as_ptr() as *const [G; OUT_255]) }; __ret } } else { aiur_fn_255(__args, record, io_buffer, __cu)? } }; let __v_20: G = __r_arr[0]; - let __r_arr: [G; OUT_400] = { let __args: [G; IN_400] = [__v_20]; let __cu = unconstrained; if let Some(result) = record.function_queries[400].get_mut(&__args[..]) { if !__cu && *result.multiplicity == G::ZERO { aiur_fn_400(__args, record, io_buffer, false)? } else { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_400] = unsafe { *(result.output.as_ptr() as *const [G; OUT_400]) }; __ret } } else { aiur_fn_400(__args, record, io_buffer, __cu)? } }; + let __r_arr: [G; OUT_396] = { let __args: [G; IN_396] = [__v_20]; let __cu = unconstrained; if let Some(result) = record.function_queries[396].get_mut(&__args[..]) { if !__cu && *result.multiplicity == G::ZERO { aiur_fn_396(__args, record, io_buffer, false)? } else { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_396] = unsafe { *(result.output.as_ptr() as *const [G; OUT_396]) }; __ret } } else { aiur_fn_396(__args, record, io_buffer, __cu)? } }; let __v_21: G = __r_arr[0]; - let __r_arr: [G; OUT_406] = { let __args: [G; IN_406] = [__v_21]; let __cu = unconstrained; if let Some(result) = record.function_queries[406].get_mut(&__args[..]) { if !__cu && *result.multiplicity == G::ZERO { aiur_fn_406(__args, record, io_buffer, false)? } else { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_406] = unsafe { *(result.output.as_ptr() as *const [G; OUT_406]) }; __ret } } else { aiur_fn_406(__args, record, io_buffer, __cu)? } }; + let __r_arr: [G; OUT_402] = { let __args: [G; IN_402] = [__v_21]; let __cu = unconstrained; if let Some(result) = record.function_queries[402].get_mut(&__args[..]) { if !__cu && *result.multiplicity == G::ZERO { aiur_fn_402(__args, record, io_buffer, false)? } else { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_402] = unsafe { *(result.output.as_ptr() as *const [G; OUT_402]) }; __ret } } else { aiur_fn_402(__args, record, io_buffer, __cu)? } }; let __v_22: G = __r_arr[0]; let __v_23: G = __r_arr[1]; let __v_24: G = __r_arr[2]; let __v_25: G = __r_arr[3]; match __v_22.as_canonical_u64() { 1u64 => { - let __r_arr: [G; OUT_407] = { let __args: [G; IN_407] = [__v_6, __v_23]; let __cu = unconstrained; if let Some(result) = record.function_queries[407].get_mut(&__args[..]) { if !__cu && *result.multiplicity == G::ZERO { aiur_fn_407(__args, record, io_buffer, false)? } else { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_407] = unsafe { *(result.output.as_ptr() as *const [G; OUT_407]) }; __ret } } else { aiur_fn_407(__args, record, io_buffer, __cu)? } }; + let __r_arr: [G; OUT_403] = { let __args: [G; IN_403] = [__v_6, __v_23]; let __cu = unconstrained; if let Some(result) = record.function_queries[403].get_mut(&__args[..]) { if !__cu && *result.multiplicity == G::ZERO { aiur_fn_403(__args, record, io_buffer, false)? } else { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_403] = unsafe { *(result.output.as_ptr() as *const [G; OUT_403]) }; __ret } } else { aiur_fn_403(__args, record, io_buffer, __cu)? } }; let __v_26: G = __r_arr[0]; let __v_27: G = __r_arr[1]; let __v_28: G = __r_arr[2]; @@ -36339,40 +36065,40 @@ fn aiur_fn_405( } match __v_26.as_canonical_u64() { 0u64 => { - let __r_arr: [G; OUT_403] = { let __args: [G; IN_403] = [__v_1, __v_12, __v_19]; let __cu = unconstrained; if let Some(result) = record.function_queries[403].get_mut(&__args[..]) { if !__cu && *result.multiplicity == G::ZERO { aiur_fn_403(__args, record, io_buffer, false)? } else { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_403] = unsafe { *(result.output.as_ptr() as *const [G; OUT_403]) }; __ret } } else { aiur_fn_403(__args, record, io_buffer, __cu)? } }; + let __r_arr: [G; OUT_399] = { let __args: [G; IN_399] = [__v_1, __v_12, __v_19]; let __cu = unconstrained; if let Some(result) = record.function_queries[399].get_mut(&__args[..]) { if !__cu && *result.multiplicity == G::ZERO { aiur_fn_399(__args, record, io_buffer, false)? } else { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_399] = unsafe { *(result.output.as_ptr() as *const [G; OUT_399]) }; __ret } } else { aiur_fn_399(__args, record, io_buffer, __cu)? } }; let __v_31: G = __r_arr[0]; let __v_32: G = G::from_u64(2); - let __r_arr: [G; OUT_255] = { let __args: [G; IN_255] = [__v_8, __v_31]; let __cu = unconstrained; if let Some(result) = record.function_queries[255].get_mut(&__args[..]) { if !__cu && *result.multiplicity == G::ZERO { aiur_fn_255(__args, record, io_buffer, false)? } else { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_255] = unsafe { *(result.output.as_ptr() as *const [G; OUT_255]) }; __ret } } else { aiur_fn_255(__args, record, io_buffer, __cu)? } }; + let __r_arr: [G; OUT_251] = { let __args: [G; IN_251] = [__v_8, __v_31]; let __cu = unconstrained; if let Some(result) = record.function_queries[251].get_mut(&__args[..]) { if !__cu && *result.multiplicity == G::ZERO { aiur_fn_251(__args, record, io_buffer, false)? } else { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_251] = unsafe { *(result.output.as_ptr() as *const [G; OUT_251]) }; __ret } } else { aiur_fn_251(__args, record, io_buffer, __cu)? } }; let __v_33: G = __r_arr[0]; - let __ret: [G; OUT_405] = [__v_32, __v_33]; - if let Some(result) = record.function_queries[405].get_mut(&inp[..]) { debug_assert_eq!(result.output, &__ret[..]); if !unconstrained { *result.multiplicity += G::ONE; } } else { record.function_queries[405].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained)); }; + let __ret: [G; OUT_401] = [__v_32, __v_33]; + if let Some(result) = record.function_queries[401].get_mut(&inp[..]) { debug_assert_eq!(result.output, &__ret[..]); if !unconstrained { *result.multiplicity += G::ONE; } } else { record.function_queries[401].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained)); }; return Ok(__ret); }, 1u64 => { - let __r_arr: [G; OUT_336] = { let __args: [G; IN_336] = [__v_28, __v_0]; let __cu = unconstrained; if let Some(result) = record.function_queries[336].get_mut(&__args[..]) { if !__cu && *result.multiplicity == G::ZERO { aiur_fn_336(__args, record, io_buffer, false)? } else { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_336] = unsafe { *(result.output.as_ptr() as *const [G; OUT_336]) }; __ret } } else { aiur_fn_336(__args, record, io_buffer, __cu)? } }; + let __r_arr: [G; OUT_332] = { let __args: [G; IN_332] = [__v_28, __v_0]; let __cu = unconstrained; if let Some(result) = record.function_queries[332].get_mut(&__args[..]) { if !__cu && *result.multiplicity == G::ZERO { aiur_fn_332(__args, record, io_buffer, false)? } else { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_332] = unsafe { *(result.output.as_ptr() as *const [G; OUT_332]) }; __ret } } else { aiur_fn_332(__args, record, io_buffer, __cu)? } }; let __v_31: G = __r_arr[0]; let __v_32: G = (__v_3 + __v_4); let __v_33: G = (__v_2 + __v_32); - let __r_arr: [G; OUT_774] = { let __args: [G; IN_774] = [__v_1, __v_33]; let __cu = unconstrained; if let Some(result) = record.function_queries[774].get_mut(&__args[..]) { if !__cu && *result.multiplicity == G::ZERO { aiur_fn_774(__args, record, io_buffer, false)? } else { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_774] = unsafe { *(result.output.as_ptr() as *const [G; OUT_774]) }; __ret } } else { aiur_fn_774(__args, record, io_buffer, __cu)? } }; + let __r_arr: [G; OUT_770] = { let __args: [G; IN_770] = [__v_1, __v_33]; let __cu = unconstrained; if let Some(result) = record.function_queries[770].get_mut(&__args[..]) { if !__cu && *result.multiplicity == G::ZERO { aiur_fn_770(__args, record, io_buffer, false)? } else { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_770] = unsafe { *(result.output.as_ptr() as *const [G; OUT_770]) }; __ret } } else { aiur_fn_770(__args, record, io_buffer, __cu)? } }; let __v_34: G = __r_arr[0]; - let __r_arr: [G; OUT_764] = { let __args: [G; IN_764] = [__v_25]; let __cu = unconstrained; if let Some(result) = record.function_queries[764].get_mut(&__args[..]) { if !__cu && *result.multiplicity == G::ZERO { aiur_fn_764(__args, record, io_buffer, false)? } else { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_764] = unsafe { *(result.output.as_ptr() as *const [G; OUT_764]) }; __ret } } else { aiur_fn_764(__args, record, io_buffer, __cu)? } }; + let __r_arr: [G; OUT_760] = { let __args: [G; IN_760] = [__v_25]; let __cu = unconstrained; if let Some(result) = record.function_queries[760].get_mut(&__args[..]) { if !__cu && *result.multiplicity == G::ZERO { aiur_fn_760(__args, record, io_buffer, false)? } else { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_760] = unsafe { *(result.output.as_ptr() as *const [G; OUT_760]) }; __ret } } else { aiur_fn_760(__args, record, io_buffer, __cu)? } }; let __v_35: G = __r_arr[0]; let __v_36: G = (__v_35 - __v_27); - let __r_arr: [G; OUT_775] = { let __args: [G; IN_775] = [__v_25, __v_36]; let __cu = unconstrained; if let Some(result) = record.function_queries[775].get_mut(&__args[..]) { if !__cu && *result.multiplicity == G::ZERO { aiur_fn_775(__args, record, io_buffer, false)? } else { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_775] = unsafe { *(result.output.as_ptr() as *const [G; OUT_775]) }; __ret } } else { aiur_fn_775(__args, record, io_buffer, __cu)? } }; + let __r_arr: [G; OUT_771] = { let __args: [G; IN_771] = [__v_25, __v_36]; let __cu = unconstrained; if let Some(result) = record.function_queries[771].get_mut(&__args[..]) { if !__cu && *result.multiplicity == G::ZERO { aiur_fn_771(__args, record, io_buffer, false)? } else { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_771] = unsafe { *(result.output.as_ptr() as *const [G; OUT_771]) }; __ret } } else { aiur_fn_771(__args, record, io_buffer, __cu)? } }; let __v_37: G = __r_arr[0]; let __v_38: G = G::from_u64(1); let __v_39: G = (__v_12 + __v_38); - let __r_arr: [G; OUT_775] = { let __args: [G; IN_775] = [__v_1, __v_39]; let __cu = unconstrained; if let Some(result) = record.function_queries[775].get_mut(&__args[..]) { if !__cu && *result.multiplicity == G::ZERO { aiur_fn_775(__args, record, io_buffer, false)? } else { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_775] = unsafe { *(result.output.as_ptr() as *const [G; OUT_775]) }; __ret } } else { aiur_fn_775(__args, record, io_buffer, __cu)? } }; + let __r_arr: [G; OUT_771] = { let __args: [G; IN_771] = [__v_1, __v_39]; let __cu = unconstrained; if let Some(result) = record.function_queries[771].get_mut(&__args[..]) { if !__cu && *result.multiplicity == G::ZERO { aiur_fn_771(__args, record, io_buffer, false)? } else { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_771] = unsafe { *(result.output.as_ptr() as *const [G; OUT_771]) }; __ret } } else { aiur_fn_771(__args, record, io_buffer, __cu)? } }; let __v_40: G = __r_arr[0]; - let __r_arr: [G; OUT_255] = { let __args: [G; IN_255] = [__v_31, __v_34]; let __cu = unconstrained; if let Some(result) = record.function_queries[255].get_mut(&__args[..]) { if !__cu && *result.multiplicity == G::ZERO { aiur_fn_255(__args, record, io_buffer, false)? } else { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_255] = unsafe { *(result.output.as_ptr() as *const [G; OUT_255]) }; __ret } } else { aiur_fn_255(__args, record, io_buffer, __cu)? } }; + let __r_arr: [G; OUT_251] = { let __args: [G; IN_251] = [__v_31, __v_34]; let __cu = unconstrained; if let Some(result) = record.function_queries[251].get_mut(&__args[..]) { if !__cu && *result.multiplicity == G::ZERO { aiur_fn_251(__args, record, io_buffer, false)? } else { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_251] = unsafe { *(result.output.as_ptr() as *const [G; OUT_251]) }; __ret } } else { aiur_fn_251(__args, record, io_buffer, __cu)? } }; let __v_41: G = __r_arr[0]; - let __r_arr: [G; OUT_255] = { let __args: [G; IN_255] = [__v_41, __v_37]; let __cu = unconstrained; if let Some(result) = record.function_queries[255].get_mut(&__args[..]) { if !__cu && *result.multiplicity == G::ZERO { aiur_fn_255(__args, record, io_buffer, false)? } else { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_255] = unsafe { *(result.output.as_ptr() as *const [G; OUT_255]) }; __ret } } else { aiur_fn_255(__args, record, io_buffer, __cu)? } }; + let __r_arr: [G; OUT_251] = { let __args: [G; IN_251] = [__v_41, __v_37]; let __cu = unconstrained; if let Some(result) = record.function_queries[251].get_mut(&__args[..]) { if !__cu && *result.multiplicity == G::ZERO { aiur_fn_251(__args, record, io_buffer, false)? } else { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_251] = unsafe { *(result.output.as_ptr() as *const [G; OUT_251]) }; __ret } } else { aiur_fn_251(__args, record, io_buffer, __cu)? } }; let __v_42: G = __r_arr[0]; - let __r_arr: [G; OUT_255] = { let __args: [G; IN_255] = [__v_42, __v_40]; let __cu = unconstrained; if let Some(result) = record.function_queries[255].get_mut(&__args[..]) { if !__cu && *result.multiplicity == G::ZERO { aiur_fn_255(__args, record, io_buffer, false)? } else { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_255] = unsafe { *(result.output.as_ptr() as *const [G; OUT_255]) }; __ret } } else { aiur_fn_255(__args, record, io_buffer, __cu)? } }; + let __r_arr: [G; OUT_251] = { let __args: [G; IN_251] = [__v_42, __v_40]; let __cu = unconstrained; if let Some(result) = record.function_queries[251].get_mut(&__args[..]) { if !__cu && *result.multiplicity == G::ZERO { aiur_fn_251(__args, record, io_buffer, false)? } else { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_251] = unsafe { *(result.output.as_ptr() as *const [G; OUT_251]) }; __ret } } else { aiur_fn_251(__args, record, io_buffer, __cu)? } }; let __v_43: G = __r_arr[0]; let __v_44: G = G::from_u64(1); - let __ret: [G; OUT_405] = [__v_44, __v_43]; - if let Some(result) = record.function_queries[405].get_mut(&inp[..]) { debug_assert_eq!(result.output, &__ret[..]); if !unconstrained { *result.multiplicity += G::ONE; } } else { record.function_queries[405].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained)); }; + let __ret: [G; OUT_401] = [__v_44, __v_43]; + if let Some(result) = record.function_queries[401].get_mut(&inp[..]) { debug_assert_eq!(result.output, &__ret[..]); if !unconstrained { *result.multiplicity += G::ONE; } } else { record.function_queries[401].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained)); }; return Ok(__ret); }, _ => { @@ -36381,13 +36107,13 @@ fn aiur_fn_405( } }, _ => { - let __r_arr: [G; OUT_403] = { let __args: [G; IN_403] = [__v_1, __v_12, __v_19]; let __cu = unconstrained; if let Some(result) = record.function_queries[403].get_mut(&__args[..]) { if !__cu && *result.multiplicity == G::ZERO { aiur_fn_403(__args, record, io_buffer, false)? } else { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_403] = unsafe { *(result.output.as_ptr() as *const [G; OUT_403]) }; __ret } } else { aiur_fn_403(__args, record, io_buffer, __cu)? } }; + let __r_arr: [G; OUT_399] = { let __args: [G; IN_399] = [__v_1, __v_12, __v_19]; let __cu = unconstrained; if let Some(result) = record.function_queries[399].get_mut(&__args[..]) { if !__cu && *result.multiplicity == G::ZERO { aiur_fn_399(__args, record, io_buffer, false)? } else { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_399] = unsafe { *(result.output.as_ptr() as *const [G; OUT_399]) }; __ret } } else { aiur_fn_399(__args, record, io_buffer, __cu)? } }; let __v_26: G = __r_arr[0]; let __v_27: G = G::from_u64(2); - let __r_arr: [G; OUT_255] = { let __args: [G; IN_255] = [__v_8, __v_26]; let __cu = unconstrained; if let Some(result) = record.function_queries[255].get_mut(&__args[..]) { if !__cu && *result.multiplicity == G::ZERO { aiur_fn_255(__args, record, io_buffer, false)? } else { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_255] = unsafe { *(result.output.as_ptr() as *const [G; OUT_255]) }; __ret } } else { aiur_fn_255(__args, record, io_buffer, __cu)? } }; + let __r_arr: [G; OUT_251] = { let __args: [G; IN_251] = [__v_8, __v_26]; let __cu = unconstrained; if let Some(result) = record.function_queries[251].get_mut(&__args[..]) { if !__cu && *result.multiplicity == G::ZERO { aiur_fn_251(__args, record, io_buffer, false)? } else { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_251] = unsafe { *(result.output.as_ptr() as *const [G; OUT_251]) }; __ret } } else { aiur_fn_251(__args, record, io_buffer, __cu)? } }; let __v_28: G = __r_arr[0]; - let __ret: [G; OUT_405] = [__v_27, __v_28]; - if let Some(result) = record.function_queries[405].get_mut(&inp[..]) { debug_assert_eq!(result.output, &__ret[..]); if !unconstrained { *result.multiplicity += G::ONE; } } else { record.function_queries[405].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained)); }; + let __ret: [G; OUT_401] = [__v_27, __v_28]; + if let Some(result) = record.function_queries[401].get_mut(&inp[..]) { debug_assert_eq!(result.output, &__ret[..]); if !unconstrained { *result.multiplicity += G::ONE; } } else { record.function_queries[401].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained)); }; return Ok(__ret); }, } @@ -36398,15 +36124,15 @@ fn aiur_fn_405( }) } -const INPUT_SIZE_406: usize = 1; -const IN_406: usize = 1; -const OUT_406: usize = 4; -fn aiur_fn_406( - inp: [G; IN_406], +const INPUT_SIZE_402: usize = 1; +const IN_402: usize = 1; +const OUT_402: usize = 4; +fn aiur_fn_402( + inp: [G; IN_402], record: &mut QueryRecord, io_buffer: &mut IOBuffer, unconstrained: bool, -) -> Result<[G; OUT_406], ExecError> { +) -> Result<[G; OUT_402], ExecError> { stacker::maybe_grow(64 * 1024, 4 * 1024 * 1024, || { let __v_0: G = inp[0]; let __r_arr: [G; OUT_111] = { let __args: [G; IN_111] = [__v_0]; let __cu = unconstrained; if let Some(result) = record.function_queries[111].get_mut(&__args[..]) { if !__cu && *result.multiplicity == G::ZERO { aiur_fn_111(__args, record, io_buffer, false)? } else { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_111] = unsafe { *(result.output.as_ptr() as *const [G; OUT_111]) }; __ret } } else { aiur_fn_111(__args, record, io_buffer, __cu)? } }; @@ -36419,7 +36145,7 @@ fn aiur_fn_406( let __v_6: G = __loaded[3]; match __v_3.as_canonical_u64() { 2u64 => { - let __r_arr: [G; OUT_287] = { let __args: [G; IN_287] = [__v_4]; let __cu = unconstrained; if let Some(result) = record.function_queries[287].get_mut(&__args[..]) { if !__cu && *result.multiplicity == G::ZERO { aiur_fn_287(__args, record, io_buffer, false)? } else { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_287] = unsafe { *(result.output.as_ptr() as *const [G; OUT_287]) }; __ret } } else { aiur_fn_287(__args, record, io_buffer, __cu)? } }; + let __r_arr: [G; OUT_283] = { let __args: [G; IN_283] = [__v_4]; let __cu = unconstrained; if let Some(result) = record.function_queries[283].get_mut(&__args[..]) { if !__cu && *result.multiplicity == G::ZERO { aiur_fn_283(__args, record, io_buffer, false)? } else { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_283] = unsafe { *(result.output.as_ptr() as *const [G; OUT_283]) }; __ret } } else { aiur_fn_283(__args, record, io_buffer, __cu)? } }; let __v_7: G = __r_arr[0]; let __loaded: [G; 12] = { let __mq = record.memory_queries.get_mut(&12).ok_or(ExecError::InvalidMemorySize(12))?; let __ptr_u64 = __v_7.as_canonical_u64(); let __ptr_usize = usize::try_from(__ptr_u64).ok().ok_or(ExecError::PointerTooLarge(__ptr_u64))?; let (__args, __mult) = __mq.get_index_mut(__ptr_usize).ok_or(ExecError::UnboundPointer { ptr: __ptr_u64, size: 12 })?; if !unconstrained { *__mult += G::ONE; } let __arr: [G; 12] = __args[..12].try_into().unwrap(); __arr }; let __v_8: G = __loaded[0]; @@ -36437,10 +36163,10 @@ fn aiur_fn_406( match __v_8.as_canonical_u64() { 6u64 => { let __v_20: G = G::from_u64(1); - let __r_arr: [G; OUT_464] = { let __args: [G; IN_464] = [__v_11, __v_12]; let __cu = unconstrained; if let Some(result) = record.function_queries[464].get_mut(&__args[..]) { if !__cu && *result.multiplicity == G::ZERO { aiur_fn_464(__args, record, io_buffer, false)? } else { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_464] = unsafe { *(result.output.as_ptr() as *const [G; OUT_464]) }; __ret } } else { aiur_fn_464(__args, record, io_buffer, __cu)? } }; + let __r_arr: [G; OUT_460] = { let __args: [G; IN_460] = [__v_11, __v_12]; let __cu = unconstrained; if let Some(result) = record.function_queries[460].get_mut(&__args[..]) { if !__cu && *result.multiplicity == G::ZERO { aiur_fn_460(__args, record, io_buffer, false)? } else { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_460] = unsafe { *(result.output.as_ptr() as *const [G; OUT_460]) }; __ret } } else { aiur_fn_460(__args, record, io_buffer, __cu)? } }; let __v_21: G = __r_arr[0]; - let __ret: [G; OUT_406] = [__v_20, __v_13, __v_21, __v_2]; - if let Some(result) = record.function_queries[406].get_mut(&inp[..]) { debug_assert_eq!(result.output, &__ret[..]); if !unconstrained { *result.multiplicity += G::ONE; } } else { record.function_queries[406].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained)); }; + let __ret: [G; OUT_402] = [__v_20, __v_13, __v_21, __v_2]; + if let Some(result) = record.function_queries[402].get_mut(&inp[..]) { debug_assert_eq!(result.output, &__ret[..]); if !unconstrained { *result.multiplicity += G::ONE; } } else { record.function_queries[402].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained)); }; return Ok(__ret); }, _ => { @@ -36482,8 +36208,8 @@ fn aiur_fn_406( let __v_55: G = G::from_u64(1); let __v_56: G = G::from_u64(1); let __v_57: G = { let __values: [G; 3] = [__v_55, __v_56, __v_56]; let __mq = record.memory_queries.get_mut(&3).ok_or(ExecError::InvalidMemorySize(3))?; if let Some(result) = __mq.get_mut(&__values[..]) { if !unconstrained { *result.multiplicity += G::ONE; } result.output[0] } else { let __ptr = G::from_usize(__mq.len()); __mq.insert(&__values[..], &[__ptr], G::from_bool(!unconstrained)); __ptr } }; - let __ret: [G; OUT_406] = [__v_20, __v_21, __v_54, __v_57]; - if let Some(result) = record.function_queries[406].get_mut(&inp[..]) { debug_assert_eq!(result.output, &__ret[..]); if !unconstrained { *result.multiplicity += G::ONE; } } else { record.function_queries[406].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained)); }; + let __ret: [G; OUT_402] = [__v_20, __v_21, __v_54, __v_57]; + if let Some(result) = record.function_queries[402].get_mut(&inp[..]) { debug_assert_eq!(result.output, &__ret[..]); if !unconstrained { *result.multiplicity += G::ONE; } } else { record.function_queries[402].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained)); }; return Ok(__ret); }, } @@ -36527,23 +36253,23 @@ fn aiur_fn_406( let __v_42: G = G::from_u64(1); let __v_43: G = G::from_u64(1); let __v_44: G = { let __values: [G; 3] = [__v_42, __v_43, __v_43]; let __mq = record.memory_queries.get_mut(&3).ok_or(ExecError::InvalidMemorySize(3))?; if let Some(result) = __mq.get_mut(&__values[..]) { if !unconstrained { *result.multiplicity += G::ONE; } result.output[0] } else { let __ptr = G::from_usize(__mq.len()); __mq.insert(&__values[..], &[__ptr], G::from_bool(!unconstrained)); __ptr } }; - let __ret: [G; OUT_406] = [__v_7, __v_8, __v_41, __v_44]; - if let Some(result) = record.function_queries[406].get_mut(&inp[..]) { debug_assert_eq!(result.output, &__ret[..]); if !unconstrained { *result.multiplicity += G::ONE; } } else { record.function_queries[406].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained)); }; + let __ret: [G; OUT_402] = [__v_7, __v_8, __v_41, __v_44]; + if let Some(result) = record.function_queries[402].get_mut(&inp[..]) { debug_assert_eq!(result.output, &__ret[..]); if !unconstrained { *result.multiplicity += G::ONE; } } else { record.function_queries[402].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained)); }; return Ok(__ret); }, } }) } -const INPUT_SIZE_407: usize = 2; -const IN_407: usize = 2; -const OUT_407: usize = 3; -fn aiur_fn_407( - inp: [G; IN_407], +const INPUT_SIZE_403: usize = 2; +const IN_403: usize = 2; +const OUT_403: usize = 3; +fn aiur_fn_403( + inp: [G; IN_403], record: &mut QueryRecord, io_buffer: &mut IOBuffer, unconstrained: bool, -) -> Result<[G; OUT_407], ExecError> { +) -> Result<[G; OUT_403], ExecError> { stacker::maybe_grow(64 * 1024, 4 * 1024 * 1024, || { let __v_0: G = inp[0]; let __v_1: G = inp[1]; @@ -36561,8 +36287,8 @@ fn aiur_fn_407( let __v_10: G = G::from_u64(0); let __v_11: G = G::from_u64(0); let __v_12: G = { let __values: [G; 4] = [__v_9, __v_10, __v_11, __v_11]; let __mq = record.memory_queries.get_mut(&4).ok_or(ExecError::InvalidMemorySize(4))?; if let Some(result) = __mq.get_mut(&__values[..]) { if !unconstrained { *result.multiplicity += G::ONE; } result.output[0] } else { let __ptr = G::from_usize(__mq.len()); __mq.insert(&__values[..], &[__ptr], G::from_bool(!unconstrained)); __ptr } }; - let __ret: [G; OUT_407] = [__v_7, __v_8, __v_12]; - if let Some(result) = record.function_queries[407].get_mut(&inp[..]) { debug_assert_eq!(result.output, &__ret[..]); if !unconstrained { *result.multiplicity += G::ONE; } } else { record.function_queries[407].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained)); }; + let __ret: [G; OUT_403] = [__v_7, __v_8, __v_12]; + if let Some(result) = record.function_queries[403].get_mut(&inp[..]) { debug_assert_eq!(result.output, &__ret[..]); if !unconstrained { *result.multiplicity += G::ONE; } } else { record.function_queries[403].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained)); }; return Ok(__ret); }, 0u64 => { @@ -36572,17 +36298,17 @@ fn aiur_fn_407( match __v_7.as_canonical_u64() { 0u64 => { let __v_8: G = G::from_u64(1); - let __ret: [G; OUT_407] = [__v_8, __v_4, __v_5]; - if let Some(result) = record.function_queries[407].get_mut(&inp[..]) { debug_assert_eq!(result.output, &__ret[..]); if !unconstrained { *result.multiplicity += G::ONE; } } else { record.function_queries[407].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained)); }; + let __ret: [G; OUT_403] = [__v_8, __v_4, __v_5]; + if let Some(result) = record.function_queries[403].get_mut(&inp[..]) { debug_assert_eq!(result.output, &__ret[..]); if !unconstrained { *result.multiplicity += G::ONE; } } else { record.function_queries[403].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained)); }; return Ok(__ret); }, _ => { - let __r_arr: [G; OUT_407] = { let __args: [G; IN_407] = [__v_6, __v_1]; let __cu = unconstrained; if let Some(result) = record.function_queries[407].get_mut(&__args[..]) { if !__cu && *result.multiplicity == G::ZERO { aiur_fn_407(__args, record, io_buffer, false)? } else { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_407] = unsafe { *(result.output.as_ptr() as *const [G; OUT_407]) }; __ret } } else { aiur_fn_407(__args, record, io_buffer, __cu)? } }; + let __r_arr: [G; OUT_403] = { let __args: [G; IN_403] = [__v_6, __v_1]; let __cu = unconstrained; if let Some(result) = record.function_queries[403].get_mut(&__args[..]) { if !__cu && *result.multiplicity == G::ZERO { aiur_fn_403(__args, record, io_buffer, false)? } else { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_403] = unsafe { *(result.output.as_ptr() as *const [G; OUT_403]) }; __ret } } else { aiur_fn_403(__args, record, io_buffer, __cu)? } }; let __v_8: G = __r_arr[0]; let __v_9: G = __r_arr[1]; let __v_10: G = __r_arr[2]; - let __ret: [G; OUT_407] = [__v_8, __v_9, __v_10]; - if let Some(result) = record.function_queries[407].get_mut(&inp[..]) { debug_assert_eq!(result.output, &__ret[..]); if !unconstrained { *result.multiplicity += G::ONE; } } else { record.function_queries[407].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained)); }; + let __ret: [G; OUT_403] = [__v_8, __v_9, __v_10]; + if let Some(result) = record.function_queries[403].get_mut(&inp[..]) { debug_assert_eq!(result.output, &__ret[..]); if !unconstrained { *result.multiplicity += G::ONE; } } else { record.function_queries[403].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained)); }; return Ok(__ret); }, } @@ -36596,15 +36322,15 @@ fn aiur_fn_407( }) } -const INPUT_SIZE_408: usize = 9; -const IN_408: usize = 9; -const OUT_408: usize = 2; -fn aiur_fn_408( - inp: [G; IN_408], +const INPUT_SIZE_404: usize = 9; +const IN_404: usize = 9; +const OUT_404: usize = 2; +fn aiur_fn_404( + inp: [G; IN_404], record: &mut QueryRecord, io_buffer: &mut IOBuffer, unconstrained: bool, -) -> Result<[G; OUT_408], ExecError> { +) -> Result<[G; OUT_404], ExecError> { stacker::maybe_grow(64 * 1024, 4 * 1024 * 1024, || { let __v_0: G = inp[0]; let __v_1: G = inp[1]; @@ -36628,8 +36354,8 @@ fn aiur_fn_408( let __v_16: G = G::from_u64(0); let __v_17: G = G::from_u64(0); let __v_18: G = { let __values: [G; 4] = [__v_15, __v_16, __v_17, __v_17]; let __mq = record.memory_queries.get_mut(&4).ok_or(ExecError::InvalidMemorySize(4))?; if let Some(result) = __mq.get_mut(&__values[..]) { if !unconstrained { *result.multiplicity += G::ONE; } result.output[0] } else { let __ptr = G::from_usize(__mq.len()); __mq.insert(&__values[..], &[__ptr], G::from_bool(!unconstrained)); __ptr } }; - let __ret: [G; OUT_408] = [__v_14, __v_18]; - if let Some(result) = record.function_queries[408].get_mut(&inp[..]) { debug_assert_eq!(result.output, &__ret[..]); if !unconstrained { *result.multiplicity += G::ONE; } } else { record.function_queries[408].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained)); }; + let __ret: [G; OUT_404] = [__v_14, __v_18]; + if let Some(result) = record.function_queries[404].get_mut(&inp[..]) { debug_assert_eq!(result.output, &__ret[..]); if !unconstrained { *result.multiplicity += G::ONE; } } else { record.function_queries[404].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained)); }; return Ok(__ret); }, 0u64 => { @@ -36646,8 +36372,8 @@ fn aiur_fn_408( let __v_21: G = G::from_u64(0); let __v_22: G = G::from_u64(0); let __v_23: G = { let __values: [G; 4] = [__v_20, __v_21, __v_22, __v_22]; let __mq = record.memory_queries.get_mut(&4).ok_or(ExecError::InvalidMemorySize(4))?; if let Some(result) = __mq.get_mut(&__values[..]) { if !unconstrained { *result.multiplicity += G::ONE; } result.output[0] } else { let __ptr = G::from_usize(__mq.len()); __mq.insert(&__values[..], &[__ptr], G::from_bool(!unconstrained)); __ptr } }; - let __ret: [G; OUT_408] = [__v_19, __v_23]; - if let Some(result) = record.function_queries[408].get_mut(&inp[..]) { debug_assert_eq!(result.output, &__ret[..]); if !unconstrained { *result.multiplicity += G::ONE; } } else { record.function_queries[408].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained)); }; + let __ret: [G; OUT_404] = [__v_19, __v_23]; + if let Some(result) = record.function_queries[404].get_mut(&inp[..]) { debug_assert_eq!(result.output, &__ret[..]); if !unconstrained { *result.multiplicity += G::ONE; } } else { record.function_queries[404].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained)); }; return Ok(__ret); }, 1u64 => { @@ -36656,7 +36382,7 @@ fn aiur_fn_408( let __v_19: G = (__v_3 + __v_4); let __v_20: G = (__v_19 + __v_5); let __v_21: G = (__v_20 + __v_6); - let __r_arr: [G; OUT_409] = { let __args: [G; IN_409] = [__v_0, __v_21]; let __cu = unconstrained; if let Some(result) = record.function_queries[409].get_mut(&__args[..]) { if !__cu && *result.multiplicity == G::ZERO { aiur_fn_409(__args, record, io_buffer, false)? } else { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_409] = unsafe { *(result.output.as_ptr() as *const [G; OUT_409]) }; __ret } } else { aiur_fn_409(__args, record, io_buffer, __cu)? } }; + let __r_arr: [G; OUT_405] = { let __args: [G; IN_405] = [__v_0, __v_21]; let __cu = unconstrained; if let Some(result) = record.function_queries[405].get_mut(&__args[..]) { if !__cu && *result.multiplicity == G::ZERO { aiur_fn_405(__args, record, io_buffer, false)? } else { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_405] = unsafe { *(result.output.as_ptr() as *const [G; OUT_405]) }; __ret } } else { aiur_fn_405(__args, record, io_buffer, __cu)? } }; let __v_22: G = __r_arr[0]; let __v_23: G = __r_arr[1]; match __v_22.as_canonical_u64() { @@ -36666,12 +36392,12 @@ fn aiur_fn_408( let __v_26: G = G::from_u64(0); let __v_27: G = G::from_u64(0); let __v_28: G = { let __values: [G; 4] = [__v_25, __v_26, __v_27, __v_27]; let __mq = record.memory_queries.get_mut(&4).ok_or(ExecError::InvalidMemorySize(4))?; if let Some(result) = __mq.get_mut(&__values[..]) { if !unconstrained { *result.multiplicity += G::ONE; } result.output[0] } else { let __ptr = G::from_usize(__mq.len()); __mq.insert(&__values[..], &[__ptr], G::from_bool(!unconstrained)); __ptr } }; - let __ret: [G; OUT_408] = [__v_24, __v_28]; - if let Some(result) = record.function_queries[408].get_mut(&inp[..]) { debug_assert_eq!(result.output, &__ret[..]); if !unconstrained { *result.multiplicity += G::ONE; } } else { record.function_queries[408].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained)); }; + let __ret: [G; OUT_404] = [__v_24, __v_28]; + if let Some(result) = record.function_queries[404].get_mut(&inp[..]) { debug_assert_eq!(result.output, &__ret[..]); if !unconstrained { *result.multiplicity += G::ONE; } } else { record.function_queries[404].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained)); }; return Ok(__ret); }, _ => { - let __r_arr: [G; OUT_287] = { let __args: [G; IN_287] = [__v_23]; let __cu = unconstrained; if let Some(result) = record.function_queries[287].get_mut(&__args[..]) { if !__cu && *result.multiplicity == G::ZERO { aiur_fn_287(__args, record, io_buffer, false)? } else { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_287] = unsafe { *(result.output.as_ptr() as *const [G; OUT_287]) }; __ret } } else { aiur_fn_287(__args, record, io_buffer, __cu)? } }; + let __r_arr: [G; OUT_283] = { let __args: [G; IN_283] = [__v_23]; let __cu = unconstrained; if let Some(result) = record.function_queries[283].get_mut(&__args[..]) { if !__cu && *result.multiplicity == G::ZERO { aiur_fn_283(__args, record, io_buffer, false)? } else { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_283] = unsafe { *(result.output.as_ptr() as *const [G; OUT_283]) }; __ret } } else { aiur_fn_283(__args, record, io_buffer, __cu)? } }; let __v_24: G = __r_arr[0]; let __loaded: [G; 12] = { let __mq = record.memory_queries.get_mut(&12).ok_or(ExecError::InvalidMemorySize(12))?; let __ptr_u64 = __v_24.as_canonical_u64(); let __ptr_usize = usize::try_from(__ptr_u64).ok().ok_or(ExecError::PointerTooLarge(__ptr_u64))?; let (__args, __mult) = __mq.get_index_mut(__ptr_usize).ok_or(ExecError::UnboundPointer { ptr: __ptr_u64, size: 12 })?; if !unconstrained { *__mult += G::ONE; } let __arr: [G; 12] = __args[..12].try_into().unwrap(); __arr }; let __v_25: G = __loaded[0]; @@ -36694,7 +36420,7 @@ fn aiur_fn_408( 0u64 => { match __v_29.as_canonical_u64() { 0u64 => { - let __r_arr: [G; OUT_411] = { let __args: [G; IN_411] = [__v_23]; let __cu = unconstrained; if let Some(result) = record.function_queries[411].get_mut(&__args[..]) { if !__cu && *result.multiplicity == G::ZERO { aiur_fn_411(__args, record, io_buffer, false)? } else { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_411] = unsafe { *(result.output.as_ptr() as *const [G; OUT_411]) }; __ret } } else { aiur_fn_411(__args, record, io_buffer, __cu)? } }; + let __r_arr: [G; OUT_407] = { let __args: [G; IN_407] = [__v_23]; let __cu = unconstrained; if let Some(result) = record.function_queries[407].get_mut(&__args[..]) { if !__cu && *result.multiplicity == G::ZERO { aiur_fn_407(__args, record, io_buffer, false)? } else { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_407] = unsafe { *(result.output.as_ptr() as *const [G; OUT_407]) }; __ret } } else { aiur_fn_407(__args, record, io_buffer, __cu)? } }; let __v_39: G = __r_arr[0]; match __v_39.as_canonical_u64() { 1u64 => { @@ -36703,18 +36429,18 @@ fn aiur_fn_408( let __v_42: G = G::from_u64(0); let __v_43: G = G::from_u64(0); let __v_44: G = { let __values: [G; 4] = [__v_41, __v_42, __v_43, __v_43]; let __mq = record.memory_queries.get_mut(&4).ok_or(ExecError::InvalidMemorySize(4))?; if let Some(result) = __mq.get_mut(&__values[..]) { if !unconstrained { *result.multiplicity += G::ONE; } result.output[0] } else { let __ptr = G::from_usize(__mq.len()); __mq.insert(&__values[..], &[__ptr], G::from_bool(!unconstrained)); __ptr } }; - let __ret: [G; OUT_408] = [__v_40, __v_44]; - if let Some(result) = record.function_queries[408].get_mut(&inp[..]) { debug_assert_eq!(result.output, &__ret[..]); if !unconstrained { *result.multiplicity += G::ONE; } } else { record.function_queries[408].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained)); }; + let __ret: [G; OUT_404] = [__v_40, __v_44]; + if let Some(result) = record.function_queries[404].get_mut(&inp[..]) { debug_assert_eq!(result.output, &__ret[..]); if !unconstrained { *result.multiplicity += G::ONE; } } else { record.function_queries[404].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained)); }; return Ok(__ret); }, _ => { - let __r_arr: [G; OUT_766] = { let __args: [G; IN_766] = [__v_2, __v_21]; let __cu = unconstrained; if let Some(result) = record.function_queries[766].get_mut(&__args[..]) { if !__cu && *result.multiplicity == G::ZERO { aiur_fn_766(__args, record, io_buffer, false)? } else { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_766] = unsafe { *(result.output.as_ptr() as *const [G; OUT_766]) }; __ret } } else { aiur_fn_766(__args, record, io_buffer, __cu)? } }; + let __r_arr: [G; OUT_762] = { let __args: [G; IN_762] = [__v_2, __v_21]; let __cu = unconstrained; if let Some(result) = record.function_queries[762].get_mut(&__args[..]) { if !__cu && *result.multiplicity == G::ZERO { aiur_fn_762(__args, record, io_buffer, false)? } else { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_762] = unsafe { *(result.output.as_ptr() as *const [G; OUT_762]) }; __ret } } else { aiur_fn_762(__args, record, io_buffer, __cu)? } }; let __v_40: G = __r_arr[0]; - let __r_arr: [G; OUT_764] = { let __args: [G; IN_764] = [__v_8]; let __cu = unconstrained; if let Some(result) = record.function_queries[764].get_mut(&__args[..]) { if !__cu && *result.multiplicity == G::ZERO { aiur_fn_764(__args, record, io_buffer, false)? } else { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_764] = unsafe { *(result.output.as_ptr() as *const [G; OUT_764]) }; __ret } } else { aiur_fn_764(__args, record, io_buffer, __cu)? } }; + let __r_arr: [G; OUT_760] = { let __args: [G; IN_760] = [__v_8]; let __cu = unconstrained; if let Some(result) = record.function_queries[760].get_mut(&__args[..]) { if !__cu && *result.multiplicity == G::ZERO { aiur_fn_760(__args, record, io_buffer, false)? } else { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_760] = unsafe { *(result.output.as_ptr() as *const [G; OUT_760]) }; __ret } } else { aiur_fn_760(__args, record, io_buffer, __cu)? } }; let __v_41: G = __r_arr[0]; - let __r_arr: [G; OUT_341] = { let __args: [G; IN_341] = [__v_40]; let __cu = unconstrained; if let Some(result) = record.function_queries[341].get_mut(&__args[..]) { if !__cu && *result.multiplicity == G::ZERO { aiur_fn_341(__args, record, io_buffer, false)? } else { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_341] = unsafe { *(result.output.as_ptr() as *const [G; OUT_341]) }; __ret } } else { aiur_fn_341(__args, record, io_buffer, __cu)? } }; + let __r_arr: [G; OUT_337] = { let __args: [G; IN_337] = [__v_40]; let __cu = unconstrained; if let Some(result) = record.function_queries[337].get_mut(&__args[..]) { if !__cu && *result.multiplicity == G::ZERO { aiur_fn_337(__args, record, io_buffer, false)? } else { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_337] = unsafe { *(result.output.as_ptr() as *const [G; OUT_337]) }; __ret } } else { aiur_fn_337(__args, record, io_buffer, __cu)? } }; let __v_42: G = __r_arr[0]; - let __r_arr: [G; OUT_346] = { let __args: [G; IN_346] = [__v_41, __v_42]; let __cu = unconstrained; if let Some(result) = record.function_queries[346].get_mut(&__args[..]) { if !__cu && *result.multiplicity == G::ZERO { aiur_fn_346(__args, record, io_buffer, false)? } else { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_346] = unsafe { *(result.output.as_ptr() as *const [G; OUT_346]) }; __ret } } else { aiur_fn_346(__args, record, io_buffer, __cu)? } }; + let __r_arr: [G; OUT_342] = { let __args: [G; IN_342] = [__v_41, __v_42]; let __cu = unconstrained; if let Some(result) = record.function_queries[342].get_mut(&__args[..]) { if !__cu && *result.multiplicity == G::ZERO { aiur_fn_342(__args, record, io_buffer, false)? } else { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_342] = unsafe { *(result.output.as_ptr() as *const [G; OUT_342]) }; __ret } } else { aiur_fn_342(__args, record, io_buffer, __cu)? } }; let __v_43: G = __r_arr[0]; match __v_43.as_canonical_u64() { 1u64 => { @@ -36723,14 +36449,14 @@ fn aiur_fn_408( let __v_46: G = G::from_u64(0); let __v_47: G = G::from_u64(0); let __v_48: G = { let __values: [G; 4] = [__v_45, __v_46, __v_47, __v_47]; let __mq = record.memory_queries.get_mut(&4).ok_or(ExecError::InvalidMemorySize(4))?; if let Some(result) = __mq.get_mut(&__values[..]) { if !unconstrained { *result.multiplicity += G::ONE; } result.output[0] } else { let __ptr = G::from_usize(__mq.len()); __mq.insert(&__values[..], &[__ptr], G::from_bool(!unconstrained)); __ptr } }; - let __ret: [G; OUT_408] = [__v_44, __v_48]; - if let Some(result) = record.function_queries[408].get_mut(&inp[..]) { debug_assert_eq!(result.output, &__ret[..]); if !unconstrained { *result.multiplicity += G::ONE; } } else { record.function_queries[408].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained)); }; + let __ret: [G; OUT_404] = [__v_44, __v_48]; + if let Some(result) = record.function_queries[404].get_mut(&inp[..]) { debug_assert_eq!(result.output, &__ret[..]); if !unconstrained { *result.multiplicity += G::ONE; } } else { record.function_queries[404].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained)); }; return Ok(__ret); }, _ => { - let __r_arr: [G; OUT_488] = { let __args: [G; IN_488] = [__v_40, __v_8]; let __cu = unconstrained; if let Some(result) = record.function_queries[488].get_mut(&__args[..]) { if !__cu && *result.multiplicity == G::ZERO { aiur_fn_488(__args, record, io_buffer, false)? } else { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_488] = unsafe { *(result.output.as_ptr() as *const [G; OUT_488]) }; __ret } } else { aiur_fn_488(__args, record, io_buffer, __cu)? } }; + let __r_arr: [G; OUT_484] = { let __args: [G; IN_484] = [__v_40, __v_8]; let __cu = unconstrained; if let Some(result) = record.function_queries[484].get_mut(&__args[..]) { if !__cu && *result.multiplicity == G::ZERO { aiur_fn_484(__args, record, io_buffer, false)? } else { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_484] = unsafe { *(result.output.as_ptr() as *const [G; OUT_484]) }; __ret } } else { aiur_fn_484(__args, record, io_buffer, __cu)? } }; let __v_44: G = __r_arr[0]; - let __r_arr: [G; OUT_470] = { let __args: [G; IN_470] = [__v_44, __v_8]; let __cu = unconstrained; if let Some(result) = record.function_queries[470].get_mut(&__args[..]) { if !__cu && *result.multiplicity == G::ZERO { aiur_fn_470(__args, record, io_buffer, false)? } else { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_470] = unsafe { *(result.output.as_ptr() as *const [G; OUT_470]) }; __ret } } else { aiur_fn_470(__args, record, io_buffer, __cu)? } }; + let __r_arr: [G; OUT_466] = { let __args: [G; IN_466] = [__v_44, __v_8]; let __cu = unconstrained; if let Some(result) = record.function_queries[466].get_mut(&__args[..]) { if !__cu && *result.multiplicity == G::ZERO { aiur_fn_466(__args, record, io_buffer, false)? } else { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_466] = unsafe { *(result.output.as_ptr() as *const [G; OUT_466]) }; __ret } } else { aiur_fn_466(__args, record, io_buffer, __cu)? } }; let __v_45: G = __r_arr[0]; match __v_45.as_canonical_u64() { 1u64 => { @@ -36739,31 +36465,31 @@ fn aiur_fn_408( let __v_48: G = G::from_u64(0); let __v_49: G = G::from_u64(0); let __v_50: G = { let __values: [G; 4] = [__v_47, __v_48, __v_49, __v_49]; let __mq = record.memory_queries.get_mut(&4).ok_or(ExecError::InvalidMemorySize(4))?; if let Some(result) = __mq.get_mut(&__values[..]) { if !unconstrained { *result.multiplicity += G::ONE; } result.output[0] } else { let __ptr = G::from_usize(__mq.len()); __mq.insert(&__values[..], &[__ptr], G::from_bool(!unconstrained)); __ptr } }; - let __ret: [G; OUT_408] = [__v_46, __v_50]; - if let Some(result) = record.function_queries[408].get_mut(&inp[..]) { debug_assert_eq!(result.output, &__ret[..]); if !unconstrained { *result.multiplicity += G::ONE; } } else { record.function_queries[408].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained)); }; + let __ret: [G; OUT_404] = [__v_46, __v_50]; + if let Some(result) = record.function_queries[404].get_mut(&inp[..]) { debug_assert_eq!(result.output, &__ret[..]); if !unconstrained { *result.multiplicity += G::ONE; } } else { record.function_queries[404].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained)); }; return Ok(__ret); }, _ => { - let __r_arr: [G; OUT_336] = { let __args: [G; IN_336] = [__v_12, __v_1]; let __cu = unconstrained; if let Some(result) = record.function_queries[336].get_mut(&__args[..]) { if !__cu && *result.multiplicity == G::ZERO { aiur_fn_336(__args, record, io_buffer, false)? } else { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_336] = unsafe { *(result.output.as_ptr() as *const [G; OUT_336]) }; __ret } } else { aiur_fn_336(__args, record, io_buffer, __cu)? } }; + let __r_arr: [G; OUT_332] = { let __args: [G; IN_332] = [__v_12, __v_1]; let __cu = unconstrained; if let Some(result) = record.function_queries[332].get_mut(&__args[..]) { if !__cu && *result.multiplicity == G::ZERO { aiur_fn_332(__args, record, io_buffer, false)? } else { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_332] = unsafe { *(result.output.as_ptr() as *const [G; OUT_332]) }; __ret } } else { aiur_fn_332(__args, record, io_buffer, __cu)? } }; let __v_46: G = __r_arr[0]; let __v_47: G = (__v_3 + __v_4); let __v_48: G = (__v_47 + __v_5); - let __r_arr: [G; OUT_774] = { let __args: [G; IN_774] = [__v_2, __v_48]; let __cu = unconstrained; if let Some(result) = record.function_queries[774].get_mut(&__args[..]) { if !__cu && *result.multiplicity == G::ZERO { aiur_fn_774(__args, record, io_buffer, false)? } else { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_774] = unsafe { *(result.output.as_ptr() as *const [G; OUT_774]) }; __ret } } else { aiur_fn_774(__args, record, io_buffer, __cu)? } }; + let __r_arr: [G; OUT_770] = { let __args: [G; IN_770] = [__v_2, __v_48]; let __cu = unconstrained; if let Some(result) = record.function_queries[770].get_mut(&__args[..]) { if !__cu && *result.multiplicity == G::ZERO { aiur_fn_770(__args, record, io_buffer, false)? } else { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_770] = unsafe { *(result.output.as_ptr() as *const [G; OUT_770]) }; __ret } } else { aiur_fn_770(__args, record, io_buffer, __cu)? } }; let __v_49: G = __r_arr[0]; - let __r_arr: [G; OUT_255] = { let __args: [G; IN_255] = [__v_46, __v_49]; let __cu = unconstrained; if let Some(result) = record.function_queries[255].get_mut(&__args[..]) { if !__cu && *result.multiplicity == G::ZERO { aiur_fn_255(__args, record, io_buffer, false)? } else { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_255] = unsafe { *(result.output.as_ptr() as *const [G; OUT_255]) }; __ret } } else { aiur_fn_255(__args, record, io_buffer, __cu)? } }; + let __r_arr: [G; OUT_251] = { let __args: [G; IN_251] = [__v_46, __v_49]; let __cu = unconstrained; if let Some(result) = record.function_queries[251].get_mut(&__args[..]) { if !__cu && *result.multiplicity == G::ZERO { aiur_fn_251(__args, record, io_buffer, false)? } else { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_251] = unsafe { *(result.output.as_ptr() as *const [G; OUT_251]) }; __ret } } else { aiur_fn_251(__args, record, io_buffer, __cu)? } }; let __v_50: G = __r_arr[0]; let __v_51: G = G::from_u64(0); - let __r_arr: [G; OUT_410] = { let __args: [G; IN_410] = [__v_50, __v_23, __v_40, __v_11, __v_51]; let __cu = unconstrained; if let Some(result) = record.function_queries[410].get_mut(&__args[..]) { if !__cu && *result.multiplicity == G::ZERO { aiur_fn_410(__args, record, io_buffer, false)? } else { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_410] = unsafe { *(result.output.as_ptr() as *const [G; OUT_410]) }; __ret } } else { aiur_fn_410(__args, record, io_buffer, __cu)? } }; + let __r_arr: [G; OUT_406] = { let __args: [G; IN_406] = [__v_50, __v_23, __v_40, __v_11, __v_51]; let __cu = unconstrained; if let Some(result) = record.function_queries[406].get_mut(&__args[..]) { if !__cu && *result.multiplicity == G::ZERO { aiur_fn_406(__args, record, io_buffer, false)? } else { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_406] = unsafe { *(result.output.as_ptr() as *const [G; OUT_406]) }; __ret } } else { aiur_fn_406(__args, record, io_buffer, __cu)? } }; let __v_52: G = __r_arr[0]; let __v_53: G = G::from_u64(1); let __v_54: G = (__v_21 + __v_53); - let __r_arr: [G; OUT_775] = { let __args: [G; IN_775] = [__v_2, __v_54]; let __cu = unconstrained; if let Some(result) = record.function_queries[775].get_mut(&__args[..]) { if !__cu && *result.multiplicity == G::ZERO { aiur_fn_775(__args, record, io_buffer, false)? } else { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_775] = unsafe { *(result.output.as_ptr() as *const [G; OUT_775]) }; __ret } } else { aiur_fn_775(__args, record, io_buffer, __cu)? } }; + let __r_arr: [G; OUT_771] = { let __args: [G; IN_771] = [__v_2, __v_54]; let __cu = unconstrained; if let Some(result) = record.function_queries[771].get_mut(&__args[..]) { if !__cu && *result.multiplicity == G::ZERO { aiur_fn_771(__args, record, io_buffer, false)? } else { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_771] = unsafe { *(result.output.as_ptr() as *const [G; OUT_771]) }; __ret } } else { aiur_fn_771(__args, record, io_buffer, __cu)? } }; let __v_55: G = __r_arr[0]; let __v_56: G = G::from_u64(1); - let __r_arr: [G; OUT_255] = { let __args: [G; IN_255] = [__v_52, __v_55]; let __cu = unconstrained; if let Some(result) = record.function_queries[255].get_mut(&__args[..]) { if !__cu && *result.multiplicity == G::ZERO { aiur_fn_255(__args, record, io_buffer, false)? } else { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_255] = unsafe { *(result.output.as_ptr() as *const [G; OUT_255]) }; __ret } } else { aiur_fn_255(__args, record, io_buffer, __cu)? } }; + let __r_arr: [G; OUT_251] = { let __args: [G; IN_251] = [__v_52, __v_55]; let __cu = unconstrained; if let Some(result) = record.function_queries[251].get_mut(&__args[..]) { if !__cu && *result.multiplicity == G::ZERO { aiur_fn_251(__args, record, io_buffer, false)? } else { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_251] = unsafe { *(result.output.as_ptr() as *const [G; OUT_251]) }; __ret } } else { aiur_fn_251(__args, record, io_buffer, __cu)? } }; let __v_57: G = __r_arr[0]; - let __ret: [G; OUT_408] = [__v_56, __v_57]; - if let Some(result) = record.function_queries[408].get_mut(&inp[..]) { debug_assert_eq!(result.output, &__ret[..]); if !unconstrained { *result.multiplicity += G::ONE; } } else { record.function_queries[408].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained)); }; + let __ret: [G; OUT_404] = [__v_56, __v_57]; + if let Some(result) = record.function_queries[404].get_mut(&inp[..]) { debug_assert_eq!(result.output, &__ret[..]); if !unconstrained { *result.multiplicity += G::ONE; } } else { record.function_queries[404].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained)); }; return Ok(__ret); }, } @@ -36778,8 +36504,8 @@ fn aiur_fn_408( let __v_41: G = G::from_u64(0); let __v_42: G = G::from_u64(0); let __v_43: G = { let __values: [G; 4] = [__v_40, __v_41, __v_42, __v_42]; let __mq = record.memory_queries.get_mut(&4).ok_or(ExecError::InvalidMemorySize(4))?; if let Some(result) = __mq.get_mut(&__values[..]) { if !unconstrained { *result.multiplicity += G::ONE; } result.output[0] } else { let __ptr = G::from_usize(__mq.len()); __mq.insert(&__values[..], &[__ptr], G::from_bool(!unconstrained)); __ptr } }; - let __ret: [G; OUT_408] = [__v_39, __v_43]; - if let Some(result) = record.function_queries[408].get_mut(&inp[..]) { debug_assert_eq!(result.output, &__ret[..]); if !unconstrained { *result.multiplicity += G::ONE; } } else { record.function_queries[408].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained)); }; + let __ret: [G; OUT_404] = [__v_39, __v_43]; + if let Some(result) = record.function_queries[404].get_mut(&inp[..]) { debug_assert_eq!(result.output, &__ret[..]); if !unconstrained { *result.multiplicity += G::ONE; } } else { record.function_queries[404].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained)); }; return Ok(__ret); }, } @@ -36790,8 +36516,8 @@ fn aiur_fn_408( let __v_41: G = G::from_u64(0); let __v_42: G = G::from_u64(0); let __v_43: G = { let __values: [G; 4] = [__v_40, __v_41, __v_42, __v_42]; let __mq = record.memory_queries.get_mut(&4).ok_or(ExecError::InvalidMemorySize(4))?; if let Some(result) = __mq.get_mut(&__values[..]) { if !unconstrained { *result.multiplicity += G::ONE; } result.output[0] } else { let __ptr = G::from_usize(__mq.len()); __mq.insert(&__values[..], &[__ptr], G::from_bool(!unconstrained)); __ptr } }; - let __ret: [G; OUT_408] = [__v_39, __v_43]; - if let Some(result) = record.function_queries[408].get_mut(&inp[..]) { debug_assert_eq!(result.output, &__ret[..]); if !unconstrained { *result.multiplicity += G::ONE; } } else { record.function_queries[408].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained)); }; + let __ret: [G; OUT_404] = [__v_39, __v_43]; + if let Some(result) = record.function_queries[404].get_mut(&inp[..]) { debug_assert_eq!(result.output, &__ret[..]); if !unconstrained { *result.multiplicity += G::ONE; } } else { record.function_queries[404].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained)); }; return Ok(__ret); }, } @@ -36802,8 +36528,8 @@ fn aiur_fn_408( let __v_39: G = G::from_u64(0); let __v_40: G = G::from_u64(0); let __v_41: G = { let __values: [G; 4] = [__v_38, __v_39, __v_40, __v_40]; let __mq = record.memory_queries.get_mut(&4).ok_or(ExecError::InvalidMemorySize(4))?; if let Some(result) = __mq.get_mut(&__values[..]) { if !unconstrained { *result.multiplicity += G::ONE; } result.output[0] } else { let __ptr = G::from_usize(__mq.len()); __mq.insert(&__values[..], &[__ptr], G::from_bool(!unconstrained)); __ptr } }; - let __ret: [G; OUT_408] = [__v_37, __v_41]; - if let Some(result) = record.function_queries[408].get_mut(&inp[..]) { debug_assert_eq!(result.output, &__ret[..]); if !unconstrained { *result.multiplicity += G::ONE; } } else { record.function_queries[408].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained)); }; + let __ret: [G; OUT_404] = [__v_37, __v_41]; + if let Some(result) = record.function_queries[404].get_mut(&inp[..]) { debug_assert_eq!(result.output, &__ret[..]); if !unconstrained { *result.multiplicity += G::ONE; } } else { record.function_queries[404].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained)); }; return Ok(__ret); }, } @@ -36824,15 +36550,15 @@ fn aiur_fn_408( }) } -const INPUT_SIZE_409: usize = 2; -const IN_409: usize = 2; -const OUT_409: usize = 2; -fn aiur_fn_409( - inp: [G; IN_409], +const INPUT_SIZE_405: usize = 2; +const IN_405: usize = 2; +const OUT_405: usize = 2; +fn aiur_fn_405( + inp: [G; IN_405], record: &mut QueryRecord, io_buffer: &mut IOBuffer, unconstrained: bool, -) -> Result<[G; OUT_409], ExecError> { +) -> Result<[G; OUT_405], ExecError> { stacker::maybe_grow(64 * 1024, 4 * 1024 * 1024, || { let __v_0: G = inp[0]; let __v_1: G = inp[1]; @@ -36856,8 +36582,8 @@ fn aiur_fn_409( match __v_8.as_canonical_u64() { 2u64 => { let __v_12: G = G::from_u64(1); - let __ret: [G; OUT_409] = [__v_12, __v_9]; - if let Some(result) = record.function_queries[409].get_mut(&inp[..]) { debug_assert_eq!(result.output, &__ret[..]); if !unconstrained { *result.multiplicity += G::ONE; } } else { record.function_queries[409].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained)); }; + let __ret: [G; OUT_405] = [__v_12, __v_9]; + if let Some(result) = record.function_queries[405].get_mut(&inp[..]) { debug_assert_eq!(result.output, &__ret[..]); if !unconstrained { *result.multiplicity += G::ONE; } } else { record.function_queries[405].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained)); }; return Ok(__ret); }, _ => { @@ -36895,8 +36621,8 @@ fn aiur_fn_409( let __v_43: G = G::from_u64(0); let __v_44: G = G::from_u64(0); let __v_45: G = { let __values: [G; 32] = [__v_13, __v_14, __v_15, __v_16, __v_17, __v_18, __v_19, __v_20, __v_21, __v_22, __v_23, __v_24, __v_25, __v_26, __v_27, __v_28, __v_29, __v_30, __v_31, __v_32, __v_33, __v_34, __v_35, __v_36, __v_37, __v_38, __v_39, __v_40, __v_41, __v_42, __v_43, __v_44]; let __mq = record.memory_queries.get_mut(&32).ok_or(ExecError::InvalidMemorySize(32))?; if let Some(result) = __mq.get_mut(&__values[..]) { if !unconstrained { *result.multiplicity += G::ONE; } result.output[0] } else { let __ptr = G::from_usize(__mq.len()); __mq.insert(&__values[..], &[__ptr], G::from_bool(!unconstrained)); __ptr } }; - let __ret: [G; OUT_409] = [__v_12, __v_45]; - if let Some(result) = record.function_queries[409].get_mut(&inp[..]) { debug_assert_eq!(result.output, &__ret[..]); if !unconstrained { *result.multiplicity += G::ONE; } } else { record.function_queries[409].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained)); }; + let __ret: [G; OUT_405] = [__v_12, __v_45]; + if let Some(result) = record.function_queries[405].get_mut(&inp[..]) { debug_assert_eq!(result.output, &__ret[..]); if !unconstrained { *result.multiplicity += G::ONE; } } else { record.function_queries[405].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained)); }; return Ok(__ret); }, } @@ -36936,8 +36662,8 @@ fn aiur_fn_409( let __v_37: G = G::from_u64(0); let __v_38: G = G::from_u64(0); let __v_39: G = { let __values: [G; 32] = [__v_7, __v_8, __v_9, __v_10, __v_11, __v_12, __v_13, __v_14, __v_15, __v_16, __v_17, __v_18, __v_19, __v_20, __v_21, __v_22, __v_23, __v_24, __v_25, __v_26, __v_27, __v_28, __v_29, __v_30, __v_31, __v_32, __v_33, __v_34, __v_35, __v_36, __v_37, __v_38]; let __mq = record.memory_queries.get_mut(&32).ok_or(ExecError::InvalidMemorySize(32))?; if let Some(result) = __mq.get_mut(&__values[..]) { if !unconstrained { *result.multiplicity += G::ONE; } result.output[0] } else { let __ptr = G::from_usize(__mq.len()); __mq.insert(&__values[..], &[__ptr], G::from_bool(!unconstrained)); __ptr } }; - let __ret: [G; OUT_409] = [__v_6, __v_39]; - if let Some(result) = record.function_queries[409].get_mut(&inp[..]) { debug_assert_eq!(result.output, &__ret[..]); if !unconstrained { *result.multiplicity += G::ONE; } } else { record.function_queries[409].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained)); }; + let __ret: [G; OUT_405] = [__v_6, __v_39]; + if let Some(result) = record.function_queries[405].get_mut(&inp[..]) { debug_assert_eq!(result.output, &__ret[..]); if !unconstrained { *result.multiplicity += G::ONE; } } else { record.function_queries[405].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained)); }; return Ok(__ret); }, } @@ -36952,11 +36678,11 @@ fn aiur_fn_409( 5u64 => { let __v_6: G = G::from_u64(1); let __v_7: G = (__v_1 - __v_6); - let __r_arr: [G; OUT_409] = { let __args: [G; IN_409] = [__v_4, __v_7]; let __cu = unconstrained; if let Some(result) = record.function_queries[409].get_mut(&__args[..]) { if !__cu && *result.multiplicity == G::ZERO { aiur_fn_409(__args, record, io_buffer, false)? } else { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_409] = unsafe { *(result.output.as_ptr() as *const [G; OUT_409]) }; __ret } } else { aiur_fn_409(__args, record, io_buffer, __cu)? } }; + let __r_arr: [G; OUT_405] = { let __args: [G; IN_405] = [__v_4, __v_7]; let __cu = unconstrained; if let Some(result) = record.function_queries[405].get_mut(&__args[..]) { if !__cu && *result.multiplicity == G::ZERO { aiur_fn_405(__args, record, io_buffer, false)? } else { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_405] = unsafe { *(result.output.as_ptr() as *const [G; OUT_405]) }; __ret } } else { aiur_fn_405(__args, record, io_buffer, __cu)? } }; let __v_8: G = __r_arr[0]; let __v_9: G = __r_arr[1]; - let __ret: [G; OUT_409] = [__v_8, __v_9]; - if let Some(result) = record.function_queries[409].get_mut(&inp[..]) { debug_assert_eq!(result.output, &__ret[..]); if !unconstrained { *result.multiplicity += G::ONE; } } else { record.function_queries[409].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained)); }; + let __ret: [G; OUT_405] = [__v_8, __v_9]; + if let Some(result) = record.function_queries[405].get_mut(&inp[..]) { debug_assert_eq!(result.output, &__ret[..]); if !unconstrained { *result.multiplicity += G::ONE; } } else { record.function_queries[405].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained)); }; return Ok(__ret); }, _ => { @@ -36994,8 +36720,8 @@ fn aiur_fn_409( let __v_37: G = G::from_u64(0); let __v_38: G = G::from_u64(0); let __v_39: G = { let __values: [G; 32] = [__v_7, __v_8, __v_9, __v_10, __v_11, __v_12, __v_13, __v_14, __v_15, __v_16, __v_17, __v_18, __v_19, __v_20, __v_21, __v_22, __v_23, __v_24, __v_25, __v_26, __v_27, __v_28, __v_29, __v_30, __v_31, __v_32, __v_33, __v_34, __v_35, __v_36, __v_37, __v_38]; let __mq = record.memory_queries.get_mut(&32).ok_or(ExecError::InvalidMemorySize(32))?; if let Some(result) = __mq.get_mut(&__values[..]) { if !unconstrained { *result.multiplicity += G::ONE; } result.output[0] } else { let __ptr = G::from_usize(__mq.len()); __mq.insert(&__values[..], &[__ptr], G::from_bool(!unconstrained)); __ptr } }; - let __ret: [G; OUT_409] = [__v_6, __v_39]; - if let Some(result) = record.function_queries[409].get_mut(&inp[..]) { debug_assert_eq!(result.output, &__ret[..]); if !unconstrained { *result.multiplicity += G::ONE; } } else { record.function_queries[409].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained)); }; + let __ret: [G; OUT_405] = [__v_6, __v_39]; + if let Some(result) = record.function_queries[405].get_mut(&inp[..]) { debug_assert_eq!(result.output, &__ret[..]); if !unconstrained { *result.multiplicity += G::ONE; } } else { record.function_queries[405].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained)); }; return Ok(__ret); }, } @@ -37004,15 +36730,15 @@ fn aiur_fn_409( }) } -const INPUT_SIZE_410: usize = 5; -const IN_410: usize = 5; -const OUT_410: usize = 1; -fn aiur_fn_410( - inp: [G; IN_410], +const INPUT_SIZE_406: usize = 5; +const IN_406: usize = 5; +const OUT_406: usize = 1; +fn aiur_fn_406( + inp: [G; IN_406], record: &mut QueryRecord, io_buffer: &mut IOBuffer, unconstrained: bool, -) -> Result<[G; OUT_410], ExecError> { +) -> Result<[G; OUT_406], ExecError> { stacker::maybe_grow(64 * 1024, 4 * 1024 * 1024, || { let __v_0: G = inp[0]; let __v_1: G = inp[1]; @@ -37022,8 +36748,8 @@ fn aiur_fn_410( let __v_5: G = (__v_3 - __v_4); match __v_5.as_canonical_u64() { 0u64 => { - let __ret: [G; OUT_410] = [__v_0]; - if let Some(result) = record.function_queries[410].get_mut(&inp[..]) { debug_assert_eq!(result.output, &__ret[..]); if !unconstrained { *result.multiplicity += G::ONE; } } else { record.function_queries[410].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained)); }; + let __ret: [G; OUT_406] = [__v_0]; + if let Some(result) = record.function_queries[406].get_mut(&inp[..]) { debug_assert_eq!(result.output, &__ret[..]); if !unconstrained { *result.multiplicity += G::ONE; } } else { record.function_queries[406].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained)); }; return Ok(__ret); }, _ => { @@ -37034,28 +36760,28 @@ fn aiur_fn_410( let __v_10: G = { let __values: [G; 4] = [__v_8, __v_0, __v_7, __v_9]; let __mq = record.memory_queries.get_mut(&4).ok_or(ExecError::InvalidMemorySize(4))?; if let Some(result) = __mq.get_mut(&__values[..]) { if !unconstrained { *result.multiplicity += G::ONE; } result.output[0] } else { let __ptr = G::from_usize(__mq.len()); __mq.insert(&__values[..], &[__ptr], G::from_bool(!unconstrained)); __ptr } }; let __v_11: G = G::from_u64(1); let __v_12: G = (__v_4 + __v_11); - let __r_arr: [G; OUT_410] = { let __args: [G; IN_410] = [__v_10, __v_1, __v_2, __v_3, __v_12]; let __cu = unconstrained; if let Some(result) = record.function_queries[410].get_mut(&__args[..]) { if !__cu && *result.multiplicity == G::ZERO { aiur_fn_410(__args, record, io_buffer, false)? } else { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_410] = unsafe { *(result.output.as_ptr() as *const [G; OUT_410]) }; __ret } } else { aiur_fn_410(__args, record, io_buffer, __cu)? } }; + let __r_arr: [G; OUT_406] = { let __args: [G; IN_406] = [__v_10, __v_1, __v_2, __v_3, __v_12]; let __cu = unconstrained; if let Some(result) = record.function_queries[406].get_mut(&__args[..]) { if !__cu && *result.multiplicity == G::ZERO { aiur_fn_406(__args, record, io_buffer, false)? } else { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_406] = unsafe { *(result.output.as_ptr() as *const [G; OUT_406]) }; __ret } } else { aiur_fn_406(__args, record, io_buffer, __cu)? } }; let __v_13: G = __r_arr[0]; - let __ret: [G; OUT_410] = [__v_13]; - if let Some(result) = record.function_queries[410].get_mut(&inp[..]) { debug_assert_eq!(result.output, &__ret[..]); if !unconstrained { *result.multiplicity += G::ONE; } } else { record.function_queries[410].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained)); }; + let __ret: [G; OUT_406] = [__v_13]; + if let Some(result) = record.function_queries[406].get_mut(&inp[..]) { debug_assert_eq!(result.output, &__ret[..]); if !unconstrained { *result.multiplicity += G::ONE; } } else { record.function_queries[406].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained)); }; return Ok(__ret); }, } }) } -const INPUT_SIZE_411: usize = 1; -const IN_411: usize = 1; -const OUT_411: usize = 1; -fn aiur_fn_411( - inp: [G; IN_411], +const INPUT_SIZE_407: usize = 1; +const IN_407: usize = 1; +const OUT_407: usize = 1; +fn aiur_fn_407( + inp: [G; IN_407], record: &mut QueryRecord, io_buffer: &mut IOBuffer, unconstrained: bool, -) -> Result<[G; OUT_411], ExecError> { +) -> Result<[G; OUT_407], ExecError> { stacker::maybe_grow(64 * 1024, 4 * 1024 * 1024, || { let __v_0: G = inp[0]; - let __r_arr: [G; OUT_287] = { let __args: [G; IN_287] = [__v_0]; let __cu = unconstrained; if let Some(result) = record.function_queries[287].get_mut(&__args[..]) { if !__cu && *result.multiplicity == G::ZERO { aiur_fn_287(__args, record, io_buffer, false)? } else { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_287] = unsafe { *(result.output.as_ptr() as *const [G; OUT_287]) }; __ret } } else { aiur_fn_287(__args, record, io_buffer, __cu)? } }; + let __r_arr: [G; OUT_283] = { let __args: [G; IN_283] = [__v_0]; let __cu = unconstrained; if let Some(result) = record.function_queries[283].get_mut(&__args[..]) { if !__cu && *result.multiplicity == G::ZERO { aiur_fn_283(__args, record, io_buffer, false)? } else { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_283] = unsafe { *(result.output.as_ptr() as *const [G; OUT_283]) }; __ret } } else { aiur_fn_283(__args, record, io_buffer, __cu)? } }; let __v_1: G = __r_arr[0]; let __loaded: [G; 12] = { let __mq = record.memory_queries.get_mut(&12).ok_or(ExecError::InvalidMemorySize(12))?; let __ptr_u64 = __v_1.as_canonical_u64(); let __ptr_usize = usize::try_from(__ptr_u64).ok().ok_or(ExecError::PointerTooLarge(__ptr_u64))?; let (__args, __mult) = __mq.get_index_mut(__ptr_usize).ok_or(ExecError::UnboundPointer { ptr: __ptr_u64, size: 12 })?; if !unconstrained { *__mult += G::ONE; } let __arr: [G; 12] = __args[..12].try_into().unwrap(); __arr }; let __v_2: G = __loaded[0]; @@ -37072,38 +36798,38 @@ fn aiur_fn_411( let __v_13: G = __loaded[11]; match __v_2.as_canonical_u64() { 5u64 => { - let __r_arr: [G; OUT_412] = { let __args: [G; IN_412] = [__v_0, __v_9]; let __cu = unconstrained; if let Some(result) = record.function_queries[412].get_mut(&__args[..]) { if !__cu && *result.multiplicity == G::ZERO { aiur_fn_412(__args, record, io_buffer, false)? } else { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_412] = unsafe { *(result.output.as_ptr() as *const [G; OUT_412]) }; __ret } } else { aiur_fn_412(__args, record, io_buffer, __cu)? } }; + let __r_arr: [G; OUT_408] = { let __args: [G; IN_408] = [__v_0, __v_9]; let __cu = unconstrained; if let Some(result) = record.function_queries[408].get_mut(&__args[..]) { if !__cu && *result.multiplicity == G::ZERO { aiur_fn_408(__args, record, io_buffer, false)? } else { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_408] = unsafe { *(result.output.as_ptr() as *const [G; OUT_408]) }; __ret } } else { aiur_fn_408(__args, record, io_buffer, __cu)? } }; let __v_14: G = __r_arr[0]; let __v_15: G = G::from_u64(0); - let __r_arr: [G; OUT_413] = { let __args: [G; IN_413] = [__v_9, __v_10, __v_7, __v_5, __v_14, __v_15]; let __cu = unconstrained; if let Some(result) = record.function_queries[413].get_mut(&__args[..]) { if !__cu && *result.multiplicity == G::ZERO { aiur_fn_413(__args, record, io_buffer, false)? } else { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_413] = unsafe { *(result.output.as_ptr() as *const [G; OUT_413]) }; __ret } } else { aiur_fn_413(__args, record, io_buffer, __cu)? } }; + let __r_arr: [G; OUT_409] = { let __args: [G; IN_409] = [__v_9, __v_10, __v_7, __v_5, __v_14, __v_15]; let __cu = unconstrained; if let Some(result) = record.function_queries[409].get_mut(&__args[..]) { if !__cu && *result.multiplicity == G::ZERO { aiur_fn_409(__args, record, io_buffer, false)? } else { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_409] = unsafe { *(result.output.as_ptr() as *const [G; OUT_409]) }; __ret } } else { aiur_fn_409(__args, record, io_buffer, __cu)? } }; let __v_16: G = __r_arr[0]; - let __ret: [G; OUT_411] = [__v_16]; - if let Some(result) = record.function_queries[411].get_mut(&inp[..]) { debug_assert_eq!(result.output, &__ret[..]); if !unconstrained { *result.multiplicity += G::ONE; } } else { record.function_queries[411].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained)); }; + let __ret: [G; OUT_407] = [__v_16]; + if let Some(result) = record.function_queries[407].get_mut(&inp[..]) { debug_assert_eq!(result.output, &__ret[..]); if !unconstrained { *result.multiplicity += G::ONE; } } else { record.function_queries[407].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained)); }; return Ok(__ret); }, _ => { let __v_14: G = G::from_u64(1); - let __ret: [G; OUT_411] = [__v_14]; - if let Some(result) = record.function_queries[411].get_mut(&inp[..]) { debug_assert_eq!(result.output, &__ret[..]); if !unconstrained { *result.multiplicity += G::ONE; } } else { record.function_queries[411].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained)); }; + let __ret: [G; OUT_407] = [__v_14]; + if let Some(result) = record.function_queries[407].get_mut(&inp[..]) { debug_assert_eq!(result.output, &__ret[..]); if !unconstrained { *result.multiplicity += G::ONE; } } else { record.function_queries[407].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained)); }; return Ok(__ret); }, } }) } -const INPUT_SIZE_412: usize = 2; -const IN_412: usize = 2; -const OUT_412: usize = 1; -fn aiur_fn_412( - inp: [G; IN_412], +const INPUT_SIZE_408: usize = 2; +const IN_408: usize = 2; +const OUT_408: usize = 1; +fn aiur_fn_408( + inp: [G; IN_408], record: &mut QueryRecord, io_buffer: &mut IOBuffer, unconstrained: bool, -) -> Result<[G; OUT_412], ExecError> { +) -> Result<[G; OUT_408], ExecError> { stacker::maybe_grow(64 * 1024, 4 * 1024 * 1024, || { let __v_0: G = inp[0]; let __v_1: G = inp[1]; - let __r_arr: [G; OUT_282] = { let __args: [G; IN_282] = [__v_1]; let __cu = unconstrained; if let Some(result) = record.function_queries[282].get_mut(&__args[..]) { if !__cu && *result.multiplicity == G::ZERO { aiur_fn_282(__args, record, io_buffer, false)? } else { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_282] = unsafe { *(result.output.as_ptr() as *const [G; OUT_282]) }; __ret } } else { aiur_fn_282(__args, record, io_buffer, __cu)? } }; + let __r_arr: [G; OUT_278] = { let __args: [G; IN_278] = [__v_1]; let __cu = unconstrained; if let Some(result) = record.function_queries[278].get_mut(&__args[..]) { if !__cu && *result.multiplicity == G::ZERO { aiur_fn_278(__args, record, io_buffer, false)? } else { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_278] = unsafe { *(result.output.as_ptr() as *const [G; OUT_278]) }; __ret } } else { aiur_fn_278(__args, record, io_buffer, __cu)? } }; let __v_2: G = __r_arr[0]; let __v_3: G = __r_arr[1]; let __v_4: G = __r_arr[2]; @@ -37156,10 +36882,10 @@ fn aiur_fn_412( _ => { match __v_2.as_canonical_u64() { 8u64 => { - let __r_arr: [G; OUT_295] = { let __args: [G; IN_295] = [__v_3, __v_1]; let __cu = unconstrained; if let Some(result) = record.function_queries[295].get_mut(&__args[..]) { if !__cu && *result.multiplicity == G::ZERO { aiur_fn_295(__args, record, io_buffer, false)? } else { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_295] = unsafe { *(result.output.as_ptr() as *const [G; OUT_295]) }; __ret } } else { aiur_fn_295(__args, record, io_buffer, __cu)? } }; + let __r_arr: [G; OUT_291] = { let __args: [G; IN_291] = [__v_3, __v_1]; let __cu = unconstrained; if let Some(result) = record.function_queries[291].get_mut(&__args[..]) { if !__cu && *result.multiplicity == G::ZERO { aiur_fn_291(__args, record, io_buffer, false)? } else { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_291] = unsafe { *(result.output.as_ptr() as *const [G; OUT_291]) }; __ret } } else { aiur_fn_291(__args, record, io_buffer, __cu)? } }; let __v_50: G = __r_arr[0]; - let __ret: [G; OUT_412] = [__v_50]; - if let Some(result) = record.function_queries[412].get_mut(&inp[..]) { debug_assert_eq!(result.output, &__ret[..]); if !unconstrained { *result.multiplicity += G::ONE; } } else { record.function_queries[412].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained)); }; + let __ret: [G; OUT_408] = [__v_50]; + if let Some(result) = record.function_queries[408].get_mut(&inp[..]) { debug_assert_eq!(result.output, &__ret[..]); if !unconstrained { *result.multiplicity += G::ONE; } } else { record.function_queries[408].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained)); }; return Ok(__ret); }, _ => { @@ -37168,8 +36894,8 @@ fn aiur_fn_412( let __v_52: G = G::from_u64(1); let __v_53: G = { let __values: [G; 3] = [__v_51, __v_52, __v_52]; let __mq = record.memory_queries.get_mut(&3).ok_or(ExecError::InvalidMemorySize(3))?; if let Some(result) = __mq.get_mut(&__values[..]) { if !unconstrained { *result.multiplicity += G::ONE; } result.output[0] } else { let __ptr = G::from_usize(__mq.len()); __mq.insert(&__values[..], &[__ptr], G::from_bool(!unconstrained)); __ptr } }; let __v_54: G = { let __values: [G; 3] = [__v_50, __v_0, __v_53]; let __mq = record.memory_queries.get_mut(&3).ok_or(ExecError::InvalidMemorySize(3))?; if let Some(result) = __mq.get_mut(&__values[..]) { if !unconstrained { *result.multiplicity += G::ONE; } result.output[0] } else { let __ptr = G::from_usize(__mq.len()); __mq.insert(&__values[..], &[__ptr], G::from_bool(!unconstrained)); __ptr } }; - let __ret: [G; OUT_412] = [__v_54]; - if let Some(result) = record.function_queries[412].get_mut(&inp[..]) { debug_assert_eq!(result.output, &__ret[..]); if !unconstrained { *result.multiplicity += G::ONE; } } else { record.function_queries[412].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained)); }; + let __ret: [G; OUT_408] = [__v_54]; + if let Some(result) = record.function_queries[408].get_mut(&inp[..]) { debug_assert_eq!(result.output, &__ret[..]); if !unconstrained { *result.multiplicity += G::ONE; } } else { record.function_queries[408].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained)); }; return Ok(__ret); }, } @@ -37178,15 +36904,15 @@ fn aiur_fn_412( }) } -const INPUT_SIZE_413: usize = 6; -const IN_413: usize = 6; -const OUT_413: usize = 1; -fn aiur_fn_413( - inp: [G; IN_413], +const INPUT_SIZE_409: usize = 6; +const IN_409: usize = 6; +const OUT_409: usize = 1; +fn aiur_fn_409( + inp: [G; IN_409], record: &mut QueryRecord, io_buffer: &mut IOBuffer, unconstrained: bool, -) -> Result<[G; OUT_413], ExecError> { +) -> Result<[G; OUT_409], ExecError> { stacker::maybe_grow(64 * 1024, 4 * 1024 * 1024, || { let __v_0: G = inp[0]; let __v_1: G = inp[1]; @@ -37198,12 +36924,12 @@ fn aiur_fn_413( match __v_6.as_canonical_u64() { 0u64 => { let __v_7: G = G::from_u64(0); - let __ret: [G; OUT_413] = [__v_7]; - if let Some(result) = record.function_queries[413].get_mut(&inp[..]) { debug_assert_eq!(result.output, &__ret[..]); if !unconstrained { *result.multiplicity += G::ONE; } } else { record.function_queries[413].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained)); }; + let __ret: [G; OUT_409] = [__v_7]; + if let Some(result) = record.function_queries[409].get_mut(&inp[..]) { debug_assert_eq!(result.output, &__ret[..]); if !unconstrained { *result.multiplicity += G::ONE; } } else { record.function_queries[409].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained)); }; return Ok(__ret); }, _ => { - let __r_arr: [G; OUT_290] = { let __args: [G; IN_290] = [__v_0, __v_1, __v_5]; let __cu = unconstrained; if let Some(result) = record.function_queries[290].get_mut(&__args[..]) { if !__cu && *result.multiplicity == G::ZERO { aiur_fn_290(__args, record, io_buffer, false)? } else { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_290] = unsafe { *(result.output.as_ptr() as *const [G; OUT_290]) }; __ret } } else { aiur_fn_290(__args, record, io_buffer, __cu)? } }; + let __r_arr: [G; OUT_286] = { let __args: [G; IN_286] = [__v_0, __v_1, __v_5]; let __cu = unconstrained; if let Some(result) = record.function_queries[286].get_mut(&__args[..]) { if !__cu && *result.multiplicity == G::ZERO { aiur_fn_286(__args, record, io_buffer, false)? } else { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_286] = unsafe { *(result.output.as_ptr() as *const [G; OUT_286]) }; __ret } } else { aiur_fn_286(__args, record, io_buffer, __cu)? } }; let __v_7: G = __r_arr[0]; let __loaded: [G; 12] = { let __mq = record.memory_queries.get_mut(&12).ok_or(ExecError::InvalidMemorySize(12))?; let __ptr_u64 = __v_7.as_canonical_u64(); let __ptr_usize = usize::try_from(__ptr_u64).ok().ok_or(ExecError::PointerTooLarge(__ptr_u64))?; let (__args, __mult) = __mq.get_index_mut(__ptr_usize).ok_or(ExecError::UnboundPointer { ptr: __ptr_u64, size: 12 })?; if !unconstrained { *__mult += G::ONE; } let __arr: [G; 12] = __args[..12].try_into().unwrap(); __arr }; let __v_8: G = __loaded[0]; @@ -37220,32 +36946,32 @@ fn aiur_fn_413( let __v_19: G = __loaded[11]; match __v_8.as_canonical_u64() { 6u64 => { - let __r_arr: [G; OUT_414] = { let __args: [G; IN_414] = [__v_10, __v_3]; let __cu = unconstrained; if let Some(result) = record.function_queries[414].get_mut(&__args[..]) { if !__cu && *result.multiplicity == G::ZERO { aiur_fn_414(__args, record, io_buffer, false)? } else { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_414] = unsafe { *(result.output.as_ptr() as *const [G; OUT_414]) }; __ret } } else { aiur_fn_414(__args, record, io_buffer, __cu)? } }; + let __r_arr: [G; OUT_410] = { let __args: [G; IN_410] = [__v_10, __v_3]; let __cu = unconstrained; if let Some(result) = record.function_queries[410].get_mut(&__args[..]) { if !__cu && *result.multiplicity == G::ZERO { aiur_fn_410(__args, record, io_buffer, false)? } else { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_410] = unsafe { *(result.output.as_ptr() as *const [G; OUT_410]) }; __ret } } else { aiur_fn_410(__args, record, io_buffer, __cu)? } }; let __v_20: G = __r_arr[0]; - let __r_arr: [G; OUT_415] = { let __args: [G; IN_415] = [__v_20, __v_4]; let __cu = unconstrained; if let Some(result) = record.function_queries[415].get_mut(&__args[..]) { if !__cu && *result.multiplicity == G::ZERO { aiur_fn_415(__args, record, io_buffer, false)? } else { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_415] = unsafe { *(result.output.as_ptr() as *const [G; OUT_415]) }; __ret } } else { aiur_fn_415(__args, record, io_buffer, __cu)? } }; + let __r_arr: [G; OUT_411] = { let __args: [G; IN_411] = [__v_20, __v_4]; let __cu = unconstrained; if let Some(result) = record.function_queries[411].get_mut(&__args[..]) { if !__cu && *result.multiplicity == G::ZERO { aiur_fn_411(__args, record, io_buffer, false)? } else { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_411] = unsafe { *(result.output.as_ptr() as *const [G; OUT_411]) }; __ret } } else { aiur_fn_411(__args, record, io_buffer, __cu)? } }; let __v_21: G = __r_arr[0]; match __v_21.as_canonical_u64() { 1u64 => { let __v_22: G = G::from_u64(1); - let __ret: [G; OUT_413] = [__v_22]; - if let Some(result) = record.function_queries[413].get_mut(&inp[..]) { debug_assert_eq!(result.output, &__ret[..]); if !unconstrained { *result.multiplicity += G::ONE; } } else { record.function_queries[413].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained)); }; + let __ret: [G; OUT_409] = [__v_22]; + if let Some(result) = record.function_queries[409].get_mut(&inp[..]) { debug_assert_eq!(result.output, &__ret[..]); if !unconstrained { *result.multiplicity += G::ONE; } } else { record.function_queries[409].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained)); }; return Ok(__ret); }, _ => { let __v_22: G = G::from_u64(1); let __v_23: G = (__v_5 + __v_22); - let __r_arr: [G; OUT_413] = { let __args: [G; IN_413] = [__v_0, __v_1, __v_2, __v_3, __v_4, __v_23]; let __cu = unconstrained; if let Some(result) = record.function_queries[413].get_mut(&__args[..]) { if !__cu && *result.multiplicity == G::ZERO { aiur_fn_413(__args, record, io_buffer, false)? } else { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_413] = unsafe { *(result.output.as_ptr() as *const [G; OUT_413]) }; __ret } } else { aiur_fn_413(__args, record, io_buffer, __cu)? } }; + let __r_arr: [G; OUT_409] = { let __args: [G; IN_409] = [__v_0, __v_1, __v_2, __v_3, __v_4, __v_23]; let __cu = unconstrained; if let Some(result) = record.function_queries[409].get_mut(&__args[..]) { if !__cu && *result.multiplicity == G::ZERO { aiur_fn_409(__args, record, io_buffer, false)? } else { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_409] = unsafe { *(result.output.as_ptr() as *const [G; OUT_409]) }; __ret } } else { aiur_fn_409(__args, record, io_buffer, __cu)? } }; let __v_24: G = __r_arr[0]; - let __ret: [G; OUT_413] = [__v_24]; - if let Some(result) = record.function_queries[413].get_mut(&inp[..]) { debug_assert_eq!(result.output, &__ret[..]); if !unconstrained { *result.multiplicity += G::ONE; } } else { record.function_queries[413].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained)); }; + let __ret: [G; OUT_409] = [__v_24]; + if let Some(result) = record.function_queries[409].get_mut(&inp[..]) { debug_assert_eq!(result.output, &__ret[..]); if !unconstrained { *result.multiplicity += G::ONE; } } else { record.function_queries[409].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained)); }; return Ok(__ret); }, } }, _ => { let __v_20: G = G::from_u64(1); - let __ret: [G; OUT_413] = [__v_20]; - if let Some(result) = record.function_queries[413].get_mut(&inp[..]) { debug_assert_eq!(result.output, &__ret[..]); if !unconstrained { *result.multiplicity += G::ONE; } } else { record.function_queries[413].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained)); }; + let __ret: [G; OUT_409] = [__v_20]; + if let Some(result) = record.function_queries[409].get_mut(&inp[..]) { debug_assert_eq!(result.output, &__ret[..]); if !unconstrained { *result.multiplicity += G::ONE; } } else { record.function_queries[409].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained)); }; return Ok(__ret); }, } @@ -37254,22 +36980,22 @@ fn aiur_fn_413( }) } -const INPUT_SIZE_414: usize = 2; -const IN_414: usize = 2; -const OUT_414: usize = 1; -fn aiur_fn_414( - inp: [G; IN_414], +const INPUT_SIZE_410: usize = 2; +const IN_410: usize = 2; +const OUT_410: usize = 1; +fn aiur_fn_410( + inp: [G; IN_410], record: &mut QueryRecord, io_buffer: &mut IOBuffer, unconstrained: bool, -) -> Result<[G; OUT_414], ExecError> { +) -> Result<[G; OUT_410], ExecError> { stacker::maybe_grow(64 * 1024, 4 * 1024 * 1024, || { let __v_0: G = inp[0]; let __v_1: G = inp[1]; match __v_1.as_canonical_u64() { 0u64 => { - let __ret: [G; OUT_414] = [__v_0]; - if let Some(result) = record.function_queries[414].get_mut(&inp[..]) { debug_assert_eq!(result.output, &__ret[..]); if !unconstrained { *result.multiplicity += G::ONE; } } else { record.function_queries[414].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained)); }; + let __ret: [G; OUT_410] = [__v_0]; + if let Some(result) = record.function_queries[410].get_mut(&inp[..]) { debug_assert_eq!(result.output, &__ret[..]); if !unconstrained { *result.multiplicity += G::ONE; } } else { record.function_queries[410].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained)); }; return Ok(__ret); }, _ => { @@ -37282,15 +37008,15 @@ fn aiur_fn_414( 5u64 => { let __v_6: G = G::from_u64(1); let __v_7: G = (__v_1 - __v_6); - let __r_arr: [G; OUT_414] = { let __args: [G; IN_414] = [__v_4, __v_7]; let __cu = unconstrained; if let Some(result) = record.function_queries[414].get_mut(&__args[..]) { if !__cu && *result.multiplicity == G::ZERO { aiur_fn_414(__args, record, io_buffer, false)? } else { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_414] = unsafe { *(result.output.as_ptr() as *const [G; OUT_414]) }; __ret } } else { aiur_fn_414(__args, record, io_buffer, __cu)? } }; + let __r_arr: [G; OUT_410] = { let __args: [G; IN_410] = [__v_4, __v_7]; let __cu = unconstrained; if let Some(result) = record.function_queries[410].get_mut(&__args[..]) { if !__cu && *result.multiplicity == G::ZERO { aiur_fn_410(__args, record, io_buffer, false)? } else { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_410] = unsafe { *(result.output.as_ptr() as *const [G; OUT_410]) }; __ret } } else { aiur_fn_410(__args, record, io_buffer, __cu)? } }; let __v_8: G = __r_arr[0]; - let __ret: [G; OUT_414] = [__v_8]; - if let Some(result) = record.function_queries[414].get_mut(&inp[..]) { debug_assert_eq!(result.output, &__ret[..]); if !unconstrained { *result.multiplicity += G::ONE; } } else { record.function_queries[414].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained)); }; + let __ret: [G; OUT_410] = [__v_8]; + if let Some(result) = record.function_queries[410].get_mut(&inp[..]) { debug_assert_eq!(result.output, &__ret[..]); if !unconstrained { *result.multiplicity += G::ONE; } } else { record.function_queries[410].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained)); }; return Ok(__ret); }, _ => { - let __ret: [G; OUT_414] = [__v_0]; - if let Some(result) = record.function_queries[414].get_mut(&inp[..]) { debug_assert_eq!(result.output, &__ret[..]); if !unconstrained { *result.multiplicity += G::ONE; } } else { record.function_queries[414].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained)); }; + let __ret: [G; OUT_410] = [__v_0]; + if let Some(result) = record.function_queries[410].get_mut(&inp[..]) { debug_assert_eq!(result.output, &__ret[..]); if !unconstrained { *result.multiplicity += G::ONE; } } else { record.function_queries[410].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained)); }; return Ok(__ret); }, } @@ -37299,15 +37025,15 @@ fn aiur_fn_414( }) } -const INPUT_SIZE_415: usize = 2; -const IN_415: usize = 2; -const OUT_415: usize = 1; -fn aiur_fn_415( - inp: [G; IN_415], +const INPUT_SIZE_411: usize = 2; +const IN_411: usize = 2; +const OUT_411: usize = 1; +fn aiur_fn_411( + inp: [G; IN_411], record: &mut QueryRecord, io_buffer: &mut IOBuffer, unconstrained: bool, -) -> Result<[G; OUT_415], ExecError> { +) -> Result<[G; OUT_411], ExecError> { stacker::maybe_grow(64 * 1024, 4 * 1024 * 1024, || { let __v_0: G = inp[0]; let __v_1: G = inp[1]; @@ -37318,43 +37044,43 @@ fn aiur_fn_415( let __v_5: G = __loaded[3]; match __v_2.as_canonical_u64() { 5u64 => { - let __r_arr: [G; OUT_416] = { let __args: [G; IN_416] = [__v_3, __v_1]; let __cu = unconstrained; if let Some(result) = record.function_queries[416].get_mut(&__args[..]) { if !__cu && *result.multiplicity == G::ZERO { aiur_fn_416(__args, record, io_buffer, false)? } else { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_416] = unsafe { *(result.output.as_ptr() as *const [G; OUT_416]) }; __ret } } else { aiur_fn_416(__args, record, io_buffer, __cu)? } }; + let __r_arr: [G; OUT_412] = { let __args: [G; IN_412] = [__v_3, __v_1]; let __cu = unconstrained; if let Some(result) = record.function_queries[412].get_mut(&__args[..]) { if !__cu && *result.multiplicity == G::ZERO { aiur_fn_412(__args, record, io_buffer, false)? } else { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_412] = unsafe { *(result.output.as_ptr() as *const [G; OUT_412]) }; __ret } } else { aiur_fn_412(__args, record, io_buffer, __cu)? } }; let __v_6: G = __r_arr[0]; match __v_6.as_canonical_u64() { 1u64 => { let __v_7: G = G::from_u64(1); - let __ret: [G; OUT_415] = [__v_7]; - if let Some(result) = record.function_queries[415].get_mut(&inp[..]) { debug_assert_eq!(result.output, &__ret[..]); if !unconstrained { *result.multiplicity += G::ONE; } } else { record.function_queries[415].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained)); }; + let __ret: [G; OUT_411] = [__v_7]; + if let Some(result) = record.function_queries[411].get_mut(&inp[..]) { debug_assert_eq!(result.output, &__ret[..]); if !unconstrained { *result.multiplicity += G::ONE; } } else { record.function_queries[411].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained)); }; return Ok(__ret); }, _ => { - let __r_arr: [G; OUT_415] = { let __args: [G; IN_415] = [__v_4, __v_1]; let __cu = unconstrained; if let Some(result) = record.function_queries[415].get_mut(&__args[..]) { if !__cu && *result.multiplicity == G::ZERO { aiur_fn_415(__args, record, io_buffer, false)? } else { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_415] = unsafe { *(result.output.as_ptr() as *const [G; OUT_415]) }; __ret } } else { aiur_fn_415(__args, record, io_buffer, __cu)? } }; + let __r_arr: [G; OUT_411] = { let __args: [G; IN_411] = [__v_4, __v_1]; let __cu = unconstrained; if let Some(result) = record.function_queries[411].get_mut(&__args[..]) { if !__cu && *result.multiplicity == G::ZERO { aiur_fn_411(__args, record, io_buffer, false)? } else { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_411] = unsafe { *(result.output.as_ptr() as *const [G; OUT_411]) }; __ret } } else { aiur_fn_411(__args, record, io_buffer, __cu)? } }; let __v_7: G = __r_arr[0]; - let __ret: [G; OUT_415] = [__v_7]; - if let Some(result) = record.function_queries[415].get_mut(&inp[..]) { debug_assert_eq!(result.output, &__ret[..]); if !unconstrained { *result.multiplicity += G::ONE; } } else { record.function_queries[415].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained)); }; + let __ret: [G; OUT_411] = [__v_7]; + if let Some(result) = record.function_queries[411].get_mut(&inp[..]) { debug_assert_eq!(result.output, &__ret[..]); if !unconstrained { *result.multiplicity += G::ONE; } } else { record.function_queries[411].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained)); }; return Ok(__ret); }, } }, _ => { let __v_6: G = G::from_u64(0); - let __ret: [G; OUT_415] = [__v_6]; - if let Some(result) = record.function_queries[415].get_mut(&inp[..]) { debug_assert_eq!(result.output, &__ret[..]); if !unconstrained { *result.multiplicity += G::ONE; } } else { record.function_queries[415].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained)); }; + let __ret: [G; OUT_411] = [__v_6]; + if let Some(result) = record.function_queries[411].get_mut(&inp[..]) { debug_assert_eq!(result.output, &__ret[..]); if !unconstrained { *result.multiplicity += G::ONE; } } else { record.function_queries[411].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained)); }; return Ok(__ret); }, } }) } -const INPUT_SIZE_416: usize = 2; -const IN_416: usize = 2; -const OUT_416: usize = 1; -fn aiur_fn_416( - inp: [G; IN_416], +const INPUT_SIZE_412: usize = 2; +const IN_412: usize = 2; +const OUT_412: usize = 1; +fn aiur_fn_412( + inp: [G; IN_412], record: &mut QueryRecord, io_buffer: &mut IOBuffer, unconstrained: bool, -) -> Result<[G; OUT_416], ExecError> { +) -> Result<[G; OUT_412], ExecError> { stacker::maybe_grow(64 * 1024, 4 * 1024 * 1024, || { let __v_0: G = inp[0]; let __v_1: G = inp[1]; @@ -37365,94 +37091,94 @@ fn aiur_fn_416( let __v_5: G = __loaded[3]; match __v_2.as_canonical_u64() { 2u64 => { - let __r_arr: [G; OUT_417] = { let __args: [G; IN_417] = [__v_3, __v_1]; let __cu = unconstrained; if let Some(result) = record.function_queries[417].get_mut(&__args[..]) { if !__cu && *result.multiplicity == G::ZERO { aiur_fn_417(__args, record, io_buffer, false)? } else { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_417] = unsafe { *(result.output.as_ptr() as *const [G; OUT_417]) }; __ret } } else { aiur_fn_417(__args, record, io_buffer, __cu)? } }; + let __r_arr: [G; OUT_413] = { let __args: [G; IN_413] = [__v_3, __v_1]; let __cu = unconstrained; if let Some(result) = record.function_queries[413].get_mut(&__args[..]) { if !__cu && *result.multiplicity == G::ZERO { aiur_fn_413(__args, record, io_buffer, false)? } else { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_413] = unsafe { *(result.output.as_ptr() as *const [G; OUT_413]) }; __ret } } else { aiur_fn_413(__args, record, io_buffer, __cu)? } }; let __v_6: G = __r_arr[0]; - let __ret: [G; OUT_416] = [__v_6]; - if let Some(result) = record.function_queries[416].get_mut(&inp[..]) { debug_assert_eq!(result.output, &__ret[..]); if !unconstrained { *result.multiplicity += G::ONE; } } else { record.function_queries[416].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained)); }; + let __ret: [G; OUT_412] = [__v_6]; + if let Some(result) = record.function_queries[412].get_mut(&inp[..]) { debug_assert_eq!(result.output, &__ret[..]); if !unconstrained { *result.multiplicity += G::ONE; } } else { record.function_queries[412].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained)); }; return Ok(__ret); }, 3u64 => { - let __r_arr: [G; OUT_416] = { let __args: [G; IN_416] = [__v_3, __v_1]; let __cu = unconstrained; if let Some(result) = record.function_queries[416].get_mut(&__args[..]) { if !__cu && *result.multiplicity == G::ZERO { aiur_fn_416(__args, record, io_buffer, false)? } else { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_416] = unsafe { *(result.output.as_ptr() as *const [G; OUT_416]) }; __ret } } else { aiur_fn_416(__args, record, io_buffer, __cu)? } }; + let __r_arr: [G; OUT_412] = { let __args: [G; IN_412] = [__v_3, __v_1]; let __cu = unconstrained; if let Some(result) = record.function_queries[412].get_mut(&__args[..]) { if !__cu && *result.multiplicity == G::ZERO { aiur_fn_412(__args, record, io_buffer, false)? } else { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_412] = unsafe { *(result.output.as_ptr() as *const [G; OUT_412]) }; __ret } } else { aiur_fn_412(__args, record, io_buffer, __cu)? } }; let __v_6: G = __r_arr[0]; match __v_6.as_canonical_u64() { 1u64 => { let __v_7: G = G::from_u64(1); - let __ret: [G; OUT_416] = [__v_7]; - if let Some(result) = record.function_queries[416].get_mut(&inp[..]) { debug_assert_eq!(result.output, &__ret[..]); if !unconstrained { *result.multiplicity += G::ONE; } } else { record.function_queries[416].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained)); }; + let __ret: [G; OUT_412] = [__v_7]; + if let Some(result) = record.function_queries[412].get_mut(&inp[..]) { debug_assert_eq!(result.output, &__ret[..]); if !unconstrained { *result.multiplicity += G::ONE; } } else { record.function_queries[412].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained)); }; return Ok(__ret); }, _ => { - let __r_arr: [G; OUT_416] = { let __args: [G; IN_416] = [__v_4, __v_1]; let __cu = unconstrained; if let Some(result) = record.function_queries[416].get_mut(&__args[..]) { if !__cu && *result.multiplicity == G::ZERO { aiur_fn_416(__args, record, io_buffer, false)? } else { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_416] = unsafe { *(result.output.as_ptr() as *const [G; OUT_416]) }; __ret } } else { aiur_fn_416(__args, record, io_buffer, __cu)? } }; + let __r_arr: [G; OUT_412] = { let __args: [G; IN_412] = [__v_4, __v_1]; let __cu = unconstrained; if let Some(result) = record.function_queries[412].get_mut(&__args[..]) { if !__cu && *result.multiplicity == G::ZERO { aiur_fn_412(__args, record, io_buffer, false)? } else { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_412] = unsafe { *(result.output.as_ptr() as *const [G; OUT_412]) }; __ret } } else { aiur_fn_412(__args, record, io_buffer, __cu)? } }; let __v_7: G = __r_arr[0]; - let __ret: [G; OUT_416] = [__v_7]; - if let Some(result) = record.function_queries[416].get_mut(&inp[..]) { debug_assert_eq!(result.output, &__ret[..]); if !unconstrained { *result.multiplicity += G::ONE; } } else { record.function_queries[416].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained)); }; + let __ret: [G; OUT_412] = [__v_7]; + if let Some(result) = record.function_queries[412].get_mut(&inp[..]) { debug_assert_eq!(result.output, &__ret[..]); if !unconstrained { *result.multiplicity += G::ONE; } } else { record.function_queries[412].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained)); }; return Ok(__ret); }, } }, 4u64 => { - let __r_arr: [G; OUT_416] = { let __args: [G; IN_416] = [__v_3, __v_1]; let __cu = unconstrained; if let Some(result) = record.function_queries[416].get_mut(&__args[..]) { if !__cu && *result.multiplicity == G::ZERO { aiur_fn_416(__args, record, io_buffer, false)? } else { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_416] = unsafe { *(result.output.as_ptr() as *const [G; OUT_416]) }; __ret } } else { aiur_fn_416(__args, record, io_buffer, __cu)? } }; + let __r_arr: [G; OUT_412] = { let __args: [G; IN_412] = [__v_3, __v_1]; let __cu = unconstrained; if let Some(result) = record.function_queries[412].get_mut(&__args[..]) { if !__cu && *result.multiplicity == G::ZERO { aiur_fn_412(__args, record, io_buffer, false)? } else { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_412] = unsafe { *(result.output.as_ptr() as *const [G; OUT_412]) }; __ret } } else { aiur_fn_412(__args, record, io_buffer, __cu)? } }; let __v_6: G = __r_arr[0]; match __v_6.as_canonical_u64() { 1u64 => { let __v_7: G = G::from_u64(1); - let __ret: [G; OUT_416] = [__v_7]; - if let Some(result) = record.function_queries[416].get_mut(&inp[..]) { debug_assert_eq!(result.output, &__ret[..]); if !unconstrained { *result.multiplicity += G::ONE; } } else { record.function_queries[416].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained)); }; + let __ret: [G; OUT_412] = [__v_7]; + if let Some(result) = record.function_queries[412].get_mut(&inp[..]) { debug_assert_eq!(result.output, &__ret[..]); if !unconstrained { *result.multiplicity += G::ONE; } } else { record.function_queries[412].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained)); }; return Ok(__ret); }, _ => { - let __r_arr: [G; OUT_416] = { let __args: [G; IN_416] = [__v_4, __v_1]; let __cu = unconstrained; if let Some(result) = record.function_queries[416].get_mut(&__args[..]) { if !__cu && *result.multiplicity == G::ZERO { aiur_fn_416(__args, record, io_buffer, false)? } else { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_416] = unsafe { *(result.output.as_ptr() as *const [G; OUT_416]) }; __ret } } else { aiur_fn_416(__args, record, io_buffer, __cu)? } }; + let __r_arr: [G; OUT_412] = { let __args: [G; IN_412] = [__v_4, __v_1]; let __cu = unconstrained; if let Some(result) = record.function_queries[412].get_mut(&__args[..]) { if !__cu && *result.multiplicity == G::ZERO { aiur_fn_412(__args, record, io_buffer, false)? } else { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_412] = unsafe { *(result.output.as_ptr() as *const [G; OUT_412]) }; __ret } } else { aiur_fn_412(__args, record, io_buffer, __cu)? } }; let __v_7: G = __r_arr[0]; - let __ret: [G; OUT_416] = [__v_7]; - if let Some(result) = record.function_queries[416].get_mut(&inp[..]) { debug_assert_eq!(result.output, &__ret[..]); if !unconstrained { *result.multiplicity += G::ONE; } } else { record.function_queries[416].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained)); }; + let __ret: [G; OUT_412] = [__v_7]; + if let Some(result) = record.function_queries[412].get_mut(&inp[..]) { debug_assert_eq!(result.output, &__ret[..]); if !unconstrained { *result.multiplicity += G::ONE; } } else { record.function_queries[412].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained)); }; return Ok(__ret); }, } }, 5u64 => { - let __r_arr: [G; OUT_416] = { let __args: [G; IN_416] = [__v_3, __v_1]; let __cu = unconstrained; if let Some(result) = record.function_queries[416].get_mut(&__args[..]) { if !__cu && *result.multiplicity == G::ZERO { aiur_fn_416(__args, record, io_buffer, false)? } else { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_416] = unsafe { *(result.output.as_ptr() as *const [G; OUT_416]) }; __ret } } else { aiur_fn_416(__args, record, io_buffer, __cu)? } }; + let __r_arr: [G; OUT_412] = { let __args: [G; IN_412] = [__v_3, __v_1]; let __cu = unconstrained; if let Some(result) = record.function_queries[412].get_mut(&__args[..]) { if !__cu && *result.multiplicity == G::ZERO { aiur_fn_412(__args, record, io_buffer, false)? } else { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_412] = unsafe { *(result.output.as_ptr() as *const [G; OUT_412]) }; __ret } } else { aiur_fn_412(__args, record, io_buffer, __cu)? } }; let __v_6: G = __r_arr[0]; match __v_6.as_canonical_u64() { 1u64 => { let __v_7: G = G::from_u64(1); - let __ret: [G; OUT_416] = [__v_7]; - if let Some(result) = record.function_queries[416].get_mut(&inp[..]) { debug_assert_eq!(result.output, &__ret[..]); if !unconstrained { *result.multiplicity += G::ONE; } } else { record.function_queries[416].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained)); }; + let __ret: [G; OUT_412] = [__v_7]; + if let Some(result) = record.function_queries[412].get_mut(&inp[..]) { debug_assert_eq!(result.output, &__ret[..]); if !unconstrained { *result.multiplicity += G::ONE; } } else { record.function_queries[412].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained)); }; return Ok(__ret); }, _ => { - let __r_arr: [G; OUT_416] = { let __args: [G; IN_416] = [__v_4, __v_1]; let __cu = unconstrained; if let Some(result) = record.function_queries[416].get_mut(&__args[..]) { if !__cu && *result.multiplicity == G::ZERO { aiur_fn_416(__args, record, io_buffer, false)? } else { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_416] = unsafe { *(result.output.as_ptr() as *const [G; OUT_416]) }; __ret } } else { aiur_fn_416(__args, record, io_buffer, __cu)? } }; + let __r_arr: [G; OUT_412] = { let __args: [G; IN_412] = [__v_4, __v_1]; let __cu = unconstrained; if let Some(result) = record.function_queries[412].get_mut(&__args[..]) { if !__cu && *result.multiplicity == G::ZERO { aiur_fn_412(__args, record, io_buffer, false)? } else { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_412] = unsafe { *(result.output.as_ptr() as *const [G; OUT_412]) }; __ret } } else { aiur_fn_412(__args, record, io_buffer, __cu)? } }; let __v_7: G = __r_arr[0]; - let __ret: [G; OUT_416] = [__v_7]; - if let Some(result) = record.function_queries[416].get_mut(&inp[..]) { debug_assert_eq!(result.output, &__ret[..]); if !unconstrained { *result.multiplicity += G::ONE; } } else { record.function_queries[416].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained)); }; + let __ret: [G; OUT_412] = [__v_7]; + if let Some(result) = record.function_queries[412].get_mut(&inp[..]) { debug_assert_eq!(result.output, &__ret[..]); if !unconstrained { *result.multiplicity += G::ONE; } } else { record.function_queries[412].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained)); }; return Ok(__ret); }, } }, 6u64 => { - let __r_arr: [G; OUT_416] = { let __args: [G; IN_416] = [__v_3, __v_1]; let __cu = unconstrained; if let Some(result) = record.function_queries[416].get_mut(&__args[..]) { if !__cu && *result.multiplicity == G::ZERO { aiur_fn_416(__args, record, io_buffer, false)? } else { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_416] = unsafe { *(result.output.as_ptr() as *const [G; OUT_416]) }; __ret } } else { aiur_fn_416(__args, record, io_buffer, __cu)? } }; + let __r_arr: [G; OUT_412] = { let __args: [G; IN_412] = [__v_3, __v_1]; let __cu = unconstrained; if let Some(result) = record.function_queries[412].get_mut(&__args[..]) { if !__cu && *result.multiplicity == G::ZERO { aiur_fn_412(__args, record, io_buffer, false)? } else { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_412] = unsafe { *(result.output.as_ptr() as *const [G; OUT_412]) }; __ret } } else { aiur_fn_412(__args, record, io_buffer, __cu)? } }; let __v_6: G = __r_arr[0]; match __v_6.as_canonical_u64() { 1u64 => { let __v_7: G = G::from_u64(1); - let __ret: [G; OUT_416] = [__v_7]; - if let Some(result) = record.function_queries[416].get_mut(&inp[..]) { debug_assert_eq!(result.output, &__ret[..]); if !unconstrained { *result.multiplicity += G::ONE; } } else { record.function_queries[416].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained)); }; + let __ret: [G; OUT_412] = [__v_7]; + if let Some(result) = record.function_queries[412].get_mut(&inp[..]) { debug_assert_eq!(result.output, &__ret[..]); if !unconstrained { *result.multiplicity += G::ONE; } } else { record.function_queries[412].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained)); }; return Ok(__ret); }, _ => { - let __r_arr: [G; OUT_416] = { let __args: [G; IN_416] = [__v_4, __v_1]; let __cu = unconstrained; if let Some(result) = record.function_queries[416].get_mut(&__args[..]) { if !__cu && *result.multiplicity == G::ZERO { aiur_fn_416(__args, record, io_buffer, false)? } else { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_416] = unsafe { *(result.output.as_ptr() as *const [G; OUT_416]) }; __ret } } else { aiur_fn_416(__args, record, io_buffer, __cu)? } }; + let __r_arr: [G; OUT_412] = { let __args: [G; IN_412] = [__v_4, __v_1]; let __cu = unconstrained; if let Some(result) = record.function_queries[412].get_mut(&__args[..]) { if !__cu && *result.multiplicity == G::ZERO { aiur_fn_412(__args, record, io_buffer, false)? } else { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_412] = unsafe { *(result.output.as_ptr() as *const [G; OUT_412]) }; __ret } } else { aiur_fn_412(__args, record, io_buffer, __cu)? } }; let __v_7: G = __r_arr[0]; match __v_7.as_canonical_u64() { 1u64 => { let __v_8: G = G::from_u64(1); - let __ret: [G; OUT_416] = [__v_8]; - if let Some(result) = record.function_queries[416].get_mut(&inp[..]) { debug_assert_eq!(result.output, &__ret[..]); if !unconstrained { *result.multiplicity += G::ONE; } } else { record.function_queries[416].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained)); }; + let __ret: [G; OUT_412] = [__v_8]; + if let Some(result) = record.function_queries[412].get_mut(&inp[..]) { debug_assert_eq!(result.output, &__ret[..]); if !unconstrained { *result.multiplicity += G::ONE; } } else { record.function_queries[412].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained)); }; return Ok(__ret); }, _ => { - let __r_arr: [G; OUT_416] = { let __args: [G; IN_416] = [__v_5, __v_1]; let __cu = unconstrained; if let Some(result) = record.function_queries[416].get_mut(&__args[..]) { if !__cu && *result.multiplicity == G::ZERO { aiur_fn_416(__args, record, io_buffer, false)? } else { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_416] = unsafe { *(result.output.as_ptr() as *const [G; OUT_416]) }; __ret } } else { aiur_fn_416(__args, record, io_buffer, __cu)? } }; + let __r_arr: [G; OUT_412] = { let __args: [G; IN_412] = [__v_5, __v_1]; let __cu = unconstrained; if let Some(result) = record.function_queries[412].get_mut(&__args[..]) { if !__cu && *result.multiplicity == G::ZERO { aiur_fn_412(__args, record, io_buffer, false)? } else { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_412] = unsafe { *(result.output.as_ptr() as *const [G; OUT_412]) }; __ret } } else { aiur_fn_412(__args, record, io_buffer, __cu)? } }; let __v_8: G = __r_arr[0]; - let __ret: [G; OUT_416] = [__v_8]; - if let Some(result) = record.function_queries[416].get_mut(&inp[..]) { debug_assert_eq!(result.output, &__ret[..]); if !unconstrained { *result.multiplicity += G::ONE; } } else { record.function_queries[416].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained)); }; + let __ret: [G; OUT_412] = [__v_8]; + if let Some(result) = record.function_queries[412].get_mut(&inp[..]) { debug_assert_eq!(result.output, &__ret[..]); if !unconstrained { *result.multiplicity += G::ONE; } } else { record.function_queries[412].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained)); }; return Ok(__ret); }, } @@ -37460,31 +37186,31 @@ fn aiur_fn_416( } }, 8u64 => { - let __r_arr: [G; OUT_416] = { let __args: [G; IN_416] = [__v_5, __v_1]; let __cu = unconstrained; if let Some(result) = record.function_queries[416].get_mut(&__args[..]) { if !__cu && *result.multiplicity == G::ZERO { aiur_fn_416(__args, record, io_buffer, false)? } else { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_416] = unsafe { *(result.output.as_ptr() as *const [G; OUT_416]) }; __ret } } else { aiur_fn_416(__args, record, io_buffer, __cu)? } }; + let __r_arr: [G; OUT_412] = { let __args: [G; IN_412] = [__v_5, __v_1]; let __cu = unconstrained; if let Some(result) = record.function_queries[412].get_mut(&__args[..]) { if !__cu && *result.multiplicity == G::ZERO { aiur_fn_412(__args, record, io_buffer, false)? } else { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_412] = unsafe { *(result.output.as_ptr() as *const [G; OUT_412]) }; __ret } } else { aiur_fn_412(__args, record, io_buffer, __cu)? } }; let __v_6: G = __r_arr[0]; - let __ret: [G; OUT_416] = [__v_6]; - if let Some(result) = record.function_queries[416].get_mut(&inp[..]) { debug_assert_eq!(result.output, &__ret[..]); if !unconstrained { *result.multiplicity += G::ONE; } } else { record.function_queries[416].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained)); }; + let __ret: [G; OUT_412] = [__v_6]; + if let Some(result) = record.function_queries[412].get_mut(&inp[..]) { debug_assert_eq!(result.output, &__ret[..]); if !unconstrained { *result.multiplicity += G::ONE; } } else { record.function_queries[412].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained)); }; return Ok(__ret); }, _ => { let __v_6: G = G::from_u64(0); - let __ret: [G; OUT_416] = [__v_6]; - if let Some(result) = record.function_queries[416].get_mut(&inp[..]) { debug_assert_eq!(result.output, &__ret[..]); if !unconstrained { *result.multiplicity += G::ONE; } } else { record.function_queries[416].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained)); }; + let __ret: [G; OUT_412] = [__v_6]; + if let Some(result) = record.function_queries[412].get_mut(&inp[..]) { debug_assert_eq!(result.output, &__ret[..]); if !unconstrained { *result.multiplicity += G::ONE; } } else { record.function_queries[412].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained)); }; return Ok(__ret); }, } }) } -const INPUT_SIZE_417: usize = 2; -const IN_417: usize = 2; -const OUT_417: usize = 1; -fn aiur_fn_417( - inp: [G; IN_417], +const INPUT_SIZE_413: usize = 2; +const IN_413: usize = 2; +const OUT_413: usize = 1; +fn aiur_fn_413( + inp: [G; IN_413], record: &mut QueryRecord, io_buffer: &mut IOBuffer, unconstrained: bool, -) -> Result<[G; OUT_417], ExecError> { +) -> Result<[G; OUT_413], ExecError> { stacker::maybe_grow(64 * 1024, 4 * 1024 * 1024, || { let __v_0: G = inp[0]; let __v_1: G = inp[1]; @@ -37495,8 +37221,8 @@ fn aiur_fn_417( match __v_2.as_canonical_u64() { 1u64 => { let __v_5: G = G::from_u64(0); - let __ret: [G; OUT_417] = [__v_5]; - if let Some(result) = record.function_queries[417].get_mut(&inp[..]) { debug_assert_eq!(result.output, &__ret[..]); if !unconstrained { *result.multiplicity += G::ONE; } } else { record.function_queries[417].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained)); }; + let __ret: [G; OUT_413] = [__v_5]; + if let Some(result) = record.function_queries[413].get_mut(&inp[..]) { debug_assert_eq!(result.output, &__ret[..]); if !unconstrained { *result.multiplicity += G::ONE; } } else { record.function_queries[413].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained)); }; return Ok(__ret); }, 0u64 => { @@ -37505,15 +37231,15 @@ fn aiur_fn_417( match __v_5.as_canonical_u64() { 1u64 => { let __v_6: G = G::from_u64(1); - let __ret: [G; OUT_417] = [__v_6]; - if let Some(result) = record.function_queries[417].get_mut(&inp[..]) { debug_assert_eq!(result.output, &__ret[..]); if !unconstrained { *result.multiplicity += G::ONE; } } else { record.function_queries[417].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained)); }; + let __ret: [G; OUT_413] = [__v_6]; + if let Some(result) = record.function_queries[413].get_mut(&inp[..]) { debug_assert_eq!(result.output, &__ret[..]); if !unconstrained { *result.multiplicity += G::ONE; } } else { record.function_queries[413].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained)); }; return Ok(__ret); }, _ => { - let __r_arr: [G; OUT_417] = { let __args: [G; IN_417] = [__v_0, __v_4]; let __cu = unconstrained; if let Some(result) = record.function_queries[417].get_mut(&__args[..]) { if !__cu && *result.multiplicity == G::ZERO { aiur_fn_417(__args, record, io_buffer, false)? } else { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_417] = unsafe { *(result.output.as_ptr() as *const [G; OUT_417]) }; __ret } } else { aiur_fn_417(__args, record, io_buffer, __cu)? } }; + let __r_arr: [G; OUT_413] = { let __args: [G; IN_413] = [__v_0, __v_4]; let __cu = unconstrained; if let Some(result) = record.function_queries[413].get_mut(&__args[..]) { if !__cu && *result.multiplicity == G::ZERO { aiur_fn_413(__args, record, io_buffer, false)? } else { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_413] = unsafe { *(result.output.as_ptr() as *const [G; OUT_413]) }; __ret } } else { aiur_fn_413(__args, record, io_buffer, __cu)? } }; let __v_6: G = __r_arr[0]; - let __ret: [G; OUT_417] = [__v_6]; - if let Some(result) = record.function_queries[417].get_mut(&inp[..]) { debug_assert_eq!(result.output, &__ret[..]); if !unconstrained { *result.multiplicity += G::ONE; } } else { record.function_queries[417].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained)); }; + let __ret: [G; OUT_413] = [__v_6]; + if let Some(result) = record.function_queries[413].get_mut(&inp[..]) { debug_assert_eq!(result.output, &__ret[..]); if !unconstrained { *result.multiplicity += G::ONE; } } else { record.function_queries[413].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained)); }; return Ok(__ret); }, } @@ -37525,15 +37251,15 @@ fn aiur_fn_417( }) } -const INPUT_SIZE_418: usize = 2; -const IN_418: usize = 2; -const OUT_418: usize = 1; -fn aiur_fn_418( - inp: [G; IN_418], +const INPUT_SIZE_414: usize = 2; +const IN_414: usize = 2; +const OUT_414: usize = 1; +fn aiur_fn_414( + inp: [G; IN_414], record: &mut QueryRecord, io_buffer: &mut IOBuffer, unconstrained: bool, -) -> Result<[G; OUT_418], ExecError> { +) -> Result<[G; OUT_414], ExecError> { stacker::maybe_grow(64 * 1024, 4 * 1024 * 1024, || { let __v_0: G = inp[0]; let __v_1: G = inp[1]; @@ -37544,80 +37270,80 @@ fn aiur_fn_418( let __v_5: G = __loaded[3]; match __v_2.as_canonical_u64() { 1u64 => { - let __ret: [G; OUT_418] = [__v_0]; - if let Some(result) = record.function_queries[418].get_mut(&inp[..]) { debug_assert_eq!(result.output, &__ret[..]); if !unconstrained { *result.multiplicity += G::ONE; } } else { record.function_queries[418].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained)); }; + let __ret: [G; OUT_414] = [__v_0]; + if let Some(result) = record.function_queries[414].get_mut(&inp[..]) { debug_assert_eq!(result.output, &__ret[..]); if !unconstrained { *result.multiplicity += G::ONE; } } else { record.function_queries[414].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained)); }; return Ok(__ret); }, 7u64 => { - let __ret: [G; OUT_418] = [__v_0]; - if let Some(result) = record.function_queries[418].get_mut(&inp[..]) { debug_assert_eq!(result.output, &__ret[..]); if !unconstrained { *result.multiplicity += G::ONE; } } else { record.function_queries[418].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained)); }; + let __ret: [G; OUT_414] = [__v_0]; + if let Some(result) = record.function_queries[414].get_mut(&inp[..]) { debug_assert_eq!(result.output, &__ret[..]); if !unconstrained { *result.multiplicity += G::ONE; } } else { record.function_queries[414].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained)); }; return Ok(__ret); }, 4u64 => { - let __ret: [G; OUT_418] = [__v_0]; - if let Some(result) = record.function_queries[418].get_mut(&inp[..]) { debug_assert_eq!(result.output, &__ret[..]); if !unconstrained { *result.multiplicity += G::ONE; } } else { record.function_queries[418].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained)); }; + let __ret: [G; OUT_414] = [__v_0]; + if let Some(result) = record.function_queries[414].get_mut(&inp[..]) { debug_assert_eq!(result.output, &__ret[..]); if !unconstrained { *result.multiplicity += G::ONE; } } else { record.function_queries[414].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained)); }; return Ok(__ret); }, 5u64 => { - let __ret: [G; OUT_418] = [__v_0]; - if let Some(result) = record.function_queries[418].get_mut(&inp[..]) { debug_assert_eq!(result.output, &__ret[..]); if !unconstrained { *result.multiplicity += G::ONE; } } else { record.function_queries[418].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained)); }; + let __ret: [G; OUT_414] = [__v_0]; + if let Some(result) = record.function_queries[414].get_mut(&inp[..]) { debug_assert_eq!(result.output, &__ret[..]); if !unconstrained { *result.multiplicity += G::ONE; } } else { record.function_queries[414].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained)); }; return Ok(__ret); }, 0u64 => { - let __ret: [G; OUT_418] = [__v_0]; - if let Some(result) = record.function_queries[418].get_mut(&inp[..]) { debug_assert_eq!(result.output, &__ret[..]); if !unconstrained { *result.multiplicity += G::ONE; } } else { record.function_queries[418].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained)); }; + let __ret: [G; OUT_414] = [__v_0]; + if let Some(result) = record.function_queries[414].get_mut(&inp[..]) { debug_assert_eq!(result.output, &__ret[..]); if !unconstrained { *result.multiplicity += G::ONE; } } else { record.function_queries[414].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained)); }; return Ok(__ret); }, _ => { - let __r_arr: [G; OUT_341] = { let __args: [G; IN_341] = [__v_0]; let __cu = unconstrained; if let Some(result) = record.function_queries[341].get_mut(&__args[..]) { if !__cu && *result.multiplicity == G::ZERO { aiur_fn_341(__args, record, io_buffer, false)? } else { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_341] = unsafe { *(result.output.as_ptr() as *const [G; OUT_341]) }; __ret } } else { aiur_fn_341(__args, record, io_buffer, __cu)? } }; + let __r_arr: [G; OUT_337] = { let __args: [G; IN_337] = [__v_0]; let __cu = unconstrained; if let Some(result) = record.function_queries[337].get_mut(&__args[..]) { if !__cu && *result.multiplicity == G::ZERO { aiur_fn_337(__args, record, io_buffer, false)? } else { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_337] = unsafe { *(result.output.as_ptr() as *const [G; OUT_337]) }; __ret } } else { aiur_fn_337(__args, record, io_buffer, __cu)? } }; let __v_6: G = __r_arr[0]; - let __r_arr: [G; OUT_354] = { let __args: [G; IN_354] = [__v_1, __v_6]; let __cu = unconstrained; if let Some(result) = record.function_queries[354].get_mut(&__args[..]) { if !__cu && *result.multiplicity == G::ZERO { aiur_fn_354(__args, record, io_buffer, false)? } else { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_354] = unsafe { *(result.output.as_ptr() as *const [G; OUT_354]) }; __ret } } else { aiur_fn_354(__args, record, io_buffer, __cu)? } }; + let __r_arr: [G; OUT_350] = { let __args: [G; IN_350] = [__v_1, __v_6]; let __cu = unconstrained; if let Some(result) = record.function_queries[350].get_mut(&__args[..]) { if !__cu && *result.multiplicity == G::ZERO { aiur_fn_350(__args, record, io_buffer, false)? } else { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_350] = unsafe { *(result.output.as_ptr() as *const [G; OUT_350]) }; __ret } } else { aiur_fn_350(__args, record, io_buffer, __cu)? } }; let __v_7: G = __r_arr[0]; let __v_8: G = G::from_u64(1); let __v_9: G = G::from_u64(1); let __v_10: G = { let __values: [G; 3] = [__v_8, __v_9, __v_9]; let __mq = record.memory_queries.get_mut(&3).ok_or(ExecError::InvalidMemorySize(3))?; if let Some(result) = __mq.get_mut(&__values[..]) { if !unconstrained { *result.multiplicity += G::ONE; } result.output[0] } else { let __ptr = G::from_usize(__mq.len()); __mq.insert(&__values[..], &[__ptr], G::from_bool(!unconstrained)); __ptr } }; - let __r_arr: [G; OUT_378] = { let __args: [G; IN_378] = [__v_0, __v_10, __v_7]; let __cu = unconstrained; if let Some(result) = record.function_queries[378].get_mut(&__args[..]) { if !__cu && *result.multiplicity == G::ZERO { aiur_fn_378(__args, record, io_buffer, false)? } else { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_378] = unsafe { *(result.output.as_ptr() as *const [G; OUT_378]) }; __ret } } else { aiur_fn_378(__args, record, io_buffer, __cu)? } }; + let __r_arr: [G; OUT_374] = { let __args: [G; IN_374] = [__v_0, __v_10, __v_7]; let __cu = unconstrained; if let Some(result) = record.function_queries[374].get_mut(&__args[..]) { if !__cu && *result.multiplicity == G::ZERO { aiur_fn_374(__args, record, io_buffer, false)? } else { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_374] = unsafe { *(result.output.as_ptr() as *const [G; OUT_374]) }; __ret } } else { aiur_fn_374(__args, record, io_buffer, __cu)? } }; let __v_11: G = __r_arr[0]; - let __ret: [G; OUT_418] = [__v_11]; - if let Some(result) = record.function_queries[418].get_mut(&inp[..]) { debug_assert_eq!(result.output, &__ret[..]); if !unconstrained { *result.multiplicity += G::ONE; } } else { record.function_queries[418].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained)); }; + let __ret: [G; OUT_414] = [__v_11]; + if let Some(result) = record.function_queries[414].get_mut(&inp[..]) { debug_assert_eq!(result.output, &__ret[..]); if !unconstrained { *result.multiplicity += G::ONE; } } else { record.function_queries[414].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained)); }; return Ok(__ret); }, } }) } -const INPUT_SIZE_419: usize = 2; -const IN_419: usize = 2; -const OUT_419: usize = 1; -fn aiur_fn_419( - inp: [G; IN_419], +const INPUT_SIZE_415: usize = 2; +const IN_415: usize = 2; +const OUT_415: usize = 1; +fn aiur_fn_415( + inp: [G; IN_415], record: &mut QueryRecord, io_buffer: &mut IOBuffer, unconstrained: bool, -) -> Result<[G; OUT_419], ExecError> { +) -> Result<[G; OUT_415], ExecError> { stacker::maybe_grow(64 * 1024, 4 * 1024 * 1024, || { let __v_0: G = inp[0]; let __v_1: G = inp[1]; let __v_2: G = G::from_u64(1); let __v_3: G = G::from_u64(1); let __v_4: G = { let __values: [G; 3] = [__v_2, __v_3, __v_3]; let __mq = record.memory_queries.get_mut(&3).ok_or(ExecError::InvalidMemorySize(3))?; if let Some(result) = __mq.get_mut(&__values[..]) { if !unconstrained { *result.multiplicity += G::ONE; } result.output[0] } else { let __ptr = G::from_usize(__mq.len()); __mq.insert(&__values[..], &[__ptr], G::from_bool(!unconstrained)); __ptr } }; - let __r_arr: [G; OUT_378] = { let __args: [G; IN_378] = [__v_0, __v_4, __v_1]; let __cu = unconstrained; if let Some(result) = record.function_queries[378].get_mut(&__args[..]) { if !__cu && *result.multiplicity == G::ZERO { aiur_fn_378(__args, record, io_buffer, false)? } else { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_378] = unsafe { *(result.output.as_ptr() as *const [G; OUT_378]) }; __ret } } else { aiur_fn_378(__args, record, io_buffer, __cu)? } }; + let __r_arr: [G; OUT_374] = { let __args: [G; IN_374] = [__v_0, __v_4, __v_1]; let __cu = unconstrained; if let Some(result) = record.function_queries[374].get_mut(&__args[..]) { if !__cu && *result.multiplicity == G::ZERO { aiur_fn_374(__args, record, io_buffer, false)? } else { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_374] = unsafe { *(result.output.as_ptr() as *const [G; OUT_374]) }; __ret } } else { aiur_fn_374(__args, record, io_buffer, __cu)? } }; let __v_5: G = __r_arr[0]; - let __ret: [G; OUT_419] = [__v_5]; - if let Some(result) = record.function_queries[419].get_mut(&inp[..]) { debug_assert_eq!(result.output, &__ret[..]); if !unconstrained { *result.multiplicity += G::ONE; } } else { record.function_queries[419].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained)); }; + let __ret: [G; OUT_415] = [__v_5]; + if let Some(result) = record.function_queries[415].get_mut(&inp[..]) { debug_assert_eq!(result.output, &__ret[..]); if !unconstrained { *result.multiplicity += G::ONE; } } else { record.function_queries[415].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained)); }; return Ok(__ret); }) } -const INPUT_SIZE_420: usize = 2; -const IN_420: usize = 2; -const OUT_420: usize = 1; -fn aiur_fn_420( - inp: [G; IN_420], +const INPUT_SIZE_416: usize = 2; +const IN_416: usize = 2; +const OUT_416: usize = 1; +fn aiur_fn_416( + inp: [G; IN_416], record: &mut QueryRecord, io_buffer: &mut IOBuffer, unconstrained: bool, -) -> Result<[G; OUT_420], ExecError> { +) -> Result<[G; OUT_416], ExecError> { stacker::maybe_grow(64 * 1024, 4 * 1024 * 1024, || { let __v_0: G = inp[0]; let __v_1: G = inp[1]; @@ -37628,57 +37354,57 @@ fn aiur_fn_420( let __v_5: G = __loaded[3]; match __v_2.as_canonical_u64() { 1u64 => { - let __ret: [G; OUT_420] = [__v_0]; - if let Some(result) = record.function_queries[420].get_mut(&inp[..]) { debug_assert_eq!(result.output, &__ret[..]); if !unconstrained { *result.multiplicity += G::ONE; } } else { record.function_queries[420].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained)); }; + let __ret: [G; OUT_416] = [__v_0]; + if let Some(result) = record.function_queries[416].get_mut(&inp[..]) { debug_assert_eq!(result.output, &__ret[..]); if !unconstrained { *result.multiplicity += G::ONE; } } else { record.function_queries[416].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained)); }; return Ok(__ret); }, 7u64 => { - let __ret: [G; OUT_420] = [__v_0]; - if let Some(result) = record.function_queries[420].get_mut(&inp[..]) { debug_assert_eq!(result.output, &__ret[..]); if !unconstrained { *result.multiplicity += G::ONE; } } else { record.function_queries[420].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained)); }; + let __ret: [G; OUT_416] = [__v_0]; + if let Some(result) = record.function_queries[416].get_mut(&inp[..]) { debug_assert_eq!(result.output, &__ret[..]); if !unconstrained { *result.multiplicity += G::ONE; } } else { record.function_queries[416].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained)); }; return Ok(__ret); }, 4u64 => { - let __ret: [G; OUT_420] = [__v_0]; - if let Some(result) = record.function_queries[420].get_mut(&inp[..]) { debug_assert_eq!(result.output, &__ret[..]); if !unconstrained { *result.multiplicity += G::ONE; } } else { record.function_queries[420].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained)); }; + let __ret: [G; OUT_416] = [__v_0]; + if let Some(result) = record.function_queries[416].get_mut(&inp[..]) { debug_assert_eq!(result.output, &__ret[..]); if !unconstrained { *result.multiplicity += G::ONE; } } else { record.function_queries[416].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained)); }; return Ok(__ret); }, 5u64 => { - let __ret: [G; OUT_420] = [__v_0]; - if let Some(result) = record.function_queries[420].get_mut(&inp[..]) { debug_assert_eq!(result.output, &__ret[..]); if !unconstrained { *result.multiplicity += G::ONE; } } else { record.function_queries[420].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained)); }; + let __ret: [G; OUT_416] = [__v_0]; + if let Some(result) = record.function_queries[416].get_mut(&inp[..]) { debug_assert_eq!(result.output, &__ret[..]); if !unconstrained { *result.multiplicity += G::ONE; } } else { record.function_queries[416].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained)); }; return Ok(__ret); }, 0u64 => { - let __ret: [G; OUT_420] = [__v_0]; - if let Some(result) = record.function_queries[420].get_mut(&inp[..]) { debug_assert_eq!(result.output, &__ret[..]); if !unconstrained { *result.multiplicity += G::ONE; } } else { record.function_queries[420].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained)); }; + let __ret: [G; OUT_416] = [__v_0]; + if let Some(result) = record.function_queries[416].get_mut(&inp[..]) { debug_assert_eq!(result.output, &__ret[..]); if !unconstrained { *result.multiplicity += G::ONE; } } else { record.function_queries[416].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained)); }; return Ok(__ret); }, _ => { let __v_6: G = G::from_u64(1); let __v_7: G = G::from_u64(1); let __v_8: G = { let __values: [G; 3] = [__v_6, __v_7, __v_7]; let __mq = record.memory_queries.get_mut(&3).ok_or(ExecError::InvalidMemorySize(3))?; if let Some(result) = __mq.get_mut(&__values[..]) { if !unconstrained { *result.multiplicity += G::ONE; } result.output[0] } else { let __ptr = G::from_usize(__mq.len()); __mq.insert(&__values[..], &[__ptr], G::from_bool(!unconstrained)); __ptr } }; - let __r_arr: [G; OUT_341] = { let __args: [G; IN_341] = [__v_0]; let __cu = unconstrained; if let Some(result) = record.function_queries[341].get_mut(&__args[..]) { if !__cu && *result.multiplicity == G::ZERO { aiur_fn_341(__args, record, io_buffer, false)? } else { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_341] = unsafe { *(result.output.as_ptr() as *const [G; OUT_341]) }; __ret } } else { aiur_fn_341(__args, record, io_buffer, __cu)? } }; + let __r_arr: [G; OUT_337] = { let __args: [G; IN_337] = [__v_0]; let __cu = unconstrained; if let Some(result) = record.function_queries[337].get_mut(&__args[..]) { if !__cu && *result.multiplicity == G::ZERO { aiur_fn_337(__args, record, io_buffer, false)? } else { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_337] = unsafe { *(result.output.as_ptr() as *const [G; OUT_337]) }; __ret } } else { aiur_fn_337(__args, record, io_buffer, __cu)? } }; let __v_9: G = __r_arr[0]; - let __r_arr: [G; OUT_354] = { let __args: [G; IN_354] = [__v_1, __v_9]; let __cu = unconstrained; if let Some(result) = record.function_queries[354].get_mut(&__args[..]) { if !__cu && *result.multiplicity == G::ZERO { aiur_fn_354(__args, record, io_buffer, false)? } else { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_354] = unsafe { *(result.output.as_ptr() as *const [G; OUT_354]) }; __ret } } else { aiur_fn_354(__args, record, io_buffer, __cu)? } }; + let __r_arr: [G; OUT_350] = { let __args: [G; IN_350] = [__v_1, __v_9]; let __cu = unconstrained; if let Some(result) = record.function_queries[350].get_mut(&__args[..]) { if !__cu && *result.multiplicity == G::ZERO { aiur_fn_350(__args, record, io_buffer, false)? } else { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_350] = unsafe { *(result.output.as_ptr() as *const [G; OUT_350]) }; __ret } } else { aiur_fn_350(__args, record, io_buffer, __cu)? } }; let __v_10: G = __r_arr[0]; - let __r_arr: [G; OUT_421] = { let __args: [G; IN_421] = [__v_0, __v_8, __v_10]; let __cu = unconstrained; if let Some(result) = record.function_queries[421].get_mut(&__args[..]) { if !__cu && *result.multiplicity == G::ZERO { aiur_fn_421(__args, record, io_buffer, false)? } else { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_421] = unsafe { *(result.output.as_ptr() as *const [G; OUT_421]) }; __ret } } else { aiur_fn_421(__args, record, io_buffer, __cu)? } }; + let __r_arr: [G; OUT_417] = { let __args: [G; IN_417] = [__v_0, __v_8, __v_10]; let __cu = unconstrained; if let Some(result) = record.function_queries[417].get_mut(&__args[..]) { if !__cu && *result.multiplicity == G::ZERO { aiur_fn_417(__args, record, io_buffer, false)? } else { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_417] = unsafe { *(result.output.as_ptr() as *const [G; OUT_417]) }; __ret } } else { aiur_fn_417(__args, record, io_buffer, __cu)? } }; let __v_11: G = __r_arr[0]; - let __ret: [G; OUT_420] = [__v_11]; - if let Some(result) = record.function_queries[420].get_mut(&inp[..]) { debug_assert_eq!(result.output, &__ret[..]); if !unconstrained { *result.multiplicity += G::ONE; } } else { record.function_queries[420].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained)); }; + let __ret: [G; OUT_416] = [__v_11]; + if let Some(result) = record.function_queries[416].get_mut(&inp[..]) { debug_assert_eq!(result.output, &__ret[..]); if !unconstrained { *result.multiplicity += G::ONE; } } else { record.function_queries[416].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained)); }; return Ok(__ret); }, } }) } -const INPUT_SIZE_421: usize = 3; -const IN_421: usize = 3; -const OUT_421: usize = 1; -fn aiur_fn_421( - inp: [G; IN_421], +const INPUT_SIZE_417: usize = 3; +const IN_417: usize = 3; +const OUT_417: usize = 1; +fn aiur_fn_417( + inp: [G; IN_417], record: &mut QueryRecord, io_buffer: &mut IOBuffer, unconstrained: bool, -) -> Result<[G; OUT_421], ExecError> { +) -> Result<[G; OUT_417], ExecError> { stacker::maybe_grow(64 * 1024, 4 * 1024 * 1024, || { let __v_0: G = inp[0]; let __v_1: G = inp[1]; @@ -37693,101 +37419,101 @@ fn aiur_fn_421( let __r_arr: [G; OUT_111] = { let __args: [G; IN_111] = [__v_0]; let __cu = unconstrained; if let Some(result) = record.function_queries[111].get_mut(&__args[..]) { if !__cu && *result.multiplicity == G::ZERO { aiur_fn_111(__args, record, io_buffer, false)? } else { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_111] = unsafe { *(result.output.as_ptr() as *const [G; OUT_111]) }; __ret } } else { aiur_fn_111(__args, record, io_buffer, __cu)? } }; let __v_7: G = __r_arr[0]; let __v_8: G = __r_arr[1]; - let __r_arr: [G; OUT_763] = { let __args: [G; IN_763] = [__v_8, __v_1]; let __cu = unconstrained; if let Some(result) = record.function_queries[763].get_mut(&__args[..]) { if !__cu && *result.multiplicity == G::ZERO { aiur_fn_763(__args, record, io_buffer, false)? } else { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_763] = unsafe { *(result.output.as_ptr() as *const [G; OUT_763]) }; __ret } } else { aiur_fn_763(__args, record, io_buffer, __cu)? } }; + let __r_arr: [G; OUT_759] = { let __args: [G; IN_759] = [__v_8, __v_1]; let __cu = unconstrained; if let Some(result) = record.function_queries[759].get_mut(&__args[..]) { if !__cu && *result.multiplicity == G::ZERO { aiur_fn_759(__args, record, io_buffer, false)? } else { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_759] = unsafe { *(result.output.as_ptr() as *const [G; OUT_759]) }; __ret } } else { aiur_fn_759(__args, record, io_buffer, __cu)? } }; let __v_9: G = __r_arr[0]; - let __r_arr: [G; OUT_421] = { let __args: [G; IN_421] = [__v_7, __v_9, __v_2]; let __cu = unconstrained; if let Some(result) = record.function_queries[421].get_mut(&__args[..]) { if !__cu && *result.multiplicity == G::ZERO { aiur_fn_421(__args, record, io_buffer, false)? } else { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_421] = unsafe { *(result.output.as_ptr() as *const [G; OUT_421]) }; __ret } } else { aiur_fn_421(__args, record, io_buffer, __cu)? } }; + let __r_arr: [G; OUT_417] = { let __args: [G; IN_417] = [__v_7, __v_9, __v_2]; let __cu = unconstrained; if let Some(result) = record.function_queries[417].get_mut(&__args[..]) { if !__cu && *result.multiplicity == G::ZERO { aiur_fn_417(__args, record, io_buffer, false)? } else { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_417] = unsafe { *(result.output.as_ptr() as *const [G; OUT_417]) }; __ret } } else { aiur_fn_417(__args, record, io_buffer, __cu)? } }; let __v_10: G = __r_arr[0]; - let __ret: [G; OUT_421] = [__v_10]; - if let Some(result) = record.function_queries[421].get_mut(&inp[..]) { debug_assert_eq!(result.output, &__ret[..]); if !unconstrained { *result.multiplicity += G::ONE; } } else { record.function_queries[421].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained)); }; + let __ret: [G; OUT_417] = [__v_10]; + if let Some(result) = record.function_queries[417].get_mut(&inp[..]) { debug_assert_eq!(result.output, &__ret[..]); if !unconstrained { *result.multiplicity += G::ONE; } } else { record.function_queries[417].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained)); }; return Ok(__ret); }, 4u64 => { let __v_7: G = G::from_u64(1); let __v_8: G = G::from_u64(1); let __v_9: G = { let __values: [G; 3] = [__v_7, __v_8, __v_8]; let __mq = record.memory_queries.get_mut(&3).ok_or(ExecError::InvalidMemorySize(3))?; if let Some(result) = __mq.get_mut(&__values[..]) { if !unconstrained { *result.multiplicity += G::ONE; } result.output[0] } else { let __ptr = G::from_usize(__mq.len()); __mq.insert(&__values[..], &[__ptr], G::from_bool(!unconstrained)); __ptr } }; - let __r_arr: [G; OUT_376] = { let __args: [G; IN_376] = [__v_0, __v_1, __v_9]; let __cu = unconstrained; if let Some(result) = record.function_queries[376].get_mut(&__args[..]) { if !__cu && *result.multiplicity == G::ZERO { aiur_fn_376(__args, record, io_buffer, false)? } else { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_376] = unsafe { *(result.output.as_ptr() as *const [G; OUT_376]) }; __ret } } else { aiur_fn_376(__args, record, io_buffer, __cu)? } }; + let __r_arr: [G; OUT_372] = { let __args: [G; IN_372] = [__v_0, __v_1, __v_9]; let __cu = unconstrained; if let Some(result) = record.function_queries[372].get_mut(&__args[..]) { if !__cu && *result.multiplicity == G::ZERO { aiur_fn_372(__args, record, io_buffer, false)? } else { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_372] = unsafe { *(result.output.as_ptr() as *const [G; OUT_372]) }; __ret } } else { aiur_fn_372(__args, record, io_buffer, __cu)? } }; let __v_10: G = __r_arr[0]; let __v_11: G = __r_arr[1]; let __v_12: G = __r_arr[2]; - let __r_arr: [G; OUT_764] = { let __args: [G; IN_764] = [__v_11]; let __cu = unconstrained; if let Some(result) = record.function_queries[764].get_mut(&__args[..]) { if !__cu && *result.multiplicity == G::ZERO { aiur_fn_764(__args, record, io_buffer, false)? } else { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_764] = unsafe { *(result.output.as_ptr() as *const [G; OUT_764]) }; __ret } } else { aiur_fn_764(__args, record, io_buffer, __cu)? } }; + let __r_arr: [G; OUT_760] = { let __args: [G; IN_760] = [__v_11]; let __cu = unconstrained; if let Some(result) = record.function_queries[760].get_mut(&__args[..]) { if !__cu && *result.multiplicity == G::ZERO { aiur_fn_760(__args, record, io_buffer, false)? } else { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_760] = unsafe { *(result.output.as_ptr() as *const [G; OUT_760]) }; __ret } } else { aiur_fn_760(__args, record, io_buffer, __cu)? } }; let __v_13: G = __r_arr[0]; match __v_13.as_canonical_u64() { 0u64 => { - let __r_arr: [G; OUT_255] = { let __args: [G; IN_255] = [__v_0, __v_1]; let __cu = unconstrained; if let Some(result) = record.function_queries[255].get_mut(&__args[..]) { if !__cu && *result.multiplicity == G::ZERO { aiur_fn_255(__args, record, io_buffer, false)? } else { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_255] = unsafe { *(result.output.as_ptr() as *const [G; OUT_255]) }; __ret } } else { aiur_fn_255(__args, record, io_buffer, __cu)? } }; + let __r_arr: [G; OUT_251] = { let __args: [G; IN_251] = [__v_0, __v_1]; let __cu = unconstrained; if let Some(result) = record.function_queries[251].get_mut(&__args[..]) { if !__cu && *result.multiplicity == G::ZERO { aiur_fn_251(__args, record, io_buffer, false)? } else { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_251] = unsafe { *(result.output.as_ptr() as *const [G; OUT_251]) }; __ret } } else { aiur_fn_251(__args, record, io_buffer, __cu)? } }; let __v_14: G = __r_arr[0]; - let __ret: [G; OUT_421] = [__v_14]; - if let Some(result) = record.function_queries[421].get_mut(&inp[..]) { debug_assert_eq!(result.output, &__ret[..]); if !unconstrained { *result.multiplicity += G::ONE; } } else { record.function_queries[421].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained)); }; + let __ret: [G; OUT_417] = [__v_14]; + if let Some(result) = record.function_queries[417].get_mut(&inp[..]) { debug_assert_eq!(result.output, &__ret[..]); if !unconstrained { *result.multiplicity += G::ONE; } } else { record.function_queries[417].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained)); }; return Ok(__ret); }, 1u64 => { let __v_14: G = G::from_u64(0); - let __r_arr: [G; OUT_766] = { let __args: [G; IN_766] = [__v_11, __v_14]; let __cu = unconstrained; if let Some(result) = record.function_queries[766].get_mut(&__args[..]) { if !__cu && *result.multiplicity == G::ZERO { aiur_fn_766(__args, record, io_buffer, false)? } else { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_766] = unsafe { *(result.output.as_ptr() as *const [G; OUT_766]) }; __ret } } else { aiur_fn_766(__args, record, io_buffer, __cu)? } }; + let __r_arr: [G; OUT_762] = { let __args: [G; IN_762] = [__v_11, __v_14]; let __cu = unconstrained; if let Some(result) = record.function_queries[762].get_mut(&__args[..]) { if !__cu && *result.multiplicity == G::ZERO { aiur_fn_762(__args, record, io_buffer, false)? } else { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_762] = unsafe { *(result.output.as_ptr() as *const [G; OUT_762]) }; __ret } } else { aiur_fn_762(__args, record, io_buffer, __cu)? } }; let __v_15: G = __r_arr[0]; let __v_16: G = G::from_u64(0); - let __r_arr: [G; OUT_368] = { let __args: [G; IN_368] = [__v_10, __v_15, __v_16]; let __cu = unconstrained; if let Some(result) = record.function_queries[368].get_mut(&__args[..]) { if !__cu && *result.multiplicity == G::ZERO { aiur_fn_368(__args, record, io_buffer, false)? } else { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_368] = unsafe { *(result.output.as_ptr() as *const [G; OUT_368]) }; __ret } } else { aiur_fn_368(__args, record, io_buffer, __cu)? } }; + let __r_arr: [G; OUT_364] = { let __args: [G; IN_364] = [__v_10, __v_15, __v_16]; let __cu = unconstrained; if let Some(result) = record.function_queries[364].get_mut(&__args[..]) { if !__cu && *result.multiplicity == G::ZERO { aiur_fn_364(__args, record, io_buffer, false)? } else { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_364] = unsafe { *(result.output.as_ptr() as *const [G; OUT_364]) }; __ret } } else { aiur_fn_364(__args, record, io_buffer, __cu)? } }; let __v_17: G = __r_arr[0]; - let __r_arr: [G; OUT_421] = { let __args: [G; IN_421] = [__v_17, __v_12, __v_2]; let __cu = unconstrained; if let Some(result) = record.function_queries[421].get_mut(&__args[..]) { if !__cu && *result.multiplicity == G::ZERO { aiur_fn_421(__args, record, io_buffer, false)? } else { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_421] = unsafe { *(result.output.as_ptr() as *const [G; OUT_421]) }; __ret } } else { aiur_fn_421(__args, record, io_buffer, __cu)? } }; + let __r_arr: [G; OUT_417] = { let __args: [G; IN_417] = [__v_17, __v_12, __v_2]; let __cu = unconstrained; if let Some(result) = record.function_queries[417].get_mut(&__args[..]) { if !__cu && *result.multiplicity == G::ZERO { aiur_fn_417(__args, record, io_buffer, false)? } else { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_417] = unsafe { *(result.output.as_ptr() as *const [G; OUT_417]) }; __ret } } else { aiur_fn_417(__args, record, io_buffer, __cu)? } }; let __v_18: G = __r_arr[0]; - let __ret: [G; OUT_421] = [__v_18]; - if let Some(result) = record.function_queries[421].get_mut(&inp[..]) { debug_assert_eq!(result.output, &__ret[..]); if !unconstrained { *result.multiplicity += G::ONE; } } else { record.function_queries[421].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained)); }; + let __ret: [G; OUT_417] = [__v_18]; + if let Some(result) = record.function_queries[417].get_mut(&inp[..]) { debug_assert_eq!(result.output, &__ret[..]); if !unconstrained { *result.multiplicity += G::ONE; } } else { record.function_queries[417].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained)); }; return Ok(__ret); }, _ => { let __v_14: G = G::from_u64(0); - let __r_arr: [G; OUT_372] = { let __args: [G; IN_372] = [__v_10, __v_11, __v_14]; let __cu = unconstrained; if let Some(result) = record.function_queries[372].get_mut(&__args[..]) { if !__cu && *result.multiplicity == G::ZERO { aiur_fn_372(__args, record, io_buffer, false)? } else { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_372] = unsafe { *(result.output.as_ptr() as *const [G; OUT_372]) }; __ret } } else { aiur_fn_372(__args, record, io_buffer, __cu)? } }; + let __r_arr: [G; OUT_368] = { let __args: [G; IN_368] = [__v_10, __v_11, __v_14]; let __cu = unconstrained; if let Some(result) = record.function_queries[368].get_mut(&__args[..]) { if !__cu && *result.multiplicity == G::ZERO { aiur_fn_368(__args, record, io_buffer, false)? } else { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_368] = unsafe { *(result.output.as_ptr() as *const [G; OUT_368]) }; __ret } } else { aiur_fn_368(__args, record, io_buffer, __cu)? } }; let __v_15: G = __r_arr[0]; - let __r_arr: [G; OUT_421] = { let __args: [G; IN_421] = [__v_15, __v_12, __v_2]; let __cu = unconstrained; if let Some(result) = record.function_queries[421].get_mut(&__args[..]) { if !__cu && *result.multiplicity == G::ZERO { aiur_fn_421(__args, record, io_buffer, false)? } else { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_421] = unsafe { *(result.output.as_ptr() as *const [G; OUT_421]) }; __ret } } else { aiur_fn_421(__args, record, io_buffer, __cu)? } }; + let __r_arr: [G; OUT_417] = { let __args: [G; IN_417] = [__v_15, __v_12, __v_2]; let __cu = unconstrained; if let Some(result) = record.function_queries[417].get_mut(&__args[..]) { if !__cu && *result.multiplicity == G::ZERO { aiur_fn_417(__args, record, io_buffer, false)? } else { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_417] = unsafe { *(result.output.as_ptr() as *const [G; OUT_417]) }; __ret } } else { aiur_fn_417(__args, record, io_buffer, __cu)? } }; let __v_16: G = __r_arr[0]; - let __ret: [G; OUT_421] = [__v_16]; - if let Some(result) = record.function_queries[421].get_mut(&inp[..]) { debug_assert_eq!(result.output, &__ret[..]); if !unconstrained { *result.multiplicity += G::ONE; } } else { record.function_queries[421].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained)); }; + let __ret: [G; OUT_417] = [__v_16]; + if let Some(result) = record.function_queries[417].get_mut(&inp[..]) { debug_assert_eq!(result.output, &__ret[..]); if !unconstrained { *result.multiplicity += G::ONE; } } else { record.function_queries[417].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained)); }; return Ok(__ret); }, } }, 6u64 => { let __v_7: G = G::from_u64(0); - let __r_arr: [G; OUT_368] = { let __args: [G; IN_368] = [__v_6, __v_5, __v_7]; let __cu = unconstrained; if let Some(result) = record.function_queries[368].get_mut(&__args[..]) { if !__cu && *result.multiplicity == G::ZERO { aiur_fn_368(__args, record, io_buffer, false)? } else { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_368] = unsafe { *(result.output.as_ptr() as *const [G; OUT_368]) }; __ret } } else { aiur_fn_368(__args, record, io_buffer, __cu)? } }; + let __r_arr: [G; OUT_364] = { let __args: [G; IN_364] = [__v_6, __v_5, __v_7]; let __cu = unconstrained; if let Some(result) = record.function_queries[364].get_mut(&__args[..]) { if !__cu && *result.multiplicity == G::ZERO { aiur_fn_364(__args, record, io_buffer, false)? } else { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_364] = unsafe { *(result.output.as_ptr() as *const [G; OUT_364]) }; __ret } } else { aiur_fn_364(__args, record, io_buffer, __cu)? } }; let __v_8: G = __r_arr[0]; - let __r_arr: [G; OUT_421] = { let __args: [G; IN_421] = [__v_8, __v_1, __v_2]; let __cu = unconstrained; if let Some(result) = record.function_queries[421].get_mut(&__args[..]) { if !__cu && *result.multiplicity == G::ZERO { aiur_fn_421(__args, record, io_buffer, false)? } else { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_421] = unsafe { *(result.output.as_ptr() as *const [G; OUT_421]) }; __ret } } else { aiur_fn_421(__args, record, io_buffer, __cu)? } }; + let __r_arr: [G; OUT_417] = { let __args: [G; IN_417] = [__v_8, __v_1, __v_2]; let __cu = unconstrained; if let Some(result) = record.function_queries[417].get_mut(&__args[..]) { if !__cu && *result.multiplicity == G::ZERO { aiur_fn_417(__args, record, io_buffer, false)? } else { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_417] = unsafe { *(result.output.as_ptr() as *const [G; OUT_417]) }; __ret } } else { aiur_fn_417(__args, record, io_buffer, __cu)? } }; let __v_9: G = __r_arr[0]; - let __ret: [G; OUT_421] = [__v_9]; - if let Some(result) = record.function_queries[421].get_mut(&inp[..]) { debug_assert_eq!(result.output, &__ret[..]); if !unconstrained { *result.multiplicity += G::ONE; } } else { record.function_queries[421].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained)); }; + let __ret: [G; OUT_417] = [__v_9]; + if let Some(result) = record.function_queries[417].get_mut(&inp[..]) { debug_assert_eq!(result.output, &__ret[..]); if !unconstrained { *result.multiplicity += G::ONE; } } else { record.function_queries[417].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained)); }; return Ok(__ret); }, 8u64 => { - let __r_arr: [G; OUT_422] = { let __args: [G; IN_422] = [__v_4, __v_5, __v_6, __v_1, __v_2, __v_0]; let __cu = unconstrained; if let Some(result) = record.function_queries[422].get_mut(&__args[..]) { if !__cu && *result.multiplicity == G::ZERO { aiur_fn_422(__args, record, io_buffer, false)? } else { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_422] = unsafe { *(result.output.as_ptr() as *const [G; OUT_422]) }; __ret } } else { aiur_fn_422(__args, record, io_buffer, __cu)? } }; + let __r_arr: [G; OUT_418] = { let __args: [G; IN_418] = [__v_4, __v_5, __v_6, __v_1, __v_2, __v_0]; let __cu = unconstrained; if let Some(result) = record.function_queries[418].get_mut(&__args[..]) { if !__cu && *result.multiplicity == G::ZERO { aiur_fn_418(__args, record, io_buffer, false)? } else { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_418] = unsafe { *(result.output.as_ptr() as *const [G; OUT_418]) }; __ret } } else { aiur_fn_418(__args, record, io_buffer, __cu)? } }; let __v_7: G = __r_arr[0]; - let __ret: [G; OUT_421] = [__v_7]; - if let Some(result) = record.function_queries[421].get_mut(&inp[..]) { debug_assert_eq!(result.output, &__ret[..]); if !unconstrained { *result.multiplicity += G::ONE; } } else { record.function_queries[421].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained)); }; + let __ret: [G; OUT_417] = [__v_7]; + if let Some(result) = record.function_queries[417].get_mut(&inp[..]) { debug_assert_eq!(result.output, &__ret[..]); if !unconstrained { *result.multiplicity += G::ONE; } } else { record.function_queries[417].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained)); }; return Ok(__ret); }, 2u64 => { - let __r_arr: [G; OUT_423] = { let __args: [G; IN_423] = [__v_4, __v_5, __v_0, __v_1, __v_2]; let __cu = unconstrained; if let Some(result) = record.function_queries[423].get_mut(&__args[..]) { if !__cu && *result.multiplicity == G::ZERO { aiur_fn_423(__args, record, io_buffer, false)? } else { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_423] = unsafe { *(result.output.as_ptr() as *const [G; OUT_423]) }; __ret } } else { aiur_fn_423(__args, record, io_buffer, __cu)? } }; + let __r_arr: [G; OUT_419] = { let __args: [G; IN_419] = [__v_4, __v_5, __v_0, __v_1, __v_2]; let __cu = unconstrained; if let Some(result) = record.function_queries[419].get_mut(&__args[..]) { if !__cu && *result.multiplicity == G::ZERO { aiur_fn_419(__args, record, io_buffer, false)? } else { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_419] = unsafe { *(result.output.as_ptr() as *const [G; OUT_419]) }; __ret } } else { aiur_fn_419(__args, record, io_buffer, __cu)? } }; let __v_7: G = __r_arr[0]; - let __ret: [G; OUT_421] = [__v_7]; - if let Some(result) = record.function_queries[421].get_mut(&inp[..]) { debug_assert_eq!(result.output, &__ret[..]); if !unconstrained { *result.multiplicity += G::ONE; } } else { record.function_queries[421].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained)); }; + let __ret: [G; OUT_417] = [__v_7]; + if let Some(result) = record.function_queries[417].get_mut(&inp[..]) { debug_assert_eq!(result.output, &__ret[..]); if !unconstrained { *result.multiplicity += G::ONE; } } else { record.function_queries[417].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained)); }; return Ok(__ret); }, _ => { - let __r_arr: [G; OUT_255] = { let __args: [G; IN_255] = [__v_0, __v_1]; let __cu = unconstrained; if let Some(result) = record.function_queries[255].get_mut(&__args[..]) { if !__cu && *result.multiplicity == G::ZERO { aiur_fn_255(__args, record, io_buffer, false)? } else { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_255] = unsafe { *(result.output.as_ptr() as *const [G; OUT_255]) }; __ret } } else { aiur_fn_255(__args, record, io_buffer, __cu)? } }; + let __r_arr: [G; OUT_251] = { let __args: [G; IN_251] = [__v_0, __v_1]; let __cu = unconstrained; if let Some(result) = record.function_queries[251].get_mut(&__args[..]) { if !__cu && *result.multiplicity == G::ZERO { aiur_fn_251(__args, record, io_buffer, false)? } else { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_251] = unsafe { *(result.output.as_ptr() as *const [G; OUT_251]) }; __ret } } else { aiur_fn_251(__args, record, io_buffer, __cu)? } }; let __v_7: G = __r_arr[0]; - let __ret: [G; OUT_421] = [__v_7]; - if let Some(result) = record.function_queries[421].get_mut(&inp[..]) { debug_assert_eq!(result.output, &__ret[..]); if !unconstrained { *result.multiplicity += G::ONE; } } else { record.function_queries[421].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained)); }; + let __ret: [G; OUT_417] = [__v_7]; + if let Some(result) = record.function_queries[417].get_mut(&inp[..]) { debug_assert_eq!(result.output, &__ret[..]); if !unconstrained { *result.multiplicity += G::ONE; } } else { record.function_queries[417].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained)); }; return Ok(__ret); }, } }) } -const INPUT_SIZE_422: usize = 6; -const IN_422: usize = 6; -const OUT_422: usize = 1; -fn aiur_fn_422( - inp: [G; IN_422], +const INPUT_SIZE_418: usize = 6; +const IN_418: usize = 6; +const OUT_418: usize = 1; +fn aiur_fn_418( + inp: [G; IN_418], record: &mut QueryRecord, io_buffer: &mut IOBuffer, unconstrained: bool, -) -> Result<[G; OUT_422], ExecError> { +) -> Result<[G; OUT_418], ExecError> { stacker::maybe_grow(64 * 1024, 4 * 1024 * 1024, || { let __v_0: G = inp[0]; let __v_1: G = inp[1]; @@ -37795,7 +37521,7 @@ fn aiur_fn_422( let __v_3: G = inp[3]; let __v_4: G = inp[4]; let __v_5: G = inp[5]; - let __r_arr: [G; OUT_420] = { let __args: [G; IN_420] = [__v_2, __v_4]; let __cu = unconstrained; if let Some(result) = record.function_queries[420].get_mut(&__args[..]) { if !__cu && *result.multiplicity == G::ZERO { aiur_fn_420(__args, record, io_buffer, false)? } else { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_420] = unsafe { *(result.output.as_ptr() as *const [G; OUT_420]) }; __ret } } else { aiur_fn_420(__args, record, io_buffer, __cu)? } }; + let __r_arr: [G; OUT_416] = { let __args: [G; IN_416] = [__v_2, __v_4]; let __cu = unconstrained; if let Some(result) = record.function_queries[416].get_mut(&__args[..]) { if !__cu && *result.multiplicity == G::ZERO { aiur_fn_416(__args, record, io_buffer, false)? } else { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_416] = unsafe { *(result.output.as_ptr() as *const [G; OUT_416]) }; __ret } } else { aiur_fn_416(__args, record, io_buffer, __cu)? } }; let __v_6: G = __r_arr[0]; let __r_arr: [G; OUT_111] = { let __args: [G; IN_111] = [__v_6]; let __cu = unconstrained; if let Some(result) = record.function_queries[111].get_mut(&__args[..]) { if !__cu && *result.multiplicity == G::ZERO { aiur_fn_111(__args, record, io_buffer, false)? } else { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_111] = unsafe { *(result.output.as_ptr() as *const [G; OUT_111]) }; __ret } } else { aiur_fn_111(__args, record, io_buffer, __cu)? } }; let __v_7: G = __r_arr[0]; @@ -37807,7 +37533,7 @@ fn aiur_fn_422( let __v_12: G = __loaded[3]; match __v_9.as_canonical_u64() { 2u64 => { - let __r_arr: [G; OUT_387] = { let __args: [G; IN_387] = [__v_7]; let __cu = unconstrained; if let Some(result) = record.function_queries[387].get_mut(&__args[..]) { if !__cu && *result.multiplicity == G::ZERO { aiur_fn_387(__args, record, io_buffer, false)? } else { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_387] = unsafe { *(result.output.as_ptr() as *const [G; OUT_387]) }; __ret } } else { aiur_fn_387(__args, record, io_buffer, __cu)? } }; + let __r_arr: [G; OUT_383] = { let __args: [G; IN_383] = [__v_7]; let __cu = unconstrained; if let Some(result) = record.function_queries[383].get_mut(&__args[..]) { if !__cu && *result.multiplicity == G::ZERO { aiur_fn_383(__args, record, io_buffer, false)? } else { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_383] = unsafe { *(result.output.as_ptr() as *const [G; OUT_383]) }; __ret } } else { aiur_fn_383(__args, record, io_buffer, __cu)? } }; let __v_13: G = __r_arr[0]; let __loaded: [G; 12] = { let __mq = record.memory_queries.get_mut(&12).ok_or(ExecError::InvalidMemorySize(12))?; let __ptr_u64 = __v_13.as_canonical_u64(); let __ptr_usize = usize::try_from(__ptr_u64).ok().ok_or(ExecError::PointerTooLarge(__ptr_u64))?; let (__args, __mult) = __mq.get_index_mut(__ptr_usize).ok_or(ExecError::UnboundPointer { ptr: __ptr_u64, size: 12 })?; if !unconstrained { *__mult += G::ONE; } let __arr: [G; 12] = __args[..12].try_into().unwrap(); __arr }; let __v_14: G = __loaded[0]; @@ -37825,50 +37551,50 @@ fn aiur_fn_422( match __v_14.as_canonical_u64() { 6u64 => { let __v_26: G = (__v_20 + __v_1); - let __r_arr: [G; OUT_766] = { let __args: [G; IN_766] = [__v_8, __v_26]; let __cu = unconstrained; if let Some(result) = record.function_queries[766].get_mut(&__args[..]) { if !__cu && *result.multiplicity == G::ZERO { aiur_fn_766(__args, record, io_buffer, false)? } else { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_766] = unsafe { *(result.output.as_ptr() as *const [G; OUT_766]) }; __ret } } else { aiur_fn_766(__args, record, io_buffer, __cu)? } }; + let __r_arr: [G; OUT_762] = { let __args: [G; IN_762] = [__v_8, __v_26]; let __cu = unconstrained; if let Some(result) = record.function_queries[762].get_mut(&__args[..]) { if !__cu && *result.multiplicity == G::ZERO { aiur_fn_762(__args, record, io_buffer, false)? } else { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_762] = unsafe { *(result.output.as_ptr() as *const [G; OUT_762]) }; __ret } } else { aiur_fn_762(__args, record, io_buffer, __cu)? } }; let __v_27: G = __r_arr[0]; - let __r_arr: [G; OUT_421] = { let __args: [G; IN_421] = [__v_27, __v_3, __v_4]; let __cu = unconstrained; if let Some(result) = record.function_queries[421].get_mut(&__args[..]) { if !__cu && *result.multiplicity == G::ZERO { aiur_fn_421(__args, record, io_buffer, false)? } else { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_421] = unsafe { *(result.output.as_ptr() as *const [G; OUT_421]) }; __ret } } else { aiur_fn_421(__args, record, io_buffer, __cu)? } }; + let __r_arr: [G; OUT_417] = { let __args: [G; IN_417] = [__v_27, __v_3, __v_4]; let __cu = unconstrained; if let Some(result) = record.function_queries[417].get_mut(&__args[..]) { if !__cu && *result.multiplicity == G::ZERO { aiur_fn_417(__args, record, io_buffer, false)? } else { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_417] = unsafe { *(result.output.as_ptr() as *const [G; OUT_417]) }; __ret } } else { aiur_fn_417(__args, record, io_buffer, __cu)? } }; let __v_28: G = __r_arr[0]; - let __ret: [G; OUT_422] = [__v_28]; - if let Some(result) = record.function_queries[422].get_mut(&inp[..]) { debug_assert_eq!(result.output, &__ret[..]); if !unconstrained { *result.multiplicity += G::ONE; } } else { record.function_queries[422].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained)); }; + let __ret: [G; OUT_418] = [__v_28]; + if let Some(result) = record.function_queries[418].get_mut(&inp[..]) { debug_assert_eq!(result.output, &__ret[..]); if !unconstrained { *result.multiplicity += G::ONE; } } else { record.function_queries[418].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained)); }; return Ok(__ret); }, _ => { - let __r_arr: [G; OUT_255] = { let __args: [G; IN_255] = [__v_5, __v_3]; let __cu = unconstrained; if let Some(result) = record.function_queries[255].get_mut(&__args[..]) { if !__cu && *result.multiplicity == G::ZERO { aiur_fn_255(__args, record, io_buffer, false)? } else { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_255] = unsafe { *(result.output.as_ptr() as *const [G; OUT_255]) }; __ret } } else { aiur_fn_255(__args, record, io_buffer, __cu)? } }; + let __r_arr: [G; OUT_251] = { let __args: [G; IN_251] = [__v_5, __v_3]; let __cu = unconstrained; if let Some(result) = record.function_queries[251].get_mut(&__args[..]) { if !__cu && *result.multiplicity == G::ZERO { aiur_fn_251(__args, record, io_buffer, false)? } else { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_251] = unsafe { *(result.output.as_ptr() as *const [G; OUT_251]) }; __ret } } else { aiur_fn_251(__args, record, io_buffer, __cu)? } }; let __v_26: G = __r_arr[0]; - let __ret: [G; OUT_422] = [__v_26]; - if let Some(result) = record.function_queries[422].get_mut(&inp[..]) { debug_assert_eq!(result.output, &__ret[..]); if !unconstrained { *result.multiplicity += G::ONE; } } else { record.function_queries[422].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained)); }; + let __ret: [G; OUT_418] = [__v_26]; + if let Some(result) = record.function_queries[418].get_mut(&inp[..]) { debug_assert_eq!(result.output, &__ret[..]); if !unconstrained { *result.multiplicity += G::ONE; } } else { record.function_queries[418].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained)); }; return Ok(__ret); }, } }, _ => { - let __r_arr: [G; OUT_255] = { let __args: [G; IN_255] = [__v_5, __v_3]; let __cu = unconstrained; if let Some(result) = record.function_queries[255].get_mut(&__args[..]) { if !__cu && *result.multiplicity == G::ZERO { aiur_fn_255(__args, record, io_buffer, false)? } else { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_255] = unsafe { *(result.output.as_ptr() as *const [G; OUT_255]) }; __ret } } else { aiur_fn_255(__args, record, io_buffer, __cu)? } }; + let __r_arr: [G; OUT_251] = { let __args: [G; IN_251] = [__v_5, __v_3]; let __cu = unconstrained; if let Some(result) = record.function_queries[251].get_mut(&__args[..]) { if !__cu && *result.multiplicity == G::ZERO { aiur_fn_251(__args, record, io_buffer, false)? } else { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_251] = unsafe { *(result.output.as_ptr() as *const [G; OUT_251]) }; __ret } } else { aiur_fn_251(__args, record, io_buffer, __cu)? } }; let __v_13: G = __r_arr[0]; - let __ret: [G; OUT_422] = [__v_13]; - if let Some(result) = record.function_queries[422].get_mut(&inp[..]) { debug_assert_eq!(result.output, &__ret[..]); if !unconstrained { *result.multiplicity += G::ONE; } } else { record.function_queries[422].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained)); }; + let __ret: [G; OUT_418] = [__v_13]; + if let Some(result) = record.function_queries[418].get_mut(&inp[..]) { debug_assert_eq!(result.output, &__ret[..]); if !unconstrained { *result.multiplicity += G::ONE; } } else { record.function_queries[418].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained)); }; return Ok(__ret); }, } }) } -const INPUT_SIZE_423: usize = 5; -const IN_423: usize = 5; -const OUT_423: usize = 1; -fn aiur_fn_423( - inp: [G; IN_423], +const INPUT_SIZE_419: usize = 5; +const IN_419: usize = 5; +const OUT_419: usize = 1; +fn aiur_fn_419( + inp: [G; IN_419], record: &mut QueryRecord, io_buffer: &mut IOBuffer, unconstrained: bool, -) -> Result<[G; OUT_423], ExecError> { +) -> Result<[G; OUT_419], ExecError> { stacker::maybe_grow(64 * 1024, 4 * 1024 * 1024, || { let __v_0: G = inp[0]; let __v_1: G = inp[1]; let __v_2: G = inp[2]; let __v_3: G = inp[3]; let __v_4: G = inp[4]; - let __r_arr: [G; OUT_287] = { let __args: [G; IN_287] = [__v_0]; let __cu = unconstrained; if let Some(result) = record.function_queries[287].get_mut(&__args[..]) { if !__cu && *result.multiplicity == G::ZERO { aiur_fn_287(__args, record, io_buffer, false)? } else { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_287] = unsafe { *(result.output.as_ptr() as *const [G; OUT_287]) }; __ret } } else { aiur_fn_287(__args, record, io_buffer, __cu)? } }; + let __r_arr: [G; OUT_283] = { let __args: [G; IN_283] = [__v_0]; let __cu = unconstrained; if let Some(result) = record.function_queries[283].get_mut(&__args[..]) { if !__cu && *result.multiplicity == G::ZERO { aiur_fn_283(__args, record, io_buffer, false)? } else { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_283] = unsafe { *(result.output.as_ptr() as *const [G; OUT_283]) }; __ret } } else { aiur_fn_283(__args, record, io_buffer, __cu)? } }; let __v_5: G = __r_arr[0]; let __loaded: [G; 12] = { let __mq = record.memory_queries.get_mut(&12).ok_or(ExecError::InvalidMemorySize(12))?; let __ptr_u64 = __v_5.as_canonical_u64(); let __ptr_usize = usize::try_from(__ptr_u64).ok().ok_or(ExecError::PointerTooLarge(__ptr_u64))?; let (__args, __mult) = __mq.get_index_mut(__ptr_usize).ok_or(ExecError::UnboundPointer { ptr: __ptr_u64, size: 12 })?; if !unconstrained { *__mult += G::ONE; } let __arr: [G; 12] = __args[..12].try_into().unwrap(); __arr }; let __v_6: G = __loaded[0]; @@ -37885,48 +37611,48 @@ fn aiur_fn_423( let __v_17: G = __loaded[11]; match __v_6.as_canonical_u64() { 7u64 => { - let __r_arr: [G; OUT_623] = { let __args: [G; IN_623] = [__v_8, __v_9, __v_11, __v_12, __v_10]; let __cu = unconstrained; if let Some(result) = record.function_queries[623].get_mut(&__args[..]) { if !__cu && *result.multiplicity == G::ZERO { aiur_fn_623(__args, record, io_buffer, false)? } else { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_623] = unsafe { *(result.output.as_ptr() as *const [G; OUT_623]) }; __ret } } else { aiur_fn_623(__args, record, io_buffer, __cu)? } }; + let __r_arr: [G; OUT_619] = { let __args: [G; IN_619] = [__v_8, __v_9, __v_11, __v_12, __v_10]; let __cu = unconstrained; if let Some(result) = record.function_queries[619].get_mut(&__args[..]) { if !__cu && *result.multiplicity == G::ZERO { aiur_fn_619(__args, record, io_buffer, false)? } else { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_619] = unsafe { *(result.output.as_ptr() as *const [G; OUT_619]) }; __ret } } else { aiur_fn_619(__args, record, io_buffer, __cu)? } }; let __v_18: G = __r_arr[0]; - let __r_arr: [G; OUT_405] = { let __args: [G; IN_405] = [__v_1, __v_3, __v_9, __v_11, __v_12, __v_10, __v_13, __v_4, __v_2, __v_18]; let __cu = unconstrained; if let Some(result) = record.function_queries[405].get_mut(&__args[..]) { if !__cu && *result.multiplicity == G::ZERO { aiur_fn_405(__args, record, io_buffer, false)? } else { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_405] = unsafe { *(result.output.as_ptr() as *const [G; OUT_405]) }; __ret } } else { aiur_fn_405(__args, record, io_buffer, __cu)? } }; + let __r_arr: [G; OUT_401] = { let __args: [G; IN_401] = [__v_1, __v_3, __v_9, __v_11, __v_12, __v_10, __v_13, __v_4, __v_2, __v_18]; let __cu = unconstrained; if let Some(result) = record.function_queries[401].get_mut(&__args[..]) { if !__cu && *result.multiplicity == G::ZERO { aiur_fn_401(__args, record, io_buffer, false)? } else { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_401] = unsafe { *(result.output.as_ptr() as *const [G; OUT_401]) }; __ret } } else { aiur_fn_401(__args, record, io_buffer, __cu)? } }; let __v_19: G = __r_arr[0]; let __v_20: G = __r_arr[1]; match __v_19.as_canonical_u64() { 1u64 => { - let __r_arr: [G; OUT_420] = { let __args: [G; IN_420] = [__v_20, __v_4]; let __cu = unconstrained; if let Some(result) = record.function_queries[420].get_mut(&__args[..]) { if !__cu && *result.multiplicity == G::ZERO { aiur_fn_420(__args, record, io_buffer, false)? } else { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_420] = unsafe { *(result.output.as_ptr() as *const [G; OUT_420]) }; __ret } } else { aiur_fn_420(__args, record, io_buffer, __cu)? } }; + let __r_arr: [G; OUT_416] = { let __args: [G; IN_416] = [__v_20, __v_4]; let __cu = unconstrained; if let Some(result) = record.function_queries[416].get_mut(&__args[..]) { if !__cu && *result.multiplicity == G::ZERO { aiur_fn_416(__args, record, io_buffer, false)? } else { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_416] = unsafe { *(result.output.as_ptr() as *const [G; OUT_416]) }; __ret } } else { aiur_fn_416(__args, record, io_buffer, __cu)? } }; let __v_21: G = __r_arr[0]; - let __ret: [G; OUT_423] = [__v_21]; - if let Some(result) = record.function_queries[423].get_mut(&inp[..]) { debug_assert_eq!(result.output, &__ret[..]); if !unconstrained { *result.multiplicity += G::ONE; } } else { record.function_queries[423].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained)); }; + let __ret: [G; OUT_419] = [__v_21]; + if let Some(result) = record.function_queries[419].get_mut(&inp[..]) { debug_assert_eq!(result.output, &__ret[..]); if !unconstrained { *result.multiplicity += G::ONE; } } else { record.function_queries[419].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained)); }; return Ok(__ret); }, _ => { - let __r_arr: [G; OUT_255] = { let __args: [G; IN_255] = [__v_2, __v_3]; let __cu = unconstrained; if let Some(result) = record.function_queries[255].get_mut(&__args[..]) { if !__cu && *result.multiplicity == G::ZERO { aiur_fn_255(__args, record, io_buffer, false)? } else { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_255] = unsafe { *(result.output.as_ptr() as *const [G; OUT_255]) }; __ret } } else { aiur_fn_255(__args, record, io_buffer, __cu)? } }; + let __r_arr: [G; OUT_251] = { let __args: [G; IN_251] = [__v_2, __v_3]; let __cu = unconstrained; if let Some(result) = record.function_queries[251].get_mut(&__args[..]) { if !__cu && *result.multiplicity == G::ZERO { aiur_fn_251(__args, record, io_buffer, false)? } else { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_251] = unsafe { *(result.output.as_ptr() as *const [G; OUT_251]) }; __ret } } else { aiur_fn_251(__args, record, io_buffer, __cu)? } }; let __v_21: G = __r_arr[0]; - let __ret: [G; OUT_423] = [__v_21]; - if let Some(result) = record.function_queries[423].get_mut(&inp[..]) { debug_assert_eq!(result.output, &__ret[..]); if !unconstrained { *result.multiplicity += G::ONE; } } else { record.function_queries[423].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained)); }; + let __ret: [G; OUT_419] = [__v_21]; + if let Some(result) = record.function_queries[419].get_mut(&inp[..]) { debug_assert_eq!(result.output, &__ret[..]); if !unconstrained { *result.multiplicity += G::ONE; } } else { record.function_queries[419].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained)); }; return Ok(__ret); }, } }, _ => { - let __r_arr: [G; OUT_255] = { let __args: [G; IN_255] = [__v_2, __v_3]; let __cu = unconstrained; if let Some(result) = record.function_queries[255].get_mut(&__args[..]) { if !__cu && *result.multiplicity == G::ZERO { aiur_fn_255(__args, record, io_buffer, false)? } else { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_255] = unsafe { *(result.output.as_ptr() as *const [G; OUT_255]) }; __ret } } else { aiur_fn_255(__args, record, io_buffer, __cu)? } }; + let __r_arr: [G; OUT_251] = { let __args: [G; IN_251] = [__v_2, __v_3]; let __cu = unconstrained; if let Some(result) = record.function_queries[251].get_mut(&__args[..]) { if !__cu && *result.multiplicity == G::ZERO { aiur_fn_251(__args, record, io_buffer, false)? } else { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_251] = unsafe { *(result.output.as_ptr() as *const [G; OUT_251]) }; __ret } } else { aiur_fn_251(__args, record, io_buffer, __cu)? } }; let __v_18: G = __r_arr[0]; - let __ret: [G; OUT_423] = [__v_18]; - if let Some(result) = record.function_queries[423].get_mut(&inp[..]) { debug_assert_eq!(result.output, &__ret[..]); if !unconstrained { *result.multiplicity += G::ONE; } } else { record.function_queries[423].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained)); }; + let __ret: [G; OUT_419] = [__v_18]; + if let Some(result) = record.function_queries[419].get_mut(&inp[..]) { debug_assert_eq!(result.output, &__ret[..]); if !unconstrained { *result.multiplicity += G::ONE; } } else { record.function_queries[419].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained)); }; return Ok(__ret); }, } }) } -const INPUT_SIZE_424: usize = 2; -const IN_424: usize = 2; -const OUT_424: usize = 1; -fn aiur_fn_424( - inp: [G; IN_424], +const INPUT_SIZE_420: usize = 2; +const IN_420: usize = 2; +const OUT_420: usize = 1; +fn aiur_fn_420( + inp: [G; IN_420], record: &mut QueryRecord, io_buffer: &mut IOBuffer, unconstrained: bool, -) -> Result<[G; OUT_424], ExecError> { +) -> Result<[G; OUT_420], ExecError> { stacker::maybe_grow(64 * 1024, 4 * 1024 * 1024, || { let __v_0: G = inp[0]; let __v_1: G = inp[1]; @@ -37937,80 +37663,80 @@ fn aiur_fn_424( let __v_5: G = __loaded[3]; match __v_2.as_canonical_u64() { 1u64 => { - let __ret: [G; OUT_424] = [__v_0]; - if let Some(result) = record.function_queries[424].get_mut(&inp[..]) { debug_assert_eq!(result.output, &__ret[..]); if !unconstrained { *result.multiplicity += G::ONE; } } else { record.function_queries[424].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained)); }; + let __ret: [G; OUT_420] = [__v_0]; + if let Some(result) = record.function_queries[420].get_mut(&inp[..]) { debug_assert_eq!(result.output, &__ret[..]); if !unconstrained { *result.multiplicity += G::ONE; } } else { record.function_queries[420].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained)); }; return Ok(__ret); }, 7u64 => { - let __ret: [G; OUT_424] = [__v_0]; - if let Some(result) = record.function_queries[424].get_mut(&inp[..]) { debug_assert_eq!(result.output, &__ret[..]); if !unconstrained { *result.multiplicity += G::ONE; } } else { record.function_queries[424].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained)); }; + let __ret: [G; OUT_420] = [__v_0]; + if let Some(result) = record.function_queries[420].get_mut(&inp[..]) { debug_assert_eq!(result.output, &__ret[..]); if !unconstrained { *result.multiplicity += G::ONE; } } else { record.function_queries[420].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained)); }; return Ok(__ret); }, 4u64 => { - let __ret: [G; OUT_424] = [__v_0]; - if let Some(result) = record.function_queries[424].get_mut(&inp[..]) { debug_assert_eq!(result.output, &__ret[..]); if !unconstrained { *result.multiplicity += G::ONE; } } else { record.function_queries[424].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained)); }; + let __ret: [G; OUT_420] = [__v_0]; + if let Some(result) = record.function_queries[420].get_mut(&inp[..]) { debug_assert_eq!(result.output, &__ret[..]); if !unconstrained { *result.multiplicity += G::ONE; } } else { record.function_queries[420].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained)); }; return Ok(__ret); }, 5u64 => { - let __ret: [G; OUT_424] = [__v_0]; - if let Some(result) = record.function_queries[424].get_mut(&inp[..]) { debug_assert_eq!(result.output, &__ret[..]); if !unconstrained { *result.multiplicity += G::ONE; } } else { record.function_queries[424].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained)); }; + let __ret: [G; OUT_420] = [__v_0]; + if let Some(result) = record.function_queries[420].get_mut(&inp[..]) { debug_assert_eq!(result.output, &__ret[..]); if !unconstrained { *result.multiplicity += G::ONE; } } else { record.function_queries[420].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained)); }; return Ok(__ret); }, 0u64 => { - let __ret: [G; OUT_424] = [__v_0]; - if let Some(result) = record.function_queries[424].get_mut(&inp[..]) { debug_assert_eq!(result.output, &__ret[..]); if !unconstrained { *result.multiplicity += G::ONE; } } else { record.function_queries[424].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained)); }; + let __ret: [G; OUT_420] = [__v_0]; + if let Some(result) = record.function_queries[420].get_mut(&inp[..]) { debug_assert_eq!(result.output, &__ret[..]); if !unconstrained { *result.multiplicity += G::ONE; } } else { record.function_queries[420].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained)); }; return Ok(__ret); }, _ => { - let __r_arr: [G; OUT_341] = { let __args: [G; IN_341] = [__v_0]; let __cu = unconstrained; if let Some(result) = record.function_queries[341].get_mut(&__args[..]) { if !__cu && *result.multiplicity == G::ZERO { aiur_fn_341(__args, record, io_buffer, false)? } else { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_341] = unsafe { *(result.output.as_ptr() as *const [G; OUT_341]) }; __ret } } else { aiur_fn_341(__args, record, io_buffer, __cu)? } }; + let __r_arr: [G; OUT_337] = { let __args: [G; IN_337] = [__v_0]; let __cu = unconstrained; if let Some(result) = record.function_queries[337].get_mut(&__args[..]) { if !__cu && *result.multiplicity == G::ZERO { aiur_fn_337(__args, record, io_buffer, false)? } else { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_337] = unsafe { *(result.output.as_ptr() as *const [G; OUT_337]) }; __ret } } else { aiur_fn_337(__args, record, io_buffer, __cu)? } }; let __v_6: G = __r_arr[0]; - let __r_arr: [G; OUT_354] = { let __args: [G; IN_354] = [__v_1, __v_6]; let __cu = unconstrained; if let Some(result) = record.function_queries[354].get_mut(&__args[..]) { if !__cu && *result.multiplicity == G::ZERO { aiur_fn_354(__args, record, io_buffer, false)? } else { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_354] = unsafe { *(result.output.as_ptr() as *const [G; OUT_354]) }; __ret } } else { aiur_fn_354(__args, record, io_buffer, __cu)? } }; + let __r_arr: [G; OUT_350] = { let __args: [G; IN_350] = [__v_1, __v_6]; let __cu = unconstrained; if let Some(result) = record.function_queries[350].get_mut(&__args[..]) { if !__cu && *result.multiplicity == G::ZERO { aiur_fn_350(__args, record, io_buffer, false)? } else { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_350] = unsafe { *(result.output.as_ptr() as *const [G; OUT_350]) }; __ret } } else { aiur_fn_350(__args, record, io_buffer, __cu)? } }; let __v_7: G = __r_arr[0]; let __v_8: G = G::from_u64(1); let __v_9: G = G::from_u64(1); let __v_10: G = { let __values: [G; 3] = [__v_8, __v_9, __v_9]; let __mq = record.memory_queries.get_mut(&3).ok_or(ExecError::InvalidMemorySize(3))?; if let Some(result) = __mq.get_mut(&__values[..]) { if !unconstrained { *result.multiplicity += G::ONE; } result.output[0] } else { let __ptr = G::from_usize(__mq.len()); __mq.insert(&__values[..], &[__ptr], G::from_bool(!unconstrained)); __ptr } }; - let __r_arr: [G; OUT_426] = { let __args: [G; IN_426] = [__v_0, __v_10, __v_7]; let __cu = unconstrained; if let Some(result) = record.function_queries[426].get_mut(&__args[..]) { if !__cu && *result.multiplicity == G::ZERO { aiur_fn_426(__args, record, io_buffer, false)? } else { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_426] = unsafe { *(result.output.as_ptr() as *const [G; OUT_426]) }; __ret } } else { aiur_fn_426(__args, record, io_buffer, __cu)? } }; + let __r_arr: [G; OUT_422] = { let __args: [G; IN_422] = [__v_0, __v_10, __v_7]; let __cu = unconstrained; if let Some(result) = record.function_queries[422].get_mut(&__args[..]) { if !__cu && *result.multiplicity == G::ZERO { aiur_fn_422(__args, record, io_buffer, false)? } else { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_422] = unsafe { *(result.output.as_ptr() as *const [G; OUT_422]) }; __ret } } else { aiur_fn_422(__args, record, io_buffer, __cu)? } }; let __v_11: G = __r_arr[0]; - let __ret: [G; OUT_424] = [__v_11]; - if let Some(result) = record.function_queries[424].get_mut(&inp[..]) { debug_assert_eq!(result.output, &__ret[..]); if !unconstrained { *result.multiplicity += G::ONE; } } else { record.function_queries[424].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained)); }; + let __ret: [G; OUT_420] = [__v_11]; + if let Some(result) = record.function_queries[420].get_mut(&inp[..]) { debug_assert_eq!(result.output, &__ret[..]); if !unconstrained { *result.multiplicity += G::ONE; } } else { record.function_queries[420].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained)); }; return Ok(__ret); }, } }) } -const INPUT_SIZE_425: usize = 2; -const IN_425: usize = 2; -const OUT_425: usize = 1; -fn aiur_fn_425( - inp: [G; IN_425], +const INPUT_SIZE_421: usize = 2; +const IN_421: usize = 2; +const OUT_421: usize = 1; +fn aiur_fn_421( + inp: [G; IN_421], record: &mut QueryRecord, io_buffer: &mut IOBuffer, unconstrained: bool, -) -> Result<[G; OUT_425], ExecError> { +) -> Result<[G; OUT_421], ExecError> { stacker::maybe_grow(64 * 1024, 4 * 1024 * 1024, || { let __v_0: G = inp[0]; let __v_1: G = inp[1]; let __v_2: G = G::from_u64(1); let __v_3: G = G::from_u64(1); let __v_4: G = { let __values: [G; 3] = [__v_2, __v_3, __v_3]; let __mq = record.memory_queries.get_mut(&3).ok_or(ExecError::InvalidMemorySize(3))?; if let Some(result) = __mq.get_mut(&__values[..]) { if !unconstrained { *result.multiplicity += G::ONE; } result.output[0] } else { let __ptr = G::from_usize(__mq.len()); __mq.insert(&__values[..], &[__ptr], G::from_bool(!unconstrained)); __ptr } }; - let __r_arr: [G; OUT_426] = { let __args: [G; IN_426] = [__v_0, __v_4, __v_1]; let __cu = unconstrained; if let Some(result) = record.function_queries[426].get_mut(&__args[..]) { if !__cu && *result.multiplicity == G::ZERO { aiur_fn_426(__args, record, io_buffer, false)? } else { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_426] = unsafe { *(result.output.as_ptr() as *const [G; OUT_426]) }; __ret } } else { aiur_fn_426(__args, record, io_buffer, __cu)? } }; + let __r_arr: [G; OUT_422] = { let __args: [G; IN_422] = [__v_0, __v_4, __v_1]; let __cu = unconstrained; if let Some(result) = record.function_queries[422].get_mut(&__args[..]) { if !__cu && *result.multiplicity == G::ZERO { aiur_fn_422(__args, record, io_buffer, false)? } else { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_422] = unsafe { *(result.output.as_ptr() as *const [G; OUT_422]) }; __ret } } else { aiur_fn_422(__args, record, io_buffer, __cu)? } }; let __v_5: G = __r_arr[0]; - let __ret: [G; OUT_425] = [__v_5]; - if let Some(result) = record.function_queries[425].get_mut(&inp[..]) { debug_assert_eq!(result.output, &__ret[..]); if !unconstrained { *result.multiplicity += G::ONE; } } else { record.function_queries[425].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained)); }; + let __ret: [G; OUT_421] = [__v_5]; + if let Some(result) = record.function_queries[421].get_mut(&inp[..]) { debug_assert_eq!(result.output, &__ret[..]); if !unconstrained { *result.multiplicity += G::ONE; } } else { record.function_queries[421].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained)); }; return Ok(__ret); }) } -const INPUT_SIZE_426: usize = 3; -const IN_426: usize = 3; -const OUT_426: usize = 1; -fn aiur_fn_426( - inp: [G; IN_426], +const INPUT_SIZE_422: usize = 3; +const IN_422: usize = 3; +const OUT_422: usize = 1; +fn aiur_fn_422( + inp: [G; IN_422], record: &mut QueryRecord, io_buffer: &mut IOBuffer, unconstrained: bool, -) -> Result<[G; OUT_426], ExecError> { +) -> Result<[G; OUT_422], ExecError> { stacker::maybe_grow(64 * 1024, 4 * 1024 * 1024, || { let __v_0: G = inp[0]; let __v_1: G = inp[1]; @@ -38025,65 +37751,65 @@ fn aiur_fn_426( let __r_arr: [G; OUT_111] = { let __args: [G; IN_111] = [__v_0]; let __cu = unconstrained; if let Some(result) = record.function_queries[111].get_mut(&__args[..]) { if !__cu && *result.multiplicity == G::ZERO { aiur_fn_111(__args, record, io_buffer, false)? } else { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_111] = unsafe { *(result.output.as_ptr() as *const [G; OUT_111]) }; __ret } } else { aiur_fn_111(__args, record, io_buffer, __cu)? } }; let __v_7: G = __r_arr[0]; let __v_8: G = __r_arr[1]; - let __r_arr: [G; OUT_763] = { let __args: [G; IN_763] = [__v_8, __v_1]; let __cu = unconstrained; if let Some(result) = record.function_queries[763].get_mut(&__args[..]) { if !__cu && *result.multiplicity == G::ZERO { aiur_fn_763(__args, record, io_buffer, false)? } else { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_763] = unsafe { *(result.output.as_ptr() as *const [G; OUT_763]) }; __ret } } else { aiur_fn_763(__args, record, io_buffer, __cu)? } }; + let __r_arr: [G; OUT_759] = { let __args: [G; IN_759] = [__v_8, __v_1]; let __cu = unconstrained; if let Some(result) = record.function_queries[759].get_mut(&__args[..]) { if !__cu && *result.multiplicity == G::ZERO { aiur_fn_759(__args, record, io_buffer, false)? } else { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_759] = unsafe { *(result.output.as_ptr() as *const [G; OUT_759]) }; __ret } } else { aiur_fn_759(__args, record, io_buffer, __cu)? } }; let __v_9: G = __r_arr[0]; - let __r_arr: [G; OUT_426] = { let __args: [G; IN_426] = [__v_7, __v_9, __v_2]; let __cu = unconstrained; if let Some(result) = record.function_queries[426].get_mut(&__args[..]) { if !__cu && *result.multiplicity == G::ZERO { aiur_fn_426(__args, record, io_buffer, false)? } else { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_426] = unsafe { *(result.output.as_ptr() as *const [G; OUT_426]) }; __ret } } else { aiur_fn_426(__args, record, io_buffer, __cu)? } }; + let __r_arr: [G; OUT_422] = { let __args: [G; IN_422] = [__v_7, __v_9, __v_2]; let __cu = unconstrained; if let Some(result) = record.function_queries[422].get_mut(&__args[..]) { if !__cu && *result.multiplicity == G::ZERO { aiur_fn_422(__args, record, io_buffer, false)? } else { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_422] = unsafe { *(result.output.as_ptr() as *const [G; OUT_422]) }; __ret } } else { aiur_fn_422(__args, record, io_buffer, __cu)? } }; let __v_10: G = __r_arr[0]; - let __ret: [G; OUT_426] = [__v_10]; - if let Some(result) = record.function_queries[426].get_mut(&inp[..]) { debug_assert_eq!(result.output, &__ret[..]); if !unconstrained { *result.multiplicity += G::ONE; } } else { record.function_queries[426].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained)); }; + let __ret: [G; OUT_422] = [__v_10]; + if let Some(result) = record.function_queries[422].get_mut(&inp[..]) { debug_assert_eq!(result.output, &__ret[..]); if !unconstrained { *result.multiplicity += G::ONE; } } else { record.function_queries[422].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained)); }; return Ok(__ret); }, 4u64 => { - let __r_arr: [G; OUT_427] = { let __args: [G; IN_427] = [__v_1, __v_0, __v_2]; let __cu = unconstrained; if let Some(result) = record.function_queries[427].get_mut(&__args[..]) { if !__cu && *result.multiplicity == G::ZERO { aiur_fn_427(__args, record, io_buffer, false)? } else { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_427] = unsafe { *(result.output.as_ptr() as *const [G; OUT_427]) }; __ret } } else { aiur_fn_427(__args, record, io_buffer, __cu)? } }; + let __r_arr: [G; OUT_423] = { let __args: [G; IN_423] = [__v_1, __v_0, __v_2]; let __cu = unconstrained; if let Some(result) = record.function_queries[423].get_mut(&__args[..]) { if !__cu && *result.multiplicity == G::ZERO { aiur_fn_423(__args, record, io_buffer, false)? } else { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_423] = unsafe { *(result.output.as_ptr() as *const [G; OUT_423]) }; __ret } } else { aiur_fn_423(__args, record, io_buffer, __cu)? } }; let __v_7: G = __r_arr[0]; - let __ret: [G; OUT_426] = [__v_7]; - if let Some(result) = record.function_queries[426].get_mut(&inp[..]) { debug_assert_eq!(result.output, &__ret[..]); if !unconstrained { *result.multiplicity += G::ONE; } } else { record.function_queries[426].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained)); }; + let __ret: [G; OUT_422] = [__v_7]; + if let Some(result) = record.function_queries[422].get_mut(&inp[..]) { debug_assert_eq!(result.output, &__ret[..]); if !unconstrained { *result.multiplicity += G::ONE; } } else { record.function_queries[422].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained)); }; return Ok(__ret); }, 2u64 => { - let __r_arr: [G; OUT_429] = { let __args: [G; IN_429] = [__v_4, __v_5, __v_0, __v_1, __v_2]; let __cu = unconstrained; if let Some(result) = record.function_queries[429].get_mut(&__args[..]) { if !__cu && *result.multiplicity == G::ZERO { aiur_fn_429(__args, record, io_buffer, false)? } else { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_429] = unsafe { *(result.output.as_ptr() as *const [G; OUT_429]) }; __ret } } else { aiur_fn_429(__args, record, io_buffer, __cu)? } }; + let __r_arr: [G; OUT_425] = { let __args: [G; IN_425] = [__v_4, __v_5, __v_0, __v_1, __v_2]; let __cu = unconstrained; if let Some(result) = record.function_queries[425].get_mut(&__args[..]) { if !__cu && *result.multiplicity == G::ZERO { aiur_fn_425(__args, record, io_buffer, false)? } else { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_425] = unsafe { *(result.output.as_ptr() as *const [G; OUT_425]) }; __ret } } else { aiur_fn_425(__args, record, io_buffer, __cu)? } }; let __v_7: G = __r_arr[0]; - let __ret: [G; OUT_426] = [__v_7]; - if let Some(result) = record.function_queries[426].get_mut(&inp[..]) { debug_assert_eq!(result.output, &__ret[..]); if !unconstrained { *result.multiplicity += G::ONE; } } else { record.function_queries[426].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained)); }; + let __ret: [G; OUT_422] = [__v_7]; + if let Some(result) = record.function_queries[422].get_mut(&inp[..]) { debug_assert_eq!(result.output, &__ret[..]); if !unconstrained { *result.multiplicity += G::ONE; } } else { record.function_queries[422].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained)); }; return Ok(__ret); }, 6u64 => { let __v_7: G = G::from_u64(0); - let __r_arr: [G; OUT_368] = { let __args: [G; IN_368] = [__v_6, __v_5, __v_7]; let __cu = unconstrained; if let Some(result) = record.function_queries[368].get_mut(&__args[..]) { if !__cu && *result.multiplicity == G::ZERO { aiur_fn_368(__args, record, io_buffer, false)? } else { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_368] = unsafe { *(result.output.as_ptr() as *const [G; OUT_368]) }; __ret } } else { aiur_fn_368(__args, record, io_buffer, __cu)? } }; + let __r_arr: [G; OUT_364] = { let __args: [G; IN_364] = [__v_6, __v_5, __v_7]; let __cu = unconstrained; if let Some(result) = record.function_queries[364].get_mut(&__args[..]) { if !__cu && *result.multiplicity == G::ZERO { aiur_fn_364(__args, record, io_buffer, false)? } else { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_364] = unsafe { *(result.output.as_ptr() as *const [G; OUT_364]) }; __ret } } else { aiur_fn_364(__args, record, io_buffer, __cu)? } }; let __v_8: G = __r_arr[0]; - let __r_arr: [G; OUT_426] = { let __args: [G; IN_426] = [__v_8, __v_1, __v_2]; let __cu = unconstrained; if let Some(result) = record.function_queries[426].get_mut(&__args[..]) { if !__cu && *result.multiplicity == G::ZERO { aiur_fn_426(__args, record, io_buffer, false)? } else { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_426] = unsafe { *(result.output.as_ptr() as *const [G; OUT_426]) }; __ret } } else { aiur_fn_426(__args, record, io_buffer, __cu)? } }; + let __r_arr: [G; OUT_422] = { let __args: [G; IN_422] = [__v_8, __v_1, __v_2]; let __cu = unconstrained; if let Some(result) = record.function_queries[422].get_mut(&__args[..]) { if !__cu && *result.multiplicity == G::ZERO { aiur_fn_422(__args, record, io_buffer, false)? } else { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_422] = unsafe { *(result.output.as_ptr() as *const [G; OUT_422]) }; __ret } } else { aiur_fn_422(__args, record, io_buffer, __cu)? } }; let __v_9: G = __r_arr[0]; - let __ret: [G; OUT_426] = [__v_9]; - if let Some(result) = record.function_queries[426].get_mut(&inp[..]) { debug_assert_eq!(result.output, &__ret[..]); if !unconstrained { *result.multiplicity += G::ONE; } } else { record.function_queries[426].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained)); }; + let __ret: [G; OUT_422] = [__v_9]; + if let Some(result) = record.function_queries[422].get_mut(&inp[..]) { debug_assert_eq!(result.output, &__ret[..]); if !unconstrained { *result.multiplicity += G::ONE; } } else { record.function_queries[422].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained)); }; return Ok(__ret); }, 8u64 => { - let __r_arr: [G; OUT_428] = { let __args: [G; IN_428] = [__v_4, __v_5, __v_6, __v_1, __v_2]; let __cu = unconstrained; if let Some(result) = record.function_queries[428].get_mut(&__args[..]) { if !__cu && *result.multiplicity == G::ZERO { aiur_fn_428(__args, record, io_buffer, false)? } else { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_428] = unsafe { *(result.output.as_ptr() as *const [G; OUT_428]) }; __ret } } else { aiur_fn_428(__args, record, io_buffer, __cu)? } }; + let __r_arr: [G; OUT_424] = { let __args: [G; IN_424] = [__v_4, __v_5, __v_6, __v_1, __v_2]; let __cu = unconstrained; if let Some(result) = record.function_queries[424].get_mut(&__args[..]) { if !__cu && *result.multiplicity == G::ZERO { aiur_fn_424(__args, record, io_buffer, false)? } else { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_424] = unsafe { *(result.output.as_ptr() as *const [G; OUT_424]) }; __ret } } else { aiur_fn_424(__args, record, io_buffer, __cu)? } }; let __v_7: G = __r_arr[0]; - let __ret: [G; OUT_426] = [__v_7]; - if let Some(result) = record.function_queries[426].get_mut(&inp[..]) { debug_assert_eq!(result.output, &__ret[..]); if !unconstrained { *result.multiplicity += G::ONE; } } else { record.function_queries[426].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained)); }; + let __ret: [G; OUT_422] = [__v_7]; + if let Some(result) = record.function_queries[422].get_mut(&inp[..]) { debug_assert_eq!(result.output, &__ret[..]); if !unconstrained { *result.multiplicity += G::ONE; } } else { record.function_queries[422].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained)); }; return Ok(__ret); }, _ => { - let __r_arr: [G; OUT_255] = { let __args: [G; IN_255] = [__v_0, __v_1]; let __cu = unconstrained; if let Some(result) = record.function_queries[255].get_mut(&__args[..]) { if !__cu && *result.multiplicity == G::ZERO { aiur_fn_255(__args, record, io_buffer, false)? } else { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_255] = unsafe { *(result.output.as_ptr() as *const [G; OUT_255]) }; __ret } } else { aiur_fn_255(__args, record, io_buffer, __cu)? } }; + let __r_arr: [G; OUT_251] = { let __args: [G; IN_251] = [__v_0, __v_1]; let __cu = unconstrained; if let Some(result) = record.function_queries[251].get_mut(&__args[..]) { if !__cu && *result.multiplicity == G::ZERO { aiur_fn_251(__args, record, io_buffer, false)? } else { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_251] = unsafe { *(result.output.as_ptr() as *const [G; OUT_251]) }; __ret } } else { aiur_fn_251(__args, record, io_buffer, __cu)? } }; let __v_7: G = __r_arr[0]; - let __ret: [G; OUT_426] = [__v_7]; - if let Some(result) = record.function_queries[426].get_mut(&inp[..]) { debug_assert_eq!(result.output, &__ret[..]); if !unconstrained { *result.multiplicity += G::ONE; } } else { record.function_queries[426].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained)); }; + let __ret: [G; OUT_422] = [__v_7]; + if let Some(result) = record.function_queries[422].get_mut(&inp[..]) { debug_assert_eq!(result.output, &__ret[..]); if !unconstrained { *result.multiplicity += G::ONE; } } else { record.function_queries[422].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained)); }; return Ok(__ret); }, } }) } -const INPUT_SIZE_427: usize = 3; -const IN_427: usize = 3; -const OUT_427: usize = 1; -fn aiur_fn_427( - inp: [G; IN_427], +const INPUT_SIZE_423: usize = 3; +const IN_423: usize = 3; +const OUT_423: usize = 1; +fn aiur_fn_423( + inp: [G; IN_423], record: &mut QueryRecord, io_buffer: &mut IOBuffer, unconstrained: bool, -) -> Result<[G; OUT_427], ExecError> { +) -> Result<[G; OUT_423], ExecError> { stacker::maybe_grow(64 * 1024, 4 * 1024 * 1024, || { let __v_0: G = inp[0]; let __v_1: G = inp[1]; @@ -38091,78 +37817,78 @@ fn aiur_fn_427( let __v_3: G = G::from_u64(1); let __v_4: G = G::from_u64(1); let __v_5: G = { let __values: [G; 3] = [__v_3, __v_4, __v_4]; let __mq = record.memory_queries.get_mut(&3).ok_or(ExecError::InvalidMemorySize(3))?; if let Some(result) = __mq.get_mut(&__values[..]) { if !unconstrained { *result.multiplicity += G::ONE; } result.output[0] } else { let __ptr = G::from_usize(__mq.len()); __mq.insert(&__values[..], &[__ptr], G::from_bool(!unconstrained)); __ptr } }; - let __r_arr: [G; OUT_376] = { let __args: [G; IN_376] = [__v_1, __v_0, __v_5]; let __cu = unconstrained; if let Some(result) = record.function_queries[376].get_mut(&__args[..]) { if !__cu && *result.multiplicity == G::ZERO { aiur_fn_376(__args, record, io_buffer, false)? } else { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_376] = unsafe { *(result.output.as_ptr() as *const [G; OUT_376]) }; __ret } } else { aiur_fn_376(__args, record, io_buffer, __cu)? } }; + let __r_arr: [G; OUT_372] = { let __args: [G; IN_372] = [__v_1, __v_0, __v_5]; let __cu = unconstrained; if let Some(result) = record.function_queries[372].get_mut(&__args[..]) { if !__cu && *result.multiplicity == G::ZERO { aiur_fn_372(__args, record, io_buffer, false)? } else { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_372] = unsafe { *(result.output.as_ptr() as *const [G; OUT_372]) }; __ret } } else { aiur_fn_372(__args, record, io_buffer, __cu)? } }; let __v_6: G = __r_arr[0]; let __v_7: G = __r_arr[1]; let __v_8: G = __r_arr[2]; - let __r_arr: [G; OUT_764] = { let __args: [G; IN_764] = [__v_7]; let __cu = unconstrained; if let Some(result) = record.function_queries[764].get_mut(&__args[..]) { if !__cu && *result.multiplicity == G::ZERO { aiur_fn_764(__args, record, io_buffer, false)? } else { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_764] = unsafe { *(result.output.as_ptr() as *const [G; OUT_764]) }; __ret } } else { aiur_fn_764(__args, record, io_buffer, __cu)? } }; + let __r_arr: [G; OUT_760] = { let __args: [G; IN_760] = [__v_7]; let __cu = unconstrained; if let Some(result) = record.function_queries[760].get_mut(&__args[..]) { if !__cu && *result.multiplicity == G::ZERO { aiur_fn_760(__args, record, io_buffer, false)? } else { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_760] = unsafe { *(result.output.as_ptr() as *const [G; OUT_760]) }; __ret } } else { aiur_fn_760(__args, record, io_buffer, __cu)? } }; let __v_9: G = __r_arr[0]; match __v_9.as_canonical_u64() { 0u64 => { - let __r_arr: [G; OUT_255] = { let __args: [G; IN_255] = [__v_1, __v_0]; let __cu = unconstrained; if let Some(result) = record.function_queries[255].get_mut(&__args[..]) { if !__cu && *result.multiplicity == G::ZERO { aiur_fn_255(__args, record, io_buffer, false)? } else { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_255] = unsafe { *(result.output.as_ptr() as *const [G; OUT_255]) }; __ret } } else { aiur_fn_255(__args, record, io_buffer, __cu)? } }; + let __r_arr: [G; OUT_251] = { let __args: [G; IN_251] = [__v_1, __v_0]; let __cu = unconstrained; if let Some(result) = record.function_queries[251].get_mut(&__args[..]) { if !__cu && *result.multiplicity == G::ZERO { aiur_fn_251(__args, record, io_buffer, false)? } else { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_251] = unsafe { *(result.output.as_ptr() as *const [G; OUT_251]) }; __ret } } else { aiur_fn_251(__args, record, io_buffer, __cu)? } }; let __v_10: G = __r_arr[0]; - let __ret: [G; OUT_427] = [__v_10]; - if let Some(result) = record.function_queries[427].get_mut(&inp[..]) { debug_assert_eq!(result.output, &__ret[..]); if !unconstrained { *result.multiplicity += G::ONE; } } else { record.function_queries[427].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained)); }; + let __ret: [G; OUT_423] = [__v_10]; + if let Some(result) = record.function_queries[423].get_mut(&inp[..]) { debug_assert_eq!(result.output, &__ret[..]); if !unconstrained { *result.multiplicity += G::ONE; } } else { record.function_queries[423].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained)); }; return Ok(__ret); }, 1u64 => { let __v_10: G = G::from_u64(0); - let __r_arr: [G; OUT_766] = { let __args: [G; IN_766] = [__v_7, __v_10]; let __cu = unconstrained; if let Some(result) = record.function_queries[766].get_mut(&__args[..]) { if !__cu && *result.multiplicity == G::ZERO { aiur_fn_766(__args, record, io_buffer, false)? } else { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_766] = unsafe { *(result.output.as_ptr() as *const [G; OUT_766]) }; __ret } } else { aiur_fn_766(__args, record, io_buffer, __cu)? } }; + let __r_arr: [G; OUT_762] = { let __args: [G; IN_762] = [__v_7, __v_10]; let __cu = unconstrained; if let Some(result) = record.function_queries[762].get_mut(&__args[..]) { if !__cu && *result.multiplicity == G::ZERO { aiur_fn_762(__args, record, io_buffer, false)? } else { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_762] = unsafe { *(result.output.as_ptr() as *const [G; OUT_762]) }; __ret } } else { aiur_fn_762(__args, record, io_buffer, __cu)? } }; let __v_11: G = __r_arr[0]; let __v_12: G = G::from_u64(0); - let __r_arr: [G; OUT_368] = { let __args: [G; IN_368] = [__v_6, __v_11, __v_12]; let __cu = unconstrained; if let Some(result) = record.function_queries[368].get_mut(&__args[..]) { if !__cu && *result.multiplicity == G::ZERO { aiur_fn_368(__args, record, io_buffer, false)? } else { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_368] = unsafe { *(result.output.as_ptr() as *const [G; OUT_368]) }; __ret } } else { aiur_fn_368(__args, record, io_buffer, __cu)? } }; + let __r_arr: [G; OUT_364] = { let __args: [G; IN_364] = [__v_6, __v_11, __v_12]; let __cu = unconstrained; if let Some(result) = record.function_queries[364].get_mut(&__args[..]) { if !__cu && *result.multiplicity == G::ZERO { aiur_fn_364(__args, record, io_buffer, false)? } else { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_364] = unsafe { *(result.output.as_ptr() as *const [G; OUT_364]) }; __ret } } else { aiur_fn_364(__args, record, io_buffer, __cu)? } }; let __v_13: G = __r_arr[0]; - let __r_arr: [G; OUT_426] = { let __args: [G; IN_426] = [__v_13, __v_8, __v_2]; let __cu = unconstrained; if let Some(result) = record.function_queries[426].get_mut(&__args[..]) { if !__cu && *result.multiplicity == G::ZERO { aiur_fn_426(__args, record, io_buffer, false)? } else { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_426] = unsafe { *(result.output.as_ptr() as *const [G; OUT_426]) }; __ret } } else { aiur_fn_426(__args, record, io_buffer, __cu)? } }; + let __r_arr: [G; OUT_422] = { let __args: [G; IN_422] = [__v_13, __v_8, __v_2]; let __cu = unconstrained; if let Some(result) = record.function_queries[422].get_mut(&__args[..]) { if !__cu && *result.multiplicity == G::ZERO { aiur_fn_422(__args, record, io_buffer, false)? } else { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_422] = unsafe { *(result.output.as_ptr() as *const [G; OUT_422]) }; __ret } } else { aiur_fn_422(__args, record, io_buffer, __cu)? } }; let __v_14: G = __r_arr[0]; - let __ret: [G; OUT_427] = [__v_14]; - if let Some(result) = record.function_queries[427].get_mut(&inp[..]) { debug_assert_eq!(result.output, &__ret[..]); if !unconstrained { *result.multiplicity += G::ONE; } } else { record.function_queries[427].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained)); }; + let __ret: [G; OUT_423] = [__v_14]; + if let Some(result) = record.function_queries[423].get_mut(&inp[..]) { debug_assert_eq!(result.output, &__ret[..]); if !unconstrained { *result.multiplicity += G::ONE; } } else { record.function_queries[423].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained)); }; return Ok(__ret); }, _ => { let __v_10: G = G::from_u64(0); - let __r_arr: [G; OUT_372] = { let __args: [G; IN_372] = [__v_6, __v_7, __v_10]; let __cu = unconstrained; if let Some(result) = record.function_queries[372].get_mut(&__args[..]) { if !__cu && *result.multiplicity == G::ZERO { aiur_fn_372(__args, record, io_buffer, false)? } else { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_372] = unsafe { *(result.output.as_ptr() as *const [G; OUT_372]) }; __ret } } else { aiur_fn_372(__args, record, io_buffer, __cu)? } }; + let __r_arr: [G; OUT_368] = { let __args: [G; IN_368] = [__v_6, __v_7, __v_10]; let __cu = unconstrained; if let Some(result) = record.function_queries[368].get_mut(&__args[..]) { if !__cu && *result.multiplicity == G::ZERO { aiur_fn_368(__args, record, io_buffer, false)? } else { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_368] = unsafe { *(result.output.as_ptr() as *const [G; OUT_368]) }; __ret } } else { aiur_fn_368(__args, record, io_buffer, __cu)? } }; let __v_11: G = __r_arr[0]; - let __r_arr: [G; OUT_426] = { let __args: [G; IN_426] = [__v_11, __v_8, __v_2]; let __cu = unconstrained; if let Some(result) = record.function_queries[426].get_mut(&__args[..]) { if !__cu && *result.multiplicity == G::ZERO { aiur_fn_426(__args, record, io_buffer, false)? } else { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_426] = unsafe { *(result.output.as_ptr() as *const [G; OUT_426]) }; __ret } } else { aiur_fn_426(__args, record, io_buffer, __cu)? } }; + let __r_arr: [G; OUT_422] = { let __args: [G; IN_422] = [__v_11, __v_8, __v_2]; let __cu = unconstrained; if let Some(result) = record.function_queries[422].get_mut(&__args[..]) { if !__cu && *result.multiplicity == G::ZERO { aiur_fn_422(__args, record, io_buffer, false)? } else { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_422] = unsafe { *(result.output.as_ptr() as *const [G; OUT_422]) }; __ret } } else { aiur_fn_422(__args, record, io_buffer, __cu)? } }; let __v_12: G = __r_arr[0]; - let __ret: [G; OUT_427] = [__v_12]; - if let Some(result) = record.function_queries[427].get_mut(&inp[..]) { debug_assert_eq!(result.output, &__ret[..]); if !unconstrained { *result.multiplicity += G::ONE; } } else { record.function_queries[427].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained)); }; + let __ret: [G; OUT_423] = [__v_12]; + if let Some(result) = record.function_queries[423].get_mut(&inp[..]) { debug_assert_eq!(result.output, &__ret[..]); if !unconstrained { *result.multiplicity += G::ONE; } } else { record.function_queries[423].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained)); }; return Ok(__ret); }, } }) } -const INPUT_SIZE_428: usize = 5; -const IN_428: usize = 5; -const OUT_428: usize = 1; -fn aiur_fn_428( - inp: [G; IN_428], +const INPUT_SIZE_424: usize = 5; +const IN_424: usize = 5; +const OUT_424: usize = 1; +fn aiur_fn_424( + inp: [G; IN_424], record: &mut QueryRecord, io_buffer: &mut IOBuffer, unconstrained: bool, -) -> Result<[G; OUT_428], ExecError> { +) -> Result<[G; OUT_424], ExecError> { stacker::maybe_grow(64 * 1024, 4 * 1024 * 1024, || { let __v_0: G = inp[0]; let __v_1: G = inp[1]; let __v_2: G = inp[2]; let __v_3: G = inp[3]; let __v_4: G = inp[4]; - let __r_arr: [G; OUT_424] = { let __args: [G; IN_424] = [__v_2, __v_4]; let __cu = unconstrained; if let Some(result) = record.function_queries[424].get_mut(&__args[..]) { if !__cu && *result.multiplicity == G::ZERO { aiur_fn_424(__args, record, io_buffer, false)? } else { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_424] = unsafe { *(result.output.as_ptr() as *const [G; OUT_424]) }; __ret } } else { aiur_fn_424(__args, record, io_buffer, __cu)? } }; + let __r_arr: [G; OUT_420] = { let __args: [G; IN_420] = [__v_2, __v_4]; let __cu = unconstrained; if let Some(result) = record.function_queries[420].get_mut(&__args[..]) { if !__cu && *result.multiplicity == G::ZERO { aiur_fn_420(__args, record, io_buffer, false)? } else { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_420] = unsafe { *(result.output.as_ptr() as *const [G; OUT_420]) }; __ret } } else { aiur_fn_420(__args, record, io_buffer, __cu)? } }; let __v_5: G = __r_arr[0]; - let __r_arr: [G; OUT_231] = { let __args: [G; IN_231] = [__v_5, __v_4]; let __cu = unconstrained; if let Some(result) = record.function_queries[231].get_mut(&__args[..]) { if !__cu && *result.multiplicity == G::ZERO { aiur_fn_231(__args, record, io_buffer, false)? } else { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_231] = unsafe { *(result.output.as_ptr() as *const [G; OUT_231]) }; __ret } } else { aiur_fn_231(__args, record, io_buffer, __cu)? } }; + let __r_arr: [G; OUT_227] = { let __args: [G; IN_227] = [__v_5, __v_4]; let __cu = unconstrained; if let Some(result) = record.function_queries[227].get_mut(&__args[..]) { if !__cu && *result.multiplicity == G::ZERO { aiur_fn_227(__args, record, io_buffer, false)? } else { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_227] = unsafe { *(result.output.as_ptr() as *const [G; OUT_227]) }; __ret } } else { aiur_fn_227(__args, record, io_buffer, __cu)? } }; let __v_6: G = __r_arr[0]; let __r_arr: [G; OUT_111] = { let __args: [G; IN_111] = [__v_6]; let __cu = unconstrained; if let Some(result) = record.function_queries[111].get_mut(&__args[..]) { if !__cu && *result.multiplicity == G::ZERO { aiur_fn_111(__args, record, io_buffer, false)? } else { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_111] = unsafe { *(result.output.as_ptr() as *const [G; OUT_111]) }; __ret } } else { aiur_fn_111(__args, record, io_buffer, __cu)? } }; let __v_7: G = __r_arr[0]; let __v_8: G = __r_arr[1]; - let __r_arr: [G; OUT_386] = { let __args: [G; IN_386] = [__v_0, __v_1, __v_7, __v_8]; let __cu = unconstrained; if let Some(result) = record.function_queries[386].get_mut(&__args[..]) { if !__cu && *result.multiplicity == G::ZERO { aiur_fn_386(__args, record, io_buffer, false)? } else { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_386] = unsafe { *(result.output.as_ptr() as *const [G; OUT_386]) }; __ret } } else { aiur_fn_386(__args, record, io_buffer, __cu)? } }; + let __r_arr: [G; OUT_382] = { let __args: [G; IN_382] = [__v_0, __v_1, __v_7, __v_8]; let __cu = unconstrained; if let Some(result) = record.function_queries[382].get_mut(&__args[..]) { if !__cu && *result.multiplicity == G::ZERO { aiur_fn_382(__args, record, io_buffer, false)? } else { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_382] = unsafe { *(result.output.as_ptr() as *const [G; OUT_382]) }; __ret } } else { aiur_fn_382(__args, record, io_buffer, __cu)? } }; let __v_9: G = __r_arr[0]; let __v_10: G = __r_arr[1]; match __v_9.as_canonical_u64() { 1u64 => { - let __r_arr: [G; OUT_426] = { let __args: [G; IN_426] = [__v_10, __v_3, __v_4]; let __cu = unconstrained; if let Some(result) = record.function_queries[426].get_mut(&__args[..]) { if !__cu && *result.multiplicity == G::ZERO { aiur_fn_426(__args, record, io_buffer, false)? } else { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_426] = unsafe { *(result.output.as_ptr() as *const [G; OUT_426]) }; __ret } } else { aiur_fn_426(__args, record, io_buffer, __cu)? } }; + let __r_arr: [G; OUT_422] = { let __args: [G; IN_422] = [__v_10, __v_3, __v_4]; let __cu = unconstrained; if let Some(result) = record.function_queries[422].get_mut(&__args[..]) { if !__cu && *result.multiplicity == G::ZERO { aiur_fn_422(__args, record, io_buffer, false)? } else { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_422] = unsafe { *(result.output.as_ptr() as *const [G; OUT_422]) }; __ret } } else { aiur_fn_422(__args, record, io_buffer, __cu)? } }; let __v_11: G = __r_arr[0]; - let __ret: [G; OUT_428] = [__v_11]; - if let Some(result) = record.function_queries[428].get_mut(&inp[..]) { debug_assert_eq!(result.output, &__ret[..]); if !unconstrained { *result.multiplicity += G::ONE; } } else { record.function_queries[428].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained)); }; + let __ret: [G; OUT_424] = [__v_11]; + if let Some(result) = record.function_queries[424].get_mut(&inp[..]) { debug_assert_eq!(result.output, &__ret[..]); if !unconstrained { *result.multiplicity += G::ONE; } } else { record.function_queries[424].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained)); }; return Ok(__ret); }, _ => { @@ -38173,7 +37899,7 @@ fn aiur_fn_428( let __v_14: G = __loaded[3]; match __v_11.as_canonical_u64() { 2u64 => { - let __r_arr: [G; OUT_387] = { let __args: [G; IN_387] = [__v_7]; let __cu = unconstrained; if let Some(result) = record.function_queries[387].get_mut(&__args[..]) { if !__cu && *result.multiplicity == G::ZERO { aiur_fn_387(__args, record, io_buffer, false)? } else { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_387] = unsafe { *(result.output.as_ptr() as *const [G; OUT_387]) }; __ret } } else { aiur_fn_387(__args, record, io_buffer, __cu)? } }; + let __r_arr: [G; OUT_383] = { let __args: [G; IN_383] = [__v_7]; let __cu = unconstrained; if let Some(result) = record.function_queries[383].get_mut(&__args[..]) { if !__cu && *result.multiplicity == G::ZERO { aiur_fn_383(__args, record, io_buffer, false)? } else { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_383] = unsafe { *(result.output.as_ptr() as *const [G; OUT_383]) }; __ret } } else { aiur_fn_383(__args, record, io_buffer, __cu)? } }; let __v_15: G = __r_arr[0]; let __loaded: [G; 12] = { let __mq = record.memory_queries.get_mut(&12).ok_or(ExecError::InvalidMemorySize(12))?; let __ptr_u64 = __v_15.as_canonical_u64(); let __ptr_usize = usize::try_from(__ptr_u64).ok().ok_or(ExecError::PointerTooLarge(__ptr_u64))?; let (__args, __mult) = __mq.get_index_mut(__ptr_usize).ok_or(ExecError::UnboundPointer { ptr: __ptr_u64, size: 12 })?; if !unconstrained { *__mult += G::ONE; } let __arr: [G; 12] = __args[..12].try_into().unwrap(); __arr }; let __v_16: G = __loaded[0]; @@ -38191,21 +37917,21 @@ fn aiur_fn_428( match __v_16.as_canonical_u64() { 6u64 => { let __v_28: G = (__v_22 + __v_1); - let __r_arr: [G; OUT_766] = { let __args: [G; IN_766] = [__v_8, __v_28]; let __cu = unconstrained; if let Some(result) = record.function_queries[766].get_mut(&__args[..]) { if !__cu && *result.multiplicity == G::ZERO { aiur_fn_766(__args, record, io_buffer, false)? } else { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_766] = unsafe { *(result.output.as_ptr() as *const [G; OUT_766]) }; __ret } } else { aiur_fn_766(__args, record, io_buffer, __cu)? } }; + let __r_arr: [G; OUT_762] = { let __args: [G; IN_762] = [__v_8, __v_28]; let __cu = unconstrained; if let Some(result) = record.function_queries[762].get_mut(&__args[..]) { if !__cu && *result.multiplicity == G::ZERO { aiur_fn_762(__args, record, io_buffer, false)? } else { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_762] = unsafe { *(result.output.as_ptr() as *const [G; OUT_762]) }; __ret } } else { aiur_fn_762(__args, record, io_buffer, __cu)? } }; let __v_29: G = __r_arr[0]; - let __r_arr: [G; OUT_426] = { let __args: [G; IN_426] = [__v_29, __v_3, __v_4]; let __cu = unconstrained; if let Some(result) = record.function_queries[426].get_mut(&__args[..]) { if !__cu && *result.multiplicity == G::ZERO { aiur_fn_426(__args, record, io_buffer, false)? } else { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_426] = unsafe { *(result.output.as_ptr() as *const [G; OUT_426]) }; __ret } } else { aiur_fn_426(__args, record, io_buffer, __cu)? } }; + let __r_arr: [G; OUT_422] = { let __args: [G; IN_422] = [__v_29, __v_3, __v_4]; let __cu = unconstrained; if let Some(result) = record.function_queries[422].get_mut(&__args[..]) { if !__cu && *result.multiplicity == G::ZERO { aiur_fn_422(__args, record, io_buffer, false)? } else { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_422] = unsafe { *(result.output.as_ptr() as *const [G; OUT_422]) }; __ret } } else { aiur_fn_422(__args, record, io_buffer, __cu)? } }; let __v_30: G = __r_arr[0]; - let __ret: [G; OUT_428] = [__v_30]; - if let Some(result) = record.function_queries[428].get_mut(&inp[..]) { debug_assert_eq!(result.output, &__ret[..]); if !unconstrained { *result.multiplicity += G::ONE; } } else { record.function_queries[428].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained)); }; + let __ret: [G; OUT_424] = [__v_30]; + if let Some(result) = record.function_queries[424].get_mut(&inp[..]) { debug_assert_eq!(result.output, &__ret[..]); if !unconstrained { *result.multiplicity += G::ONE; } } else { record.function_queries[424].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained)); }; return Ok(__ret); }, _ => { let __v_28: G = G::from_u64(8); let __v_29: G = { let __values: [G; 4] = [__v_28, __v_0, __v_1, __v_5]; let __mq = record.memory_queries.get_mut(&4).ok_or(ExecError::InvalidMemorySize(4))?; if let Some(result) = __mq.get_mut(&__values[..]) { if !unconstrained { *result.multiplicity += G::ONE; } result.output[0] } else { let __ptr = G::from_usize(__mq.len()); __mq.insert(&__values[..], &[__ptr], G::from_bool(!unconstrained)); __ptr } }; - let __r_arr: [G; OUT_255] = { let __args: [G; IN_255] = [__v_29, __v_3]; let __cu = unconstrained; if let Some(result) = record.function_queries[255].get_mut(&__args[..]) { if !__cu && *result.multiplicity == G::ZERO { aiur_fn_255(__args, record, io_buffer, false)? } else { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_255] = unsafe { *(result.output.as_ptr() as *const [G; OUT_255]) }; __ret } } else { aiur_fn_255(__args, record, io_buffer, __cu)? } }; + let __r_arr: [G; OUT_251] = { let __args: [G; IN_251] = [__v_29, __v_3]; let __cu = unconstrained; if let Some(result) = record.function_queries[251].get_mut(&__args[..]) { if !__cu && *result.multiplicity == G::ZERO { aiur_fn_251(__args, record, io_buffer, false)? } else { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_251] = unsafe { *(result.output.as_ptr() as *const [G; OUT_251]) }; __ret } } else { aiur_fn_251(__args, record, io_buffer, __cu)? } }; let __v_30: G = __r_arr[0]; - let __ret: [G; OUT_428] = [__v_30]; - if let Some(result) = record.function_queries[428].get_mut(&inp[..]) { debug_assert_eq!(result.output, &__ret[..]); if !unconstrained { *result.multiplicity += G::ONE; } } else { record.function_queries[428].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained)); }; + let __ret: [G; OUT_424] = [__v_30]; + if let Some(result) = record.function_queries[424].get_mut(&inp[..]) { debug_assert_eq!(result.output, &__ret[..]); if !unconstrained { *result.multiplicity += G::ONE; } } else { record.function_queries[424].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained)); }; return Ok(__ret); }, } @@ -38213,10 +37939,10 @@ fn aiur_fn_428( _ => { let __v_15: G = G::from_u64(8); let __v_16: G = { let __values: [G; 4] = [__v_15, __v_0, __v_1, __v_5]; let __mq = record.memory_queries.get_mut(&4).ok_or(ExecError::InvalidMemorySize(4))?; if let Some(result) = __mq.get_mut(&__values[..]) { if !unconstrained { *result.multiplicity += G::ONE; } result.output[0] } else { let __ptr = G::from_usize(__mq.len()); __mq.insert(&__values[..], &[__ptr], G::from_bool(!unconstrained)); __ptr } }; - let __r_arr: [G; OUT_255] = { let __args: [G; IN_255] = [__v_16, __v_3]; let __cu = unconstrained; if let Some(result) = record.function_queries[255].get_mut(&__args[..]) { if !__cu && *result.multiplicity == G::ZERO { aiur_fn_255(__args, record, io_buffer, false)? } else { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_255] = unsafe { *(result.output.as_ptr() as *const [G; OUT_255]) }; __ret } } else { aiur_fn_255(__args, record, io_buffer, __cu)? } }; + let __r_arr: [G; OUT_251] = { let __args: [G; IN_251] = [__v_16, __v_3]; let __cu = unconstrained; if let Some(result) = record.function_queries[251].get_mut(&__args[..]) { if !__cu && *result.multiplicity == G::ZERO { aiur_fn_251(__args, record, io_buffer, false)? } else { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_251] = unsafe { *(result.output.as_ptr() as *const [G; OUT_251]) }; __ret } } else { aiur_fn_251(__args, record, io_buffer, __cu)? } }; let __v_17: G = __r_arr[0]; - let __ret: [G; OUT_428] = [__v_17]; - if let Some(result) = record.function_queries[428].get_mut(&inp[..]) { debug_assert_eq!(result.output, &__ret[..]); if !unconstrained { *result.multiplicity += G::ONE; } } else { record.function_queries[428].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained)); }; + let __ret: [G; OUT_424] = [__v_17]; + if let Some(result) = record.function_queries[424].get_mut(&inp[..]) { debug_assert_eq!(result.output, &__ret[..]); if !unconstrained { *result.multiplicity += G::ONE; } } else { record.function_queries[424].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained)); }; return Ok(__ret); }, } @@ -38225,32 +37951,32 @@ fn aiur_fn_428( }) } -const INPUT_SIZE_429: usize = 5; -const IN_429: usize = 5; -const OUT_429: usize = 1; -fn aiur_fn_429( - inp: [G; IN_429], +const INPUT_SIZE_425: usize = 5; +const IN_425: usize = 5; +const OUT_425: usize = 1; +fn aiur_fn_425( + inp: [G; IN_425], record: &mut QueryRecord, io_buffer: &mut IOBuffer, unconstrained: bool, -) -> Result<[G; OUT_429], ExecError> { +) -> Result<[G; OUT_425], ExecError> { stacker::maybe_grow(64 * 1024, 4 * 1024 * 1024, || { let __v_0: G = inp[0]; let __v_1: G = inp[1]; let __v_2: G = inp[2]; let __v_3: G = inp[3]; let __v_4: G = inp[4]; - let __r_arr: [G; OUT_391] = { let __args: [G; IN_391] = [__v_0]; let __cu = unconstrained; if let Some(result) = record.function_queries[391].get_mut(&__args[..]) { if !__cu && *result.multiplicity == G::ZERO { aiur_fn_391(__args, record, io_buffer, false)? } else { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_391] = unsafe { *(result.output.as_ptr() as *const [G; OUT_391]) }; __ret } } else { aiur_fn_391(__args, record, io_buffer, __cu)? } }; + let __r_arr: [G; OUT_387] = { let __args: [G; IN_387] = [__v_0]; let __cu = unconstrained; if let Some(result) = record.function_queries[387].get_mut(&__args[..]) { if !__cu && *result.multiplicity == G::ZERO { aiur_fn_387(__args, record, io_buffer, false)? } else { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_387] = unsafe { *(result.output.as_ptr() as *const [G; OUT_387]) }; __ret } } else { aiur_fn_387(__args, record, io_buffer, __cu)? } }; let __v_5: G = __r_arr[0]; let __mc_out___mc_0: [G; 2] = '__mc_0: { match __v_5.as_canonical_u64() { 1u64 => { - let __r_arr: [G; OUT_255] = { let __args: [G; IN_255] = [__v_2, __v_3]; let __cu = unconstrained; if let Some(result) = record.function_queries[255].get_mut(&__args[..]) { if !__cu && *result.multiplicity == G::ZERO { aiur_fn_255(__args, record, io_buffer, false)? } else { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_255] = unsafe { *(result.output.as_ptr() as *const [G; OUT_255]) }; __ret } } else { aiur_fn_255(__args, record, io_buffer, __cu)? } }; + let __r_arr: [G; OUT_251] = { let __args: [G; IN_251] = [__v_2, __v_3]; let __cu = unconstrained; if let Some(result) = record.function_queries[251].get_mut(&__args[..]) { if !__cu && *result.multiplicity == G::ZERO { aiur_fn_251(__args, record, io_buffer, false)? } else { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_251] = unsafe { *(result.output.as_ptr() as *const [G; OUT_251]) }; __ret } } else { aiur_fn_251(__args, record, io_buffer, __cu)? } }; let __v_6: G = __r_arr[0]; - let __r_arr: [G; OUT_341] = { let __args: [G; IN_341] = [__v_6]; let __cu = unconstrained; if let Some(result) = record.function_queries[341].get_mut(&__args[..]) { if !__cu && *result.multiplicity == G::ZERO { aiur_fn_341(__args, record, io_buffer, false)? } else { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_341] = unsafe { *(result.output.as_ptr() as *const [G; OUT_341]) }; __ret } } else { aiur_fn_341(__args, record, io_buffer, __cu)? } }; + let __r_arr: [G; OUT_337] = { let __args: [G; IN_337] = [__v_6]; let __cu = unconstrained; if let Some(result) = record.function_queries[337].get_mut(&__args[..]) { if !__cu && *result.multiplicity == G::ZERO { aiur_fn_337(__args, record, io_buffer, false)? } else { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_337] = unsafe { *(result.output.as_ptr() as *const [G; OUT_337]) }; __ret } } else { aiur_fn_337(__args, record, io_buffer, __cu)? } }; let __v_7: G = __r_arr[0]; match __v_7.as_canonical_u64() { 0u64 => { - let __r_arr: [G; OUT_392] = { let __args: [G; IN_392] = [__v_0, __v_1, __v_3, __v_4]; let __cu = unconstrained; if let Some(result) = record.function_queries[392].get_mut(&__args[..]) { if !__cu && *result.multiplicity == G::ZERO { aiur_fn_392(__args, record, io_buffer, false)? } else { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_392] = unsafe { *(result.output.as_ptr() as *const [G; OUT_392]) }; __ret } } else { aiur_fn_392(__args, record, io_buffer, __cu)? } }; + let __r_arr: [G; OUT_388] = { let __args: [G; IN_388] = [__v_0, __v_1, __v_3, __v_4]; let __cu = unconstrained; if let Some(result) = record.function_queries[388].get_mut(&__args[..]) { if !__cu && *result.multiplicity == G::ZERO { aiur_fn_388(__args, record, io_buffer, false)? } else { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_388] = unsafe { *(result.output.as_ptr() as *const [G; OUT_388]) }; __ret } } else { aiur_fn_388(__args, record, io_buffer, __cu)? } }; let __v_8: G = __r_arr[0]; let __v_9: G = __r_arr[1]; break '__mc_0 [__v_8, __v_9]; @@ -38266,7 +37992,7 @@ fn aiur_fn_429( } }, _ => { - let __r_arr: [G; OUT_392] = { let __args: [G; IN_392] = [__v_0, __v_1, __v_3, __v_4]; let __cu = unconstrained; if let Some(result) = record.function_queries[392].get_mut(&__args[..]) { if !__cu && *result.multiplicity == G::ZERO { aiur_fn_392(__args, record, io_buffer, false)? } else { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_392] = unsafe { *(result.output.as_ptr() as *const [G; OUT_392]) }; __ret } } else { aiur_fn_392(__args, record, io_buffer, __cu)? } }; + let __r_arr: [G; OUT_388] = { let __args: [G; IN_388] = [__v_0, __v_1, __v_3, __v_4]; let __cu = unconstrained; if let Some(result) = record.function_queries[388].get_mut(&__args[..]) { if !__cu && *result.multiplicity == G::ZERO { aiur_fn_388(__args, record, io_buffer, false)? } else { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_388] = unsafe { *(result.output.as_ptr() as *const [G; OUT_388]) }; __ret } } else { aiur_fn_388(__args, record, io_buffer, __cu)? } }; let __v_6: G = __r_arr[0]; let __v_7: G = __r_arr[1]; break '__mc_0 [__v_6, __v_7]; @@ -38277,19 +38003,19 @@ fn aiur_fn_429( let __v_7: G = __mc_out___mc_0[1]; match __v_6.as_canonical_u64() { 1u64 => { - let __r_arr: [G; OUT_424] = { let __args: [G; IN_424] = [__v_7, __v_4]; let __cu = unconstrained; if let Some(result) = record.function_queries[424].get_mut(&__args[..]) { if !__cu && *result.multiplicity == G::ZERO { aiur_fn_424(__args, record, io_buffer, false)? } else { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_424] = unsafe { *(result.output.as_ptr() as *const [G; OUT_424]) }; __ret } } else { aiur_fn_424(__args, record, io_buffer, __cu)? } }; + let __r_arr: [G; OUT_420] = { let __args: [G; IN_420] = [__v_7, __v_4]; let __cu = unconstrained; if let Some(result) = record.function_queries[420].get_mut(&__args[..]) { if !__cu && *result.multiplicity == G::ZERO { aiur_fn_420(__args, record, io_buffer, false)? } else { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_420] = unsafe { *(result.output.as_ptr() as *const [G; OUT_420]) }; __ret } } else { aiur_fn_420(__args, record, io_buffer, __cu)? } }; let __v_8: G = __r_arr[0]; - let __ret: [G; OUT_429] = [__v_8]; - if let Some(result) = record.function_queries[429].get_mut(&inp[..]) { debug_assert_eq!(result.output, &__ret[..]); if !unconstrained { *result.multiplicity += G::ONE; } } else { record.function_queries[429].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained)); }; + let __ret: [G; OUT_425] = [__v_8]; + if let Some(result) = record.function_queries[425].get_mut(&inp[..]) { debug_assert_eq!(result.output, &__ret[..]); if !unconstrained { *result.multiplicity += G::ONE; } } else { record.function_queries[425].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained)); }; return Ok(__ret); }, 2u64 => { - let __ret: [G; OUT_429] = [__v_7]; - if let Some(result) = record.function_queries[429].get_mut(&inp[..]) { debug_assert_eq!(result.output, &__ret[..]); if !unconstrained { *result.multiplicity += G::ONE; } } else { record.function_queries[429].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained)); }; + let __ret: [G; OUT_425] = [__v_7]; + if let Some(result) = record.function_queries[425].get_mut(&inp[..]) { debug_assert_eq!(result.output, &__ret[..]); if !unconstrained { *result.multiplicity += G::ONE; } } else { record.function_queries[425].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained)); }; return Ok(__ret); }, _ => { - let __r_arr: [G; OUT_287] = { let __args: [G; IN_287] = [__v_0]; let __cu = unconstrained; if let Some(result) = record.function_queries[287].get_mut(&__args[..]) { if !__cu && *result.multiplicity == G::ZERO { aiur_fn_287(__args, record, io_buffer, false)? } else { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_287] = unsafe { *(result.output.as_ptr() as *const [G; OUT_287]) }; __ret } } else { aiur_fn_287(__args, record, io_buffer, __cu)? } }; + let __r_arr: [G; OUT_283] = { let __args: [G; IN_283] = [__v_0]; let __cu = unconstrained; if let Some(result) = record.function_queries[283].get_mut(&__args[..]) { if !__cu && *result.multiplicity == G::ZERO { aiur_fn_283(__args, record, io_buffer, false)? } else { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_283] = unsafe { *(result.output.as_ptr() as *const [G; OUT_283]) }; __ret } } else { aiur_fn_283(__args, record, io_buffer, __cu)? } }; let __v_8: G = __r_arr[0]; let __loaded: [G; 12] = { let __mq = record.memory_queries.get_mut(&12).ok_or(ExecError::InvalidMemorySize(12))?; let __ptr_u64 = __v_8.as_canonical_u64(); let __ptr_usize = usize::try_from(__ptr_u64).ok().ok_or(ExecError::PointerTooLarge(__ptr_u64))?; let (__args, __mult) = __mq.get_index_mut(__ptr_usize).ok_or(ExecError::UnboundPointer { ptr: __ptr_u64, size: 12 })?; if !unconstrained { *__mult += G::ONE; } let __arr: [G; 12] = __args[..12].try_into().unwrap(); __arr }; let __v_9: G = __loaded[0]; @@ -38306,43 +38032,43 @@ fn aiur_fn_429( let __v_20: G = __loaded[11]; match __v_9.as_canonical_u64() { 1u64 => { - let __r_arr: [G; OUT_398] = { let __args: [G; IN_398] = [__v_12, __v_3]; let __cu = unconstrained; if let Some(result) = record.function_queries[398].get_mut(&__args[..]) { if !__cu && *result.multiplicity == G::ZERO { aiur_fn_398(__args, record, io_buffer, false)? } else { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_398] = unsafe { *(result.output.as_ptr() as *const [G; OUT_398]) }; __ret } } else { aiur_fn_398(__args, record, io_buffer, __cu)? } }; + let __r_arr: [G; OUT_394] = { let __args: [G; IN_394] = [__v_12, __v_3]; let __cu = unconstrained; if let Some(result) = record.function_queries[394].get_mut(&__args[..]) { if !__cu && *result.multiplicity == G::ZERO { aiur_fn_394(__args, record, io_buffer, false)? } else { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_394] = unsafe { *(result.output.as_ptr() as *const [G; OUT_394]) }; __ret } } else { aiur_fn_394(__args, record, io_buffer, __cu)? } }; let __v_21: G = __r_arr[0]; let __v_22: G = __r_arr[1]; match __v_21.as_canonical_u64() { 1u64 => { - let __r_arr: [G; OUT_424] = { let __args: [G; IN_424] = [__v_22, __v_4]; let __cu = unconstrained; if let Some(result) = record.function_queries[424].get_mut(&__args[..]) { if !__cu && *result.multiplicity == G::ZERO { aiur_fn_424(__args, record, io_buffer, false)? } else { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_424] = unsafe { *(result.output.as_ptr() as *const [G; OUT_424]) }; __ret } } else { aiur_fn_424(__args, record, io_buffer, __cu)? } }; + let __r_arr: [G; OUT_420] = { let __args: [G; IN_420] = [__v_22, __v_4]; let __cu = unconstrained; if let Some(result) = record.function_queries[420].get_mut(&__args[..]) { if !__cu && *result.multiplicity == G::ZERO { aiur_fn_420(__args, record, io_buffer, false)? } else { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_420] = unsafe { *(result.output.as_ptr() as *const [G; OUT_420]) }; __ret } } else { aiur_fn_420(__args, record, io_buffer, __cu)? } }; let __v_23: G = __r_arr[0]; - let __ret: [G; OUT_429] = [__v_23]; - if let Some(result) = record.function_queries[429].get_mut(&inp[..]) { debug_assert_eq!(result.output, &__ret[..]); if !unconstrained { *result.multiplicity += G::ONE; } } else { record.function_queries[429].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained)); }; + let __ret: [G; OUT_425] = [__v_23]; + if let Some(result) = record.function_queries[425].get_mut(&inp[..]) { debug_assert_eq!(result.output, &__ret[..]); if !unconstrained { *result.multiplicity += G::ONE; } } else { record.function_queries[425].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained)); }; return Ok(__ret); }, _ => { - let __r_arr: [G; OUT_255] = { let __args: [G; IN_255] = [__v_2, __v_3]; let __cu = unconstrained; if let Some(result) = record.function_queries[255].get_mut(&__args[..]) { if !__cu && *result.multiplicity == G::ZERO { aiur_fn_255(__args, record, io_buffer, false)? } else { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_255] = unsafe { *(result.output.as_ptr() as *const [G; OUT_255]) }; __ret } } else { aiur_fn_255(__args, record, io_buffer, __cu)? } }; + let __r_arr: [G; OUT_251] = { let __args: [G; IN_251] = [__v_2, __v_3]; let __cu = unconstrained; if let Some(result) = record.function_queries[251].get_mut(&__args[..]) { if !__cu && *result.multiplicity == G::ZERO { aiur_fn_251(__args, record, io_buffer, false)? } else { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_251] = unsafe { *(result.output.as_ptr() as *const [G; OUT_251]) }; __ret } } else { aiur_fn_251(__args, record, io_buffer, __cu)? } }; let __v_23: G = __r_arr[0]; - let __ret: [G; OUT_429] = [__v_23]; - if let Some(result) = record.function_queries[429].get_mut(&inp[..]) { debug_assert_eq!(result.output, &__ret[..]); if !unconstrained { *result.multiplicity += G::ONE; } } else { record.function_queries[429].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained)); }; + let __ret: [G; OUT_425] = [__v_23]; + if let Some(result) = record.function_queries[425].get_mut(&inp[..]) { debug_assert_eq!(result.output, &__ret[..]); if !unconstrained { *result.multiplicity += G::ONE; } } else { record.function_queries[425].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained)); }; return Ok(__ret); }, } }, 4u64 => { - let __r_arr: [G; OUT_393] = { let __args: [G; IN_393] = [__v_0, __v_3, __v_4]; let __cu = unconstrained; if let Some(result) = record.function_queries[393].get_mut(&__args[..]) { if !__cu && *result.multiplicity == G::ZERO { aiur_fn_393(__args, record, io_buffer, false)? } else { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_393] = unsafe { *(result.output.as_ptr() as *const [G; OUT_393]) }; __ret } } else { aiur_fn_393(__args, record, io_buffer, __cu)? } }; + let __r_arr: [G; OUT_389] = { let __args: [G; IN_389] = [__v_0, __v_3, __v_4]; let __cu = unconstrained; if let Some(result) = record.function_queries[389].get_mut(&__args[..]) { if !__cu && *result.multiplicity == G::ZERO { aiur_fn_389(__args, record, io_buffer, false)? } else { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_389] = unsafe { *(result.output.as_ptr() as *const [G; OUT_389]) }; __ret } } else { aiur_fn_389(__args, record, io_buffer, __cu)? } }; let __v_21: G = __r_arr[0]; let __v_22: G = __r_arr[1]; match __v_21.as_canonical_u64() { 1u64 => { - let __r_arr: [G; OUT_424] = { let __args: [G; IN_424] = [__v_22, __v_4]; let __cu = unconstrained; if let Some(result) = record.function_queries[424].get_mut(&__args[..]) { if !__cu && *result.multiplicity == G::ZERO { aiur_fn_424(__args, record, io_buffer, false)? } else { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_424] = unsafe { *(result.output.as_ptr() as *const [G; OUT_424]) }; __ret } } else { aiur_fn_424(__args, record, io_buffer, __cu)? } }; + let __r_arr: [G; OUT_420] = { let __args: [G; IN_420] = [__v_22, __v_4]; let __cu = unconstrained; if let Some(result) = record.function_queries[420].get_mut(&__args[..]) { if !__cu && *result.multiplicity == G::ZERO { aiur_fn_420(__args, record, io_buffer, false)? } else { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_420] = unsafe { *(result.output.as_ptr() as *const [G; OUT_420]) }; __ret } } else { aiur_fn_420(__args, record, io_buffer, __cu)? } }; let __v_23: G = __r_arr[0]; - let __ret: [G; OUT_429] = [__v_23]; - if let Some(result) = record.function_queries[429].get_mut(&inp[..]) { debug_assert_eq!(result.output, &__ret[..]); if !unconstrained { *result.multiplicity += G::ONE; } } else { record.function_queries[429].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained)); }; + let __ret: [G; OUT_425] = [__v_23]; + if let Some(result) = record.function_queries[425].get_mut(&inp[..]) { debug_assert_eq!(result.output, &__ret[..]); if !unconstrained { *result.multiplicity += G::ONE; } } else { record.function_queries[425].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained)); }; return Ok(__ret); }, _ => { - let __r_arr: [G; OUT_255] = { let __args: [G; IN_255] = [__v_2, __v_3]; let __cu = unconstrained; if let Some(result) = record.function_queries[255].get_mut(&__args[..]) { if !__cu && *result.multiplicity == G::ZERO { aiur_fn_255(__args, record, io_buffer, false)? } else { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_255] = unsafe { *(result.output.as_ptr() as *const [G; OUT_255]) }; __ret } } else { aiur_fn_255(__args, record, io_buffer, __cu)? } }; + let __r_arr: [G; OUT_251] = { let __args: [G; IN_251] = [__v_2, __v_3]; let __cu = unconstrained; if let Some(result) = record.function_queries[251].get_mut(&__args[..]) { if !__cu && *result.multiplicity == G::ZERO { aiur_fn_251(__args, record, io_buffer, false)? } else { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_251] = unsafe { *(result.output.as_ptr() as *const [G; OUT_251]) }; __ret } } else { aiur_fn_251(__args, record, io_buffer, __cu)? } }; let __v_23: G = __r_arr[0]; - let __ret: [G; OUT_429] = [__v_23]; - if let Some(result) = record.function_queries[429].get_mut(&inp[..]) { debug_assert_eq!(result.output, &__ret[..]); if !unconstrained { *result.multiplicity += G::ONE; } } else { record.function_queries[429].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained)); }; + let __ret: [G; OUT_425] = [__v_23]; + if let Some(result) = record.function_queries[425].get_mut(&inp[..]) { debug_assert_eq!(result.output, &__ret[..]); if !unconstrained { *result.multiplicity += G::ONE; } } else { record.function_queries[425].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained)); }; return Ok(__ret); }, } @@ -38353,10 +38079,10 @@ fn aiur_fn_429( let __v_23: G = (__v_22 + __v_13); let __mc_out___mc_1: [G; 2] = '__mc_1: { match __v_17.as_canonical_u64() { 1u64 => { - let __r_arr: [G; OUT_409] = { let __args: [G; IN_409] = [__v_11, __v_23]; let __cu = unconstrained; if let Some(result) = record.function_queries[409].get_mut(&__args[..]) { if !__cu && *result.multiplicity == G::ZERO { aiur_fn_409(__args, record, io_buffer, false)? } else { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_409] = unsafe { *(result.output.as_ptr() as *const [G; OUT_409]) }; __ret } } else { aiur_fn_409(__args, record, io_buffer, __cu)? } }; + let __r_arr: [G; OUT_405] = { let __args: [G; IN_405] = [__v_11, __v_23]; let __cu = unconstrained; if let Some(result) = record.function_queries[405].get_mut(&__args[..]) { if !__cu && *result.multiplicity == G::ZERO { aiur_fn_405(__args, record, io_buffer, false)? } else { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_405] = unsafe { *(result.output.as_ptr() as *const [G; OUT_405]) }; __ret } } else { aiur_fn_405(__args, record, io_buffer, __cu)? } }; let __v_24: G = __r_arr[0]; let __v_25: G = __r_arr[1]; - let __r_arr: [G; OUT_401] = { let __args: [G; IN_401] = [__v_1, __v_3, __v_12, __v_14, __v_15, __v_13, __v_16, __v_25, __v_4]; let __cu = unconstrained; if let Some(result) = record.function_queries[401].get_mut(&__args[..]) { if !__cu && *result.multiplicity == G::ZERO { aiur_fn_401(__args, record, io_buffer, false)? } else { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_401] = unsafe { *(result.output.as_ptr() as *const [G; OUT_401]) }; __ret } } else { aiur_fn_401(__args, record, io_buffer, __cu)? } }; + let __r_arr: [G; OUT_397] = { let __args: [G; IN_397] = [__v_1, __v_3, __v_12, __v_14, __v_15, __v_13, __v_16, __v_25, __v_4]; let __cu = unconstrained; if let Some(result) = record.function_queries[397].get_mut(&__args[..]) { if !__cu && *result.multiplicity == G::ZERO { aiur_fn_397(__args, record, io_buffer, false)? } else { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_397] = unsafe { *(result.output.as_ptr() as *const [G; OUT_397]) }; __ret } } else { aiur_fn_397(__args, record, io_buffer, __cu)? } }; let __v_26: G = __r_arr[0]; let __v_27: G = __r_arr[1]; break '__mc_1 [__v_26, __v_27]; @@ -38371,46 +38097,46 @@ fn aiur_fn_429( let __v_25: G = __mc_out___mc_1[1]; match __v_24.as_canonical_u64() { 1u64 => { - let __ret: [G; OUT_429] = [__v_25]; - if let Some(result) = record.function_queries[429].get_mut(&inp[..]) { debug_assert_eq!(result.output, &__ret[..]); if !unconstrained { *result.multiplicity += G::ONE; } } else { record.function_queries[429].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained)); }; + let __ret: [G; OUT_425] = [__v_25]; + if let Some(result) = record.function_queries[425].get_mut(&inp[..]) { debug_assert_eq!(result.output, &__ret[..]); if !unconstrained { *result.multiplicity += G::ONE; } } else { record.function_queries[425].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained)); }; return Ok(__ret); }, _ => { - let __r_arr: [G; OUT_623] = { let __args: [G; IN_623] = [__v_11, __v_12, __v_14, __v_15, __v_13]; let __cu = unconstrained; if let Some(result) = record.function_queries[623].get_mut(&__args[..]) { if !__cu && *result.multiplicity == G::ZERO { aiur_fn_623(__args, record, io_buffer, false)? } else { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_623] = unsafe { *(result.output.as_ptr() as *const [G; OUT_623]) }; __ret } } else { aiur_fn_623(__args, record, io_buffer, __cu)? } }; + let __r_arr: [G; OUT_619] = { let __args: [G; IN_619] = [__v_11, __v_12, __v_14, __v_15, __v_13]; let __cu = unconstrained; if let Some(result) = record.function_queries[619].get_mut(&__args[..]) { if !__cu && *result.multiplicity == G::ZERO { aiur_fn_619(__args, record, io_buffer, false)? } else { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_619] = unsafe { *(result.output.as_ptr() as *const [G; OUT_619]) }; __ret } } else { aiur_fn_619(__args, record, io_buffer, __cu)? } }; let __v_26: G = __r_arr[0]; - let __r_arr: [G; OUT_405] = { let __args: [G; IN_405] = [__v_1, __v_3, __v_12, __v_14, __v_15, __v_13, __v_16, __v_4, __v_2, __v_26]; let __cu = unconstrained; if let Some(result) = record.function_queries[405].get_mut(&__args[..]) { if !__cu && *result.multiplicity == G::ZERO { aiur_fn_405(__args, record, io_buffer, false)? } else { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_405] = unsafe { *(result.output.as_ptr() as *const [G; OUT_405]) }; __ret } } else { aiur_fn_405(__args, record, io_buffer, __cu)? } }; + let __r_arr: [G; OUT_401] = { let __args: [G; IN_401] = [__v_1, __v_3, __v_12, __v_14, __v_15, __v_13, __v_16, __v_4, __v_2, __v_26]; let __cu = unconstrained; if let Some(result) = record.function_queries[401].get_mut(&__args[..]) { if !__cu && *result.multiplicity == G::ZERO { aiur_fn_401(__args, record, io_buffer, false)? } else { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_401] = unsafe { *(result.output.as_ptr() as *const [G; OUT_401]) }; __ret } } else { aiur_fn_401(__args, record, io_buffer, __cu)? } }; let __v_27: G = __r_arr[0]; let __v_28: G = __r_arr[1]; match __v_27.as_canonical_u64() { 1u64 => { - let __r_arr: [G; OUT_424] = { let __args: [G; IN_424] = [__v_28, __v_4]; let __cu = unconstrained; if let Some(result) = record.function_queries[424].get_mut(&__args[..]) { if !__cu && *result.multiplicity == G::ZERO { aiur_fn_424(__args, record, io_buffer, false)? } else { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_424] = unsafe { *(result.output.as_ptr() as *const [G; OUT_424]) }; __ret } } else { aiur_fn_424(__args, record, io_buffer, __cu)? } }; + let __r_arr: [G; OUT_420] = { let __args: [G; IN_420] = [__v_28, __v_4]; let __cu = unconstrained; if let Some(result) = record.function_queries[420].get_mut(&__args[..]) { if !__cu && *result.multiplicity == G::ZERO { aiur_fn_420(__args, record, io_buffer, false)? } else { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_420] = unsafe { *(result.output.as_ptr() as *const [G; OUT_420]) }; __ret } } else { aiur_fn_420(__args, record, io_buffer, __cu)? } }; let __v_29: G = __r_arr[0]; - let __ret: [G; OUT_429] = [__v_29]; - if let Some(result) = record.function_queries[429].get_mut(&inp[..]) { debug_assert_eq!(result.output, &__ret[..]); if !unconstrained { *result.multiplicity += G::ONE; } } else { record.function_queries[429].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained)); }; + let __ret: [G; OUT_425] = [__v_29]; + if let Some(result) = record.function_queries[425].get_mut(&inp[..]) { debug_assert_eq!(result.output, &__ret[..]); if !unconstrained { *result.multiplicity += G::ONE; } } else { record.function_queries[425].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained)); }; return Ok(__ret); }, 2u64 => { match __v_17.as_canonical_u64() { 1u64 => { - let __ret: [G; OUT_429] = [__v_28]; - if let Some(result) = record.function_queries[429].get_mut(&inp[..]) { debug_assert_eq!(result.output, &__ret[..]); if !unconstrained { *result.multiplicity += G::ONE; } } else { record.function_queries[429].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained)); }; + let __ret: [G; OUT_425] = [__v_28]; + if let Some(result) = record.function_queries[425].get_mut(&inp[..]) { debug_assert_eq!(result.output, &__ret[..]); if !unconstrained { *result.multiplicity += G::ONE; } } else { record.function_queries[425].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained)); }; return Ok(__ret); }, _ => { - let __r_arr: [G; OUT_408] = { let __args: [G; IN_408] = [__v_11, __v_1, __v_3, __v_12, __v_14, __v_15, __v_13, __v_16, __v_4]; let __cu = unconstrained; if let Some(result) = record.function_queries[408].get_mut(&__args[..]) { if !__cu && *result.multiplicity == G::ZERO { aiur_fn_408(__args, record, io_buffer, false)? } else { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_408] = unsafe { *(result.output.as_ptr() as *const [G; OUT_408]) }; __ret } } else { aiur_fn_408(__args, record, io_buffer, __cu)? } }; + let __r_arr: [G; OUT_404] = { let __args: [G; IN_404] = [__v_11, __v_1, __v_3, __v_12, __v_14, __v_15, __v_13, __v_16, __v_4]; let __cu = unconstrained; if let Some(result) = record.function_queries[404].get_mut(&__args[..]) { if !__cu && *result.multiplicity == G::ZERO { aiur_fn_404(__args, record, io_buffer, false)? } else { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_404] = unsafe { *(result.output.as_ptr() as *const [G; OUT_404]) }; __ret } } else { aiur_fn_404(__args, record, io_buffer, __cu)? } }; let __v_29: G = __r_arr[0]; let __v_30: G = __r_arr[1]; match __v_29.as_canonical_u64() { 1u64 => { - let __r_arr: [G; OUT_424] = { let __args: [G; IN_424] = [__v_30, __v_4]; let __cu = unconstrained; if let Some(result) = record.function_queries[424].get_mut(&__args[..]) { if !__cu && *result.multiplicity == G::ZERO { aiur_fn_424(__args, record, io_buffer, false)? } else { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_424] = unsafe { *(result.output.as_ptr() as *const [G; OUT_424]) }; __ret } } else { aiur_fn_424(__args, record, io_buffer, __cu)? } }; + let __r_arr: [G; OUT_420] = { let __args: [G; IN_420] = [__v_30, __v_4]; let __cu = unconstrained; if let Some(result) = record.function_queries[420].get_mut(&__args[..]) { if !__cu && *result.multiplicity == G::ZERO { aiur_fn_420(__args, record, io_buffer, false)? } else { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_420] = unsafe { *(result.output.as_ptr() as *const [G; OUT_420]) }; __ret } } else { aiur_fn_420(__args, record, io_buffer, __cu)? } }; let __v_31: G = __r_arr[0]; - let __ret: [G; OUT_429] = [__v_31]; - if let Some(result) = record.function_queries[429].get_mut(&inp[..]) { debug_assert_eq!(result.output, &__ret[..]); if !unconstrained { *result.multiplicity += G::ONE; } } else { record.function_queries[429].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained)); }; + let __ret: [G; OUT_425] = [__v_31]; + if let Some(result) = record.function_queries[425].get_mut(&inp[..]) { debug_assert_eq!(result.output, &__ret[..]); if !unconstrained { *result.multiplicity += G::ONE; } } else { record.function_queries[425].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained)); }; return Ok(__ret); }, _ => { - let __ret: [G; OUT_429] = [__v_28]; - if let Some(result) = record.function_queries[429].get_mut(&inp[..]) { debug_assert_eq!(result.output, &__ret[..]); if !unconstrained { *result.multiplicity += G::ONE; } } else { record.function_queries[429].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained)); }; + let __ret: [G; OUT_425] = [__v_28]; + if let Some(result) = record.function_queries[425].get_mut(&inp[..]) { debug_assert_eq!(result.output, &__ret[..]); if !unconstrained { *result.multiplicity += G::ONE; } } else { record.function_queries[425].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained)); }; return Ok(__ret); }, } @@ -38418,10 +38144,10 @@ fn aiur_fn_429( } }, _ => { - let __r_arr: [G; OUT_255] = { let __args: [G; IN_255] = [__v_2, __v_3]; let __cu = unconstrained; if let Some(result) = record.function_queries[255].get_mut(&__args[..]) { if !__cu && *result.multiplicity == G::ZERO { aiur_fn_255(__args, record, io_buffer, false)? } else { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_255] = unsafe { *(result.output.as_ptr() as *const [G; OUT_255]) }; __ret } } else { aiur_fn_255(__args, record, io_buffer, __cu)? } }; + let __r_arr: [G; OUT_251] = { let __args: [G; IN_251] = [__v_2, __v_3]; let __cu = unconstrained; if let Some(result) = record.function_queries[251].get_mut(&__args[..]) { if !__cu && *result.multiplicity == G::ZERO { aiur_fn_251(__args, record, io_buffer, false)? } else { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_251] = unsafe { *(result.output.as_ptr() as *const [G; OUT_251]) }; __ret } } else { aiur_fn_251(__args, record, io_buffer, __cu)? } }; let __v_29: G = __r_arr[0]; - let __ret: [G; OUT_429] = [__v_29]; - if let Some(result) = record.function_queries[429].get_mut(&inp[..]) { debug_assert_eq!(result.output, &__ret[..]); if !unconstrained { *result.multiplicity += G::ONE; } } else { record.function_queries[429].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained)); }; + let __ret: [G; OUT_425] = [__v_29]; + if let Some(result) = record.function_queries[425].get_mut(&inp[..]) { debug_assert_eq!(result.output, &__ret[..]); if !unconstrained { *result.multiplicity += G::ONE; } } else { record.function_queries[425].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained)); }; return Ok(__ret); }, } @@ -38429,10 +38155,10 @@ fn aiur_fn_429( } }, _ => { - let __r_arr: [G; OUT_255] = { let __args: [G; IN_255] = [__v_2, __v_3]; let __cu = unconstrained; if let Some(result) = record.function_queries[255].get_mut(&__args[..]) { if !__cu && *result.multiplicity == G::ZERO { aiur_fn_255(__args, record, io_buffer, false)? } else { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_255] = unsafe { *(result.output.as_ptr() as *const [G; OUT_255]) }; __ret } } else { aiur_fn_255(__args, record, io_buffer, __cu)? } }; + let __r_arr: [G; OUT_251] = { let __args: [G; IN_251] = [__v_2, __v_3]; let __cu = unconstrained; if let Some(result) = record.function_queries[251].get_mut(&__args[..]) { if !__cu && *result.multiplicity == G::ZERO { aiur_fn_251(__args, record, io_buffer, false)? } else { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_251] = unsafe { *(result.output.as_ptr() as *const [G; OUT_251]) }; __ret } } else { aiur_fn_251(__args, record, io_buffer, __cu)? } }; let __v_21: G = __r_arr[0]; - let __ret: [G; OUT_429] = [__v_21]; - if let Some(result) = record.function_queries[429].get_mut(&inp[..]) { debug_assert_eq!(result.output, &__ret[..]); if !unconstrained { *result.multiplicity += G::ONE; } } else { record.function_queries[429].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained)); }; + let __ret: [G; OUT_425] = [__v_21]; + if let Some(result) = record.function_queries[425].get_mut(&inp[..]) { debug_assert_eq!(result.output, &__ret[..]); if !unconstrained { *result.multiplicity += G::ONE; } } else { record.function_queries[425].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained)); }; return Ok(__ret); }, } @@ -38441,40 +38167,40 @@ fn aiur_fn_429( }) } -const INPUT_SIZE_430: usize = 2; -const IN_430: usize = 2; -const OUT_430: usize = 1; -fn aiur_fn_430( - inp: [G; IN_430], +const INPUT_SIZE_426: usize = 2; +const IN_426: usize = 2; +const OUT_426: usize = 1; +fn aiur_fn_426( + inp: [G; IN_426], record: &mut QueryRecord, io_buffer: &mut IOBuffer, unconstrained: bool, -) -> Result<[G; OUT_430], ExecError> { +) -> Result<[G; OUT_426], ExecError> { stacker::maybe_grow(64 * 1024, 4 * 1024 * 1024, || { let __v_0: G = inp[0]; let __v_1: G = inp[1]; - let __r_arr: [G; OUT_766] = { let __args: [G; IN_766] = [__v_0, __v_1]; let __cu = unconstrained; if let Some(result) = record.function_queries[766].get_mut(&__args[..]) { if !__cu && *result.multiplicity == G::ZERO { aiur_fn_766(__args, record, io_buffer, false)? } else { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_766] = unsafe { *(result.output.as_ptr() as *const [G; OUT_766]) }; __ret } } else { aiur_fn_766(__args, record, io_buffer, __cu)? } }; + let __r_arr: [G; OUT_762] = { let __args: [G; IN_762] = [__v_0, __v_1]; let __cu = unconstrained; if let Some(result) = record.function_queries[762].get_mut(&__args[..]) { if !__cu && *result.multiplicity == G::ZERO { aiur_fn_762(__args, record, io_buffer, false)? } else { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_762] = unsafe { *(result.output.as_ptr() as *const [G; OUT_762]) }; __ret } } else { aiur_fn_762(__args, record, io_buffer, __cu)? } }; let __v_2: G = __r_arr[0]; let __v_3: G = G::from_u64(1); let __v_4: G = (__v_1 + __v_3); let __v_5: G = G::from_u64(0); - let __r_arr: [G; OUT_359] = { let __args: [G; IN_359] = [__v_2, __v_4, __v_5]; let __cu = unconstrained; if let Some(result) = record.function_queries[359].get_mut(&__args[..]) { if !__cu && *result.multiplicity == G::ZERO { aiur_fn_359(__args, record, io_buffer, false)? } else { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_359] = unsafe { *(result.output.as_ptr() as *const [G; OUT_359]) }; __ret } } else { aiur_fn_359(__args, record, io_buffer, __cu)? } }; + let __r_arr: [G; OUT_355] = { let __args: [G; IN_355] = [__v_2, __v_4, __v_5]; let __cu = unconstrained; if let Some(result) = record.function_queries[355].get_mut(&__args[..]) { if !__cu && *result.multiplicity == G::ZERO { aiur_fn_355(__args, record, io_buffer, false)? } else { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_355] = unsafe { *(result.output.as_ptr() as *const [G; OUT_355]) }; __ret } } else { aiur_fn_355(__args, record, io_buffer, __cu)? } }; let __v_6: G = __r_arr[0]; - let __ret: [G; OUT_430] = [__v_6]; - if let Some(result) = record.function_queries[430].get_mut(&inp[..]) { debug_assert_eq!(result.output, &__ret[..]); if !unconstrained { *result.multiplicity += G::ONE; } } else { record.function_queries[430].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained)); }; + let __ret: [G; OUT_426] = [__v_6]; + if let Some(result) = record.function_queries[426].get_mut(&inp[..]) { debug_assert_eq!(result.output, &__ret[..]); if !unconstrained { *result.multiplicity += G::ONE; } } else { record.function_queries[426].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained)); }; return Ok(__ret); }) } -const INPUT_SIZE_431: usize = 12; -const IN_431: usize = 12; -const OUT_431: usize = 1; -fn aiur_fn_431( - inp: [G; IN_431], +const INPUT_SIZE_427: usize = 12; +const IN_427: usize = 12; +const OUT_427: usize = 1; +fn aiur_fn_427( + inp: [G; IN_427], record: &mut QueryRecord, io_buffer: &mut IOBuffer, unconstrained: bool, -) -> Result<[G; OUT_431], ExecError> { +) -> Result<[G; OUT_427], ExecError> { stacker::maybe_grow(64 * 1024, 4 * 1024 * 1024, || { let __v_0: G = inp[0]; let __v_1: G = inp[1]; @@ -38490,43 +38216,43 @@ fn aiur_fn_431( let __v_11: G = inp[11]; match __v_0.as_canonical_u64() { 0u64 => { - let __ret: [G; OUT_431] = [__v_1]; - if let Some(result) = record.function_queries[431].get_mut(&inp[..]) { debug_assert_eq!(result.output, &__ret[..]); if !unconstrained { *result.multiplicity += G::ONE; } } else { record.function_queries[431].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained)); }; + let __ret: [G; OUT_427] = [__v_1]; + if let Some(result) = record.function_queries[427].get_mut(&inp[..]) { debug_assert_eq!(result.output, &__ret[..]); if !unconstrained { *result.multiplicity += G::ONE; } } else { record.function_queries[427].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained)); }; return Ok(__ret); }, 1u64 => { - let __ret: [G; OUT_431] = [__v_1]; - if let Some(result) = record.function_queries[431].get_mut(&inp[..]) { debug_assert_eq!(result.output, &__ret[..]); if !unconstrained { *result.multiplicity += G::ONE; } } else { record.function_queries[431].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained)); }; + let __ret: [G; OUT_427] = [__v_1]; + if let Some(result) = record.function_queries[427].get_mut(&inp[..]) { debug_assert_eq!(result.output, &__ret[..]); if !unconstrained { *result.multiplicity += G::ONE; } } else { record.function_queries[427].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained)); }; return Ok(__ret); }, 2u64 => { - let __ret: [G; OUT_431] = [__v_1]; - if let Some(result) = record.function_queries[431].get_mut(&inp[..]) { debug_assert_eq!(result.output, &__ret[..]); if !unconstrained { *result.multiplicity += G::ONE; } } else { record.function_queries[431].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained)); }; + let __ret: [G; OUT_427] = [__v_1]; + if let Some(result) = record.function_queries[427].get_mut(&inp[..]) { debug_assert_eq!(result.output, &__ret[..]); if !unconstrained { *result.multiplicity += G::ONE; } } else { record.function_queries[427].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained)); }; return Ok(__ret); }, 3u64 => { - let __ret: [G; OUT_431] = [__v_1]; - if let Some(result) = record.function_queries[431].get_mut(&inp[..]) { debug_assert_eq!(result.output, &__ret[..]); if !unconstrained { *result.multiplicity += G::ONE; } } else { record.function_queries[431].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained)); }; + let __ret: [G; OUT_427] = [__v_1]; + if let Some(result) = record.function_queries[427].get_mut(&inp[..]) { debug_assert_eq!(result.output, &__ret[..]); if !unconstrained { *result.multiplicity += G::ONE; } } else { record.function_queries[427].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained)); }; return Ok(__ret); }, 4u64 => { - let __ret: [G; OUT_431] = [__v_1]; - if let Some(result) = record.function_queries[431].get_mut(&inp[..]) { debug_assert_eq!(result.output, &__ret[..]); if !unconstrained { *result.multiplicity += G::ONE; } } else { record.function_queries[431].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained)); }; + let __ret: [G; OUT_427] = [__v_1]; + if let Some(result) = record.function_queries[427].get_mut(&inp[..]) { debug_assert_eq!(result.output, &__ret[..]); if !unconstrained { *result.multiplicity += G::ONE; } } else { record.function_queries[427].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained)); }; return Ok(__ret); }, 5u64 => { - let __ret: [G; OUT_431] = [__v_1]; - if let Some(result) = record.function_queries[431].get_mut(&inp[..]) { debug_assert_eq!(result.output, &__ret[..]); if !unconstrained { *result.multiplicity += G::ONE; } } else { record.function_queries[431].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained)); }; + let __ret: [G; OUT_427] = [__v_1]; + if let Some(result) = record.function_queries[427].get_mut(&inp[..]) { debug_assert_eq!(result.output, &__ret[..]); if !unconstrained { *result.multiplicity += G::ONE; } } else { record.function_queries[427].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained)); }; return Ok(__ret); }, 6u64 => { - let __ret: [G; OUT_431] = [__v_1]; - if let Some(result) = record.function_queries[431].get_mut(&inp[..]) { debug_assert_eq!(result.output, &__ret[..]); if !unconstrained { *result.multiplicity += G::ONE; } } else { record.function_queries[431].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained)); }; + let __ret: [G; OUT_427] = [__v_1]; + if let Some(result) = record.function_queries[427].get_mut(&inp[..]) { debug_assert_eq!(result.output, &__ret[..]); if !unconstrained { *result.multiplicity += G::ONE; } } else { record.function_queries[427].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained)); }; return Ok(__ret); }, 7u64 => { - let __ret: [G; OUT_431] = [__v_1]; - if let Some(result) = record.function_queries[431].get_mut(&inp[..]) { debug_assert_eq!(result.output, &__ret[..]); if !unconstrained { *result.multiplicity += G::ONE; } } else { record.function_queries[431].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained)); }; + let __ret: [G; OUT_427] = [__v_1]; + if let Some(result) = record.function_queries[427].get_mut(&inp[..]) { debug_assert_eq!(result.output, &__ret[..]); if !unconstrained { *result.multiplicity += G::ONE; } } else { record.function_queries[427].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained)); }; return Ok(__ret); }, _ => { @@ -38536,15 +38262,15 @@ fn aiur_fn_431( }) } -const INPUT_SIZE_432: usize = 12; -const IN_432: usize = 12; -const OUT_432: usize = 1; -fn aiur_fn_432( - inp: [G; IN_432], +const INPUT_SIZE_428: usize = 12; +const IN_428: usize = 12; +const OUT_428: usize = 1; +fn aiur_fn_428( + inp: [G; IN_428], record: &mut QueryRecord, io_buffer: &mut IOBuffer, unconstrained: bool, -) -> Result<[G; OUT_432], ExecError> { +) -> Result<[G; OUT_428], ExecError> { stacker::maybe_grow(64 * 1024, 4 * 1024 * 1024, || { let __v_0: G = inp[0]; let __v_1: G = inp[1]; @@ -38560,43 +38286,43 @@ fn aiur_fn_432( let __v_11: G = inp[11]; match __v_0.as_canonical_u64() { 0u64 => { - let __ret: [G; OUT_432] = [__v_2]; - if let Some(result) = record.function_queries[432].get_mut(&inp[..]) { debug_assert_eq!(result.output, &__ret[..]); if !unconstrained { *result.multiplicity += G::ONE; } } else { record.function_queries[432].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained)); }; + let __ret: [G; OUT_428] = [__v_2]; + if let Some(result) = record.function_queries[428].get_mut(&inp[..]) { debug_assert_eq!(result.output, &__ret[..]); if !unconstrained { *result.multiplicity += G::ONE; } } else { record.function_queries[428].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained)); }; return Ok(__ret); }, 1u64 => { - let __ret: [G; OUT_432] = [__v_2]; - if let Some(result) = record.function_queries[432].get_mut(&inp[..]) { debug_assert_eq!(result.output, &__ret[..]); if !unconstrained { *result.multiplicity += G::ONE; } } else { record.function_queries[432].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained)); }; + let __ret: [G; OUT_428] = [__v_2]; + if let Some(result) = record.function_queries[428].get_mut(&inp[..]) { debug_assert_eq!(result.output, &__ret[..]); if !unconstrained { *result.multiplicity += G::ONE; } } else { record.function_queries[428].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained)); }; return Ok(__ret); }, 2u64 => { - let __ret: [G; OUT_432] = [__v_2]; - if let Some(result) = record.function_queries[432].get_mut(&inp[..]) { debug_assert_eq!(result.output, &__ret[..]); if !unconstrained { *result.multiplicity += G::ONE; } } else { record.function_queries[432].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained)); }; + let __ret: [G; OUT_428] = [__v_2]; + if let Some(result) = record.function_queries[428].get_mut(&inp[..]) { debug_assert_eq!(result.output, &__ret[..]); if !unconstrained { *result.multiplicity += G::ONE; } } else { record.function_queries[428].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained)); }; return Ok(__ret); }, 3u64 => { - let __ret: [G; OUT_432] = [__v_2]; - if let Some(result) = record.function_queries[432].get_mut(&inp[..]) { debug_assert_eq!(result.output, &__ret[..]); if !unconstrained { *result.multiplicity += G::ONE; } } else { record.function_queries[432].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained)); }; + let __ret: [G; OUT_428] = [__v_2]; + if let Some(result) = record.function_queries[428].get_mut(&inp[..]) { debug_assert_eq!(result.output, &__ret[..]); if !unconstrained { *result.multiplicity += G::ONE; } } else { record.function_queries[428].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained)); }; return Ok(__ret); }, 4u64 => { - let __ret: [G; OUT_432] = [__v_2]; - if let Some(result) = record.function_queries[432].get_mut(&inp[..]) { debug_assert_eq!(result.output, &__ret[..]); if !unconstrained { *result.multiplicity += G::ONE; } } else { record.function_queries[432].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained)); }; + let __ret: [G; OUT_428] = [__v_2]; + if let Some(result) = record.function_queries[428].get_mut(&inp[..]) { debug_assert_eq!(result.output, &__ret[..]); if !unconstrained { *result.multiplicity += G::ONE; } } else { record.function_queries[428].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained)); }; return Ok(__ret); }, 5u64 => { - let __ret: [G; OUT_432] = [__v_2]; - if let Some(result) = record.function_queries[432].get_mut(&inp[..]) { debug_assert_eq!(result.output, &__ret[..]); if !unconstrained { *result.multiplicity += G::ONE; } } else { record.function_queries[432].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained)); }; + let __ret: [G; OUT_428] = [__v_2]; + if let Some(result) = record.function_queries[428].get_mut(&inp[..]) { debug_assert_eq!(result.output, &__ret[..]); if !unconstrained { *result.multiplicity += G::ONE; } } else { record.function_queries[428].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained)); }; return Ok(__ret); }, 6u64 => { - let __ret: [G; OUT_432] = [__v_2]; - if let Some(result) = record.function_queries[432].get_mut(&inp[..]) { debug_assert_eq!(result.output, &__ret[..]); if !unconstrained { *result.multiplicity += G::ONE; } } else { record.function_queries[432].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained)); }; + let __ret: [G; OUT_428] = [__v_2]; + if let Some(result) = record.function_queries[428].get_mut(&inp[..]) { debug_assert_eq!(result.output, &__ret[..]); if !unconstrained { *result.multiplicity += G::ONE; } } else { record.function_queries[428].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained)); }; return Ok(__ret); }, 7u64 => { - let __ret: [G; OUT_432] = [__v_2]; - if let Some(result) = record.function_queries[432].get_mut(&inp[..]) { debug_assert_eq!(result.output, &__ret[..]); if !unconstrained { *result.multiplicity += G::ONE; } } else { record.function_queries[432].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained)); }; + let __ret: [G; OUT_428] = [__v_2]; + if let Some(result) = record.function_queries[428].get_mut(&inp[..]) { debug_assert_eq!(result.output, &__ret[..]); if !unconstrained { *result.multiplicity += G::ONE; } } else { record.function_queries[428].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained)); }; return Ok(__ret); }, _ => { @@ -38606,21 +38332,21 @@ fn aiur_fn_432( }) } -const INPUT_SIZE_433: usize = 2; -const IN_433: usize = 2; -const OUT_433: usize = 1; -fn aiur_fn_433( - inp: [G; IN_433], +const INPUT_SIZE_429: usize = 2; +const IN_429: usize = 2; +const OUT_429: usize = 1; +fn aiur_fn_429( + inp: [G; IN_429], record: &mut QueryRecord, io_buffer: &mut IOBuffer, unconstrained: bool, -) -> Result<[G; OUT_433], ExecError> { +) -> Result<[G; OUT_429], ExecError> { stacker::maybe_grow(64 * 1024, 4 * 1024 * 1024, || { let __v_0: G = inp[0]; let __v_1: G = inp[1]; - let __r_arr: [G; OUT_341] = { let __args: [G; IN_341] = [__v_0]; let __cu = unconstrained; if let Some(result) = record.function_queries[341].get_mut(&__args[..]) { if !__cu && *result.multiplicity == G::ZERO { aiur_fn_341(__args, record, io_buffer, false)? } else { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_341] = unsafe { *(result.output.as_ptr() as *const [G; OUT_341]) }; __ret } } else { aiur_fn_341(__args, record, io_buffer, __cu)? } }; + let __r_arr: [G; OUT_337] = { let __args: [G; IN_337] = [__v_0]; let __cu = unconstrained; if let Some(result) = record.function_queries[337].get_mut(&__args[..]) { if !__cu && *result.multiplicity == G::ZERO { aiur_fn_337(__args, record, io_buffer, false)? } else { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_337] = unsafe { *(result.output.as_ptr() as *const [G; OUT_337]) }; __ret } } else { aiur_fn_337(__args, record, io_buffer, __cu)? } }; let __v_2: G = __r_arr[0]; - let __r_arr: [G; OUT_354] = { let __args: [G; IN_354] = [__v_1, __v_2]; let __cu = unconstrained; if let Some(result) = record.function_queries[354].get_mut(&__args[..]) { if !__cu && *result.multiplicity == G::ZERO { aiur_fn_354(__args, record, io_buffer, false)? } else { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_354] = unsafe { *(result.output.as_ptr() as *const [G; OUT_354]) }; __ret } } else { aiur_fn_354(__args, record, io_buffer, __cu)? } }; + let __r_arr: [G; OUT_350] = { let __args: [G; IN_350] = [__v_1, __v_2]; let __cu = unconstrained; if let Some(result) = record.function_queries[350].get_mut(&__args[..]) { if !__cu && *result.multiplicity == G::ZERO { aiur_fn_350(__args, record, io_buffer, false)? } else { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_350] = unsafe { *(result.output.as_ptr() as *const [G; OUT_350]) }; __ret } } else { aiur_fn_350(__args, record, io_buffer, __cu)? } }; let __v_3: G = __r_arr[0]; let __loaded: [G; 4] = { let __mq = record.memory_queries.get_mut(&4).ok_or(ExecError::InvalidMemorySize(4))?; let __ptr_u64 = __v_0.as_canonical_u64(); let __ptr_usize = usize::try_from(__ptr_u64).ok().ok_or(ExecError::PointerTooLarge(__ptr_u64))?; let (__args, __mult) = __mq.get_index_mut(__ptr_usize).ok_or(ExecError::UnboundPointer { ptr: __ptr_u64, size: 4 })?; if !unconstrained { *__mult += G::ONE; } let __arr: [G; 4] = __args[..4].try_into().unwrap(); __arr }; let __v_4: G = __loaded[0]; @@ -38629,15 +38355,15 @@ fn aiur_fn_433( let __v_7: G = __loaded[3]; match __v_4.as_canonical_u64() { 0u64 => { - let __r_arr: [G; OUT_766] = { let __args: [G; IN_766] = [__v_3, __v_5]; let __cu = unconstrained; if let Some(result) = record.function_queries[766].get_mut(&__args[..]) { if !__cu && *result.multiplicity == G::ZERO { aiur_fn_766(__args, record, io_buffer, false)? } else { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_766] = unsafe { *(result.output.as_ptr() as *const [G; OUT_766]) }; __ret } } else { aiur_fn_766(__args, record, io_buffer, __cu)? } }; + let __r_arr: [G; OUT_762] = { let __args: [G; IN_762] = [__v_3, __v_5]; let __cu = unconstrained; if let Some(result) = record.function_queries[762].get_mut(&__args[..]) { if !__cu && *result.multiplicity == G::ZERO { aiur_fn_762(__args, record, io_buffer, false)? } else { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_762] = unsafe { *(result.output.as_ptr() as *const [G; OUT_762]) }; __ret } } else { aiur_fn_762(__args, record, io_buffer, __cu)? } }; let __v_8: G = __r_arr[0]; let __v_9: G = G::from_u64(1); let __v_10: G = (__v_5 + __v_9); let __v_11: G = G::from_u64(0); - let __r_arr: [G; OUT_359] = { let __args: [G; IN_359] = [__v_8, __v_10, __v_11]; let __cu = unconstrained; if let Some(result) = record.function_queries[359].get_mut(&__args[..]) { if !__cu && *result.multiplicity == G::ZERO { aiur_fn_359(__args, record, io_buffer, false)? } else { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_359] = unsafe { *(result.output.as_ptr() as *const [G; OUT_359]) }; __ret } } else { aiur_fn_359(__args, record, io_buffer, __cu)? } }; + let __r_arr: [G; OUT_355] = { let __args: [G; IN_355] = [__v_8, __v_10, __v_11]; let __cu = unconstrained; if let Some(result) = record.function_queries[355].get_mut(&__args[..]) { if !__cu && *result.multiplicity == G::ZERO { aiur_fn_355(__args, record, io_buffer, false)? } else { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_355] = unsafe { *(result.output.as_ptr() as *const [G; OUT_355]) }; __ret } } else { aiur_fn_355(__args, record, io_buffer, __cu)? } }; let __v_12: G = __r_arr[0]; - let __ret: [G; OUT_433] = [__v_12]; - if let Some(result) = record.function_queries[433].get_mut(&inp[..]) { debug_assert_eq!(result.output, &__ret[..]); if !unconstrained { *result.multiplicity += G::ONE; } } else { record.function_queries[433].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained)); }; + let __ret: [G; OUT_429] = [__v_12]; + if let Some(result) = record.function_queries[429].get_mut(&inp[..]) { debug_assert_eq!(result.output, &__ret[..]); if !unconstrained { *result.multiplicity += G::ONE; } } else { record.function_queries[429].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained)); }; return Ok(__ret); }, 1u64 => { @@ -38645,16 +38371,16 @@ fn aiur_fn_433( let __v_9: G = G::from_u64(1); let __v_10: G = G::from_u64(0); let __v_11: G = { let __values: [G; 3] = [__v_9, __v_5, __v_10]; let __mq = record.memory_queries.get_mut(&3).ok_or(ExecError::InvalidMemorySize(3))?; if let Some(result) = __mq.get_mut(&__values[..]) { if !unconstrained { *result.multiplicity += G::ONE; } result.output[0] } else { let __ptr = G::from_usize(__mq.len()); __mq.insert(&__values[..], &[__ptr], G::from_bool(!unconstrained)); __ptr } }; - let __r_arr: [G; OUT_333] = { let __args: [G; IN_333] = [__v_11]; let __cu = unconstrained; if let Some(result) = record.function_queries[333].get_mut(&__args[..]) { if !__cu && *result.multiplicity == G::ZERO { aiur_fn_333(__args, record, io_buffer, false)? } else { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_333] = unsafe { *(result.output.as_ptr() as *const [G; OUT_333]) }; __ret } } else { aiur_fn_333(__args, record, io_buffer, __cu)? } }; + let __r_arr: [G; OUT_329] = { let __args: [G; IN_329] = [__v_11]; let __cu = unconstrained; if let Some(result) = record.function_queries[329].get_mut(&__args[..]) { if !__cu && *result.multiplicity == G::ZERO { aiur_fn_329(__args, record, io_buffer, false)? } else { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_329] = unsafe { *(result.output.as_ptr() as *const [G; OUT_329]) }; __ret } } else { aiur_fn_329(__args, record, io_buffer, __cu)? } }; let __v_12: G = __r_arr[0]; let __v_13: G = G::from_u64(0); let __v_14: G = { let __values: [G; 4] = [__v_8, __v_12, __v_13, __v_13]; let __mq = record.memory_queries.get_mut(&4).ok_or(ExecError::InvalidMemorySize(4))?; if let Some(result) = __mq.get_mut(&__values[..]) { if !unconstrained { *result.multiplicity += G::ONE; } result.output[0] } else { let __ptr = G::from_usize(__mq.len()); __mq.insert(&__values[..], &[__ptr], G::from_bool(!unconstrained)); __ptr } }; - let __ret: [G; OUT_433] = [__v_14]; - if let Some(result) = record.function_queries[433].get_mut(&inp[..]) { debug_assert_eq!(result.output, &__ret[..]); if !unconstrained { *result.multiplicity += G::ONE; } } else { record.function_queries[433].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained)); }; + let __ret: [G; OUT_429] = [__v_14]; + if let Some(result) = record.function_queries[429].get_mut(&inp[..]) { debug_assert_eq!(result.output, &__ret[..]); if !unconstrained { *result.multiplicity += G::ONE; } } else { record.function_queries[429].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained)); }; return Ok(__ret); }, 2u64 => { - let __r_arr: [G; OUT_287] = { let __args: [G; IN_287] = [__v_5]; let __cu = unconstrained; if let Some(result) = record.function_queries[287].get_mut(&__args[..]) { if !__cu && *result.multiplicity == G::ZERO { aiur_fn_287(__args, record, io_buffer, false)? } else { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_287] = unsafe { *(result.output.as_ptr() as *const [G; OUT_287]) }; __ret } } else { aiur_fn_287(__args, record, io_buffer, __cu)? } }; + let __r_arr: [G; OUT_283] = { let __args: [G; IN_283] = [__v_5]; let __cu = unconstrained; if let Some(result) = record.function_queries[283].get_mut(&__args[..]) { if !__cu && *result.multiplicity == G::ZERO { aiur_fn_283(__args, record, io_buffer, false)? } else { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_283] = unsafe { *(result.output.as_ptr() as *const [G; OUT_283]) }; __ret } } else { aiur_fn_283(__args, record, io_buffer, __cu)? } }; let __v_8: G = __r_arr[0]; let __loaded: [G; 12] = { let __mq = record.memory_queries.get_mut(&12).ok_or(ExecError::InvalidMemorySize(12))?; let __ptr_u64 = __v_8.as_canonical_u64(); let __ptr_usize = usize::try_from(__ptr_u64).ok().ok_or(ExecError::PointerTooLarge(__ptr_u64))?; let (__args, __mult) = __mq.get_index_mut(__ptr_usize).ok_or(ExecError::UnboundPointer { ptr: __ptr_u64, size: 12 })?; if !unconstrained { *__mult += G::ONE; } let __arr: [G; 12] = __args[..12].try_into().unwrap(); __arr }; let __v_9: G = __loaded[0]; @@ -38669,23 +38395,23 @@ fn aiur_fn_433( let __v_18: G = __loaded[9]; let __v_19: G = __loaded[10]; let __v_20: G = __loaded[11]; - let __r_arr: [G; OUT_431] = { let __args: [G; IN_431] = [__v_9, __v_10, __v_11, __v_12, __v_13, __v_14, __v_15, __v_16, __v_17, __v_18, __v_19, __v_20]; let __cu = unconstrained; if let Some(result) = record.function_queries[431].get_mut(&__args[..]) { if !__cu && *result.multiplicity == G::ZERO { aiur_fn_431(__args, record, io_buffer, false)? } else { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_431] = unsafe { *(result.output.as_ptr() as *const [G; OUT_431]) }; __ret } } else { aiur_fn_431(__args, record, io_buffer, __cu)? } }; + let __r_arr: [G; OUT_427] = { let __args: [G; IN_427] = [__v_9, __v_10, __v_11, __v_12, __v_13, __v_14, __v_15, __v_16, __v_17, __v_18, __v_19, __v_20]; let __cu = unconstrained; if let Some(result) = record.function_queries[427].get_mut(&__args[..]) { if !__cu && *result.multiplicity == G::ZERO { aiur_fn_427(__args, record, io_buffer, false)? } else { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_427] = unsafe { *(result.output.as_ptr() as *const [G; OUT_427]) }; __ret } } else { aiur_fn_427(__args, record, io_buffer, __cu)? } }; let __v_21: G = __r_arr[0]; - let __r_arr: [G; OUT_432] = { let __args: [G; IN_432] = [__v_9, __v_10, __v_11, __v_12, __v_13, __v_14, __v_15, __v_16, __v_17, __v_18, __v_19, __v_20]; let __cu = unconstrained; if let Some(result) = record.function_queries[432].get_mut(&__args[..]) { if !__cu && *result.multiplicity == G::ZERO { aiur_fn_432(__args, record, io_buffer, false)? } else { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_432] = unsafe { *(result.output.as_ptr() as *const [G; OUT_432]) }; __ret } } else { aiur_fn_432(__args, record, io_buffer, __cu)? } }; + let __r_arr: [G; OUT_428] = { let __args: [G; IN_428] = [__v_9, __v_10, __v_11, __v_12, __v_13, __v_14, __v_15, __v_16, __v_17, __v_18, __v_19, __v_20]; let __cu = unconstrained; if let Some(result) = record.function_queries[428].get_mut(&__args[..]) { if !__cu && *result.multiplicity == G::ZERO { aiur_fn_428(__args, record, io_buffer, false)? } else { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_428] = unsafe { *(result.output.as_ptr() as *const [G; OUT_428]) }; __ret } } else { aiur_fn_428(__args, record, io_buffer, __cu)? } }; let __v_22: G = __r_arr[0]; - let __r_arr: [G; OUT_764] = { let __args: [G; IN_764] = [__v_6]; let __cu = unconstrained; if let Some(result) = record.function_queries[764].get_mut(&__args[..]) { if !__cu && *result.multiplicity == G::ZERO { aiur_fn_764(__args, record, io_buffer, false)? } else { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_764] = unsafe { *(result.output.as_ptr() as *const [G; OUT_764]) }; __ret } } else { aiur_fn_764(__args, record, io_buffer, __cu)? } }; + let __r_arr: [G; OUT_760] = { let __args: [G; IN_760] = [__v_6]; let __cu = unconstrained; if let Some(result) = record.function_queries[760].get_mut(&__args[..]) { if !__cu && *result.multiplicity == G::ZERO { aiur_fn_760(__args, record, io_buffer, false)? } else { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_760] = unsafe { *(result.output.as_ptr() as *const [G; OUT_760]) }; __ret } } else { aiur_fn_760(__args, record, io_buffer, __cu)? } }; let __v_23: G = __r_arr[0]; if (__v_23 != __v_21) { return Err(ExecError::AssertEqMismatch { lhs: __v_23.as_canonical_u64(), rhs: __v_21.as_canonical_u64(), msg: Some("Const applied to wrong number of universe levels".to_string()) }); } - let __r_arr: [G; OUT_336] = { let __args: [G; IN_336] = [__v_22, __v_6]; let __cu = unconstrained; if let Some(result) = record.function_queries[336].get_mut(&__args[..]) { if !__cu && *result.multiplicity == G::ZERO { aiur_fn_336(__args, record, io_buffer, false)? } else { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_336] = unsafe { *(result.output.as_ptr() as *const [G; OUT_336]) }; __ret } } else { aiur_fn_336(__args, record, io_buffer, __cu)? } }; + let __r_arr: [G; OUT_332] = { let __args: [G; IN_332] = [__v_22, __v_6]; let __cu = unconstrained; if let Some(result) = record.function_queries[332].get_mut(&__args[..]) { if !__cu && *result.multiplicity == G::ZERO { aiur_fn_332(__args, record, io_buffer, false)? } else { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_332] = unsafe { *(result.output.as_ptr() as *const [G; OUT_332]) }; __ret } } else { aiur_fn_332(__args, record, io_buffer, __cu)? } }; let __v_24: G = __r_arr[0]; - let __ret: [G; OUT_433] = [__v_24]; - if let Some(result) = record.function_queries[433].get_mut(&inp[..]) { debug_assert_eq!(result.output, &__ret[..]); if !unconstrained { *result.multiplicity += G::ONE; } } else { record.function_queries[433].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained)); }; + let __ret: [G; OUT_429] = [__v_24]; + if let Some(result) = record.function_queries[429].get_mut(&inp[..]) { debug_assert_eq!(result.output, &__ret[..]); if !unconstrained { *result.multiplicity += G::ONE; } } else { record.function_queries[429].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained)); }; return Ok(__ret); }, 3u64 => { - let __r_arr: [G; OUT_433] = { let __args: [G; IN_433] = [__v_5, __v_3]; let __cu = unconstrained; if let Some(result) = record.function_queries[433].get_mut(&__args[..]) { if !__cu && *result.multiplicity == G::ZERO { aiur_fn_433(__args, record, io_buffer, false)? } else { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_433] = unsafe { *(result.output.as_ptr() as *const [G; OUT_433]) }; __ret } } else { aiur_fn_433(__args, record, io_buffer, __cu)? } }; + let __r_arr: [G; OUT_429] = { let __args: [G; IN_429] = [__v_5, __v_3]; let __cu = unconstrained; if let Some(result) = record.function_queries[429].get_mut(&__args[..]) { if !__cu && *result.multiplicity == G::ZERO { aiur_fn_429(__args, record, io_buffer, false)? } else { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_429] = unsafe { *(result.output.as_ptr() as *const [G; OUT_429]) }; __ret } } else { aiur_fn_429(__args, record, io_buffer, __cu)? } }; let __v_8: G = __r_arr[0]; let __loaded: [G; 4] = { let __mq = record.memory_queries.get_mut(&4).ok_or(ExecError::InvalidMemorySize(4))?; let __ptr_u64 = __v_8.as_canonical_u64(); let __ptr_usize = usize::try_from(__ptr_u64).ok().ok_or(ExecError::PointerTooLarge(__ptr_u64))?; let (__args, __mult) = __mq.get_index_mut(__ptr_usize).ok_or(ExecError::UnboundPointer { ptr: __ptr_u64, size: 4 })?; if !unconstrained { *__mult += G::ONE; } let __arr: [G; 4] = __args[..4].try_into().unwrap(); __arr }; let __v_9: G = __loaded[0]; @@ -38695,14 +38421,14 @@ fn aiur_fn_433( match __v_9.as_canonical_u64() { 5u64 => { let __v_13: G = G::from_u64(0); - let __r_arr: [G; OUT_368] = { let __args: [G; IN_368] = [__v_11, __v_6, __v_13]; let __cu = unconstrained; if let Some(result) = record.function_queries[368].get_mut(&__args[..]) { if !__cu && *result.multiplicity == G::ZERO { aiur_fn_368(__args, record, io_buffer, false)? } else { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_368] = unsafe { *(result.output.as_ptr() as *const [G; OUT_368]) }; __ret } } else { aiur_fn_368(__args, record, io_buffer, __cu)? } }; + let __r_arr: [G; OUT_364] = { let __args: [G; IN_364] = [__v_11, __v_6, __v_13]; let __cu = unconstrained; if let Some(result) = record.function_queries[364].get_mut(&__args[..]) { if !__cu && *result.multiplicity == G::ZERO { aiur_fn_364(__args, record, io_buffer, false)? } else { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_364] = unsafe { *(result.output.as_ptr() as *const [G; OUT_364]) }; __ret } } else { aiur_fn_364(__args, record, io_buffer, __cu)? } }; let __v_14: G = __r_arr[0]; - let __ret: [G; OUT_433] = [__v_14]; - if let Some(result) = record.function_queries[433].get_mut(&inp[..]) { debug_assert_eq!(result.output, &__ret[..]); if !unconstrained { *result.multiplicity += G::ONE; } } else { record.function_queries[433].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained)); }; + let __ret: [G; OUT_429] = [__v_14]; + if let Some(result) = record.function_queries[429].get_mut(&inp[..]) { debug_assert_eq!(result.output, &__ret[..]); if !unconstrained { *result.multiplicity += G::ONE; } } else { record.function_queries[429].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained)); }; return Ok(__ret); }, _ => { - let __r_arr: [G; OUT_418] = { let __args: [G; IN_418] = [__v_8, __v_3]; let __cu = unconstrained; if let Some(result) = record.function_queries[418].get_mut(&__args[..]) { if !__cu && *result.multiplicity == G::ZERO { aiur_fn_418(__args, record, io_buffer, false)? } else { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_418] = unsafe { *(result.output.as_ptr() as *const [G; OUT_418]) }; __ret } } else { aiur_fn_418(__args, record, io_buffer, __cu)? } }; + let __r_arr: [G; OUT_414] = { let __args: [G; IN_414] = [__v_8, __v_3]; let __cu = unconstrained; if let Some(result) = record.function_queries[414].get_mut(&__args[..]) { if !__cu && *result.multiplicity == G::ZERO { aiur_fn_414(__args, record, io_buffer, false)? } else { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_414] = unsafe { *(result.output.as_ptr() as *const [G; OUT_414]) }; __ret } } else { aiur_fn_414(__args, record, io_buffer, __cu)? } }; let __v_13: G = __r_arr[0]; let __loaded: [G; 4] = { let __mq = record.memory_queries.get_mut(&4).ok_or(ExecError::InvalidMemorySize(4))?; let __ptr_u64 = __v_13.as_canonical_u64(); let __ptr_usize = usize::try_from(__ptr_u64).ok().ok_or(ExecError::PointerTooLarge(__ptr_u64))?; let (__args, __mult) = __mq.get_index_mut(__ptr_usize).ok_or(ExecError::UnboundPointer { ptr: __ptr_u64, size: 4 })?; if !unconstrained { *__mult += G::ONE; } let __arr: [G; 4] = __args[..4].try_into().unwrap(); __arr }; let __v_14: G = __loaded[0]; @@ -38712,10 +38438,10 @@ fn aiur_fn_433( match __v_14.as_canonical_u64() { 5u64 => { let __v_18: G = G::from_u64(0); - let __r_arr: [G; OUT_368] = { let __args: [G; IN_368] = [__v_16, __v_6, __v_18]; let __cu = unconstrained; if let Some(result) = record.function_queries[368].get_mut(&__args[..]) { if !__cu && *result.multiplicity == G::ZERO { aiur_fn_368(__args, record, io_buffer, false)? } else { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_368] = unsafe { *(result.output.as_ptr() as *const [G; OUT_368]) }; __ret } } else { aiur_fn_368(__args, record, io_buffer, __cu)? } }; + let __r_arr: [G; OUT_364] = { let __args: [G; IN_364] = [__v_16, __v_6, __v_18]; let __cu = unconstrained; if let Some(result) = record.function_queries[364].get_mut(&__args[..]) { if !__cu && *result.multiplicity == G::ZERO { aiur_fn_364(__args, record, io_buffer, false)? } else { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_364] = unsafe { *(result.output.as_ptr() as *const [G; OUT_364]) }; __ret } } else { aiur_fn_364(__args, record, io_buffer, __cu)? } }; let __v_19: G = __r_arr[0]; - let __ret: [G; OUT_433] = [__v_19]; - if let Some(result) = record.function_queries[433].get_mut(&inp[..]) { debug_assert_eq!(result.output, &__ret[..]); if !unconstrained { *result.multiplicity += G::ONE; } } else { record.function_queries[433].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained)); }; + let __ret: [G; OUT_429] = [__v_19]; + if let Some(result) = record.function_queries[429].get_mut(&inp[..]) { debug_assert_eq!(result.output, &__ret[..]); if !unconstrained { *result.multiplicity += G::ONE; } } else { record.function_queries[429].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained)); }; return Ok(__ret); }, _ => { @@ -38728,67 +38454,67 @@ fn aiur_fn_433( 4u64 => { let __v_8: G = G::from_u64(0); let __v_9: G = { let __values: [G; 3] = [__v_8, __v_5, __v_3]; let __mq = record.memory_queries.get_mut(&3).ok_or(ExecError::InvalidMemorySize(3))?; if let Some(result) = __mq.get_mut(&__values[..]) { if !unconstrained { *result.multiplicity += G::ONE; } result.output[0] } else { let __ptr = G::from_usize(__mq.len()); __mq.insert(&__values[..], &[__ptr], G::from_bool(!unconstrained)); __ptr } }; - let __r_arr: [G; OUT_433] = { let __args: [G; IN_433] = [__v_6, __v_9]; let __cu = unconstrained; if let Some(result) = record.function_queries[433].get_mut(&__args[..]) { if !__cu && *result.multiplicity == G::ZERO { aiur_fn_433(__args, record, io_buffer, false)? } else { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_433] = unsafe { *(result.output.as_ptr() as *const [G; OUT_433]) }; __ret } } else { aiur_fn_433(__args, record, io_buffer, __cu)? } }; + let __r_arr: [G; OUT_429] = { let __args: [G; IN_429] = [__v_6, __v_9]; let __cu = unconstrained; if let Some(result) = record.function_queries[429].get_mut(&__args[..]) { if !__cu && *result.multiplicity == G::ZERO { aiur_fn_429(__args, record, io_buffer, false)? } else { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_429] = unsafe { *(result.output.as_ptr() as *const [G; OUT_429]) }; __ret } } else { aiur_fn_429(__args, record, io_buffer, __cu)? } }; let __v_10: G = __r_arr[0]; let __v_11: G = G::from_u64(5); let __v_12: G = G::from_u64(0); let __v_13: G = { let __values: [G; 4] = [__v_11, __v_5, __v_10, __v_12]; let __mq = record.memory_queries.get_mut(&4).ok_or(ExecError::InvalidMemorySize(4))?; if let Some(result) = __mq.get_mut(&__values[..]) { if !unconstrained { *result.multiplicity += G::ONE; } result.output[0] } else { let __ptr = G::from_usize(__mq.len()); __mq.insert(&__values[..], &[__ptr], G::from_bool(!unconstrained)); __ptr } }; - let __ret: [G; OUT_433] = [__v_13]; - if let Some(result) = record.function_queries[433].get_mut(&inp[..]) { debug_assert_eq!(result.output, &__ret[..]); if !unconstrained { *result.multiplicity += G::ONE; } } else { record.function_queries[433].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained)); }; + let __ret: [G; OUT_429] = [__v_13]; + if let Some(result) = record.function_queries[429].get_mut(&inp[..]) { debug_assert_eq!(result.output, &__ret[..]); if !unconstrained { *result.multiplicity += G::ONE; } } else { record.function_queries[429].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained)); }; return Ok(__ret); }, 5u64 => { - let __r_arr: [G; OUT_435] = { let __args: [G; IN_435] = [__v_5, __v_3]; let __cu = unconstrained; if let Some(result) = record.function_queries[435].get_mut(&__args[..]) { if !__cu && *result.multiplicity == G::ZERO { aiur_fn_435(__args, record, io_buffer, false)? } else { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_435] = unsafe { *(result.output.as_ptr() as *const [G; OUT_435]) }; __ret } } else { aiur_fn_435(__args, record, io_buffer, __cu)? } }; + let __r_arr: [G; OUT_431] = { let __args: [G; IN_431] = [__v_5, __v_3]; let __cu = unconstrained; if let Some(result) = record.function_queries[431].get_mut(&__args[..]) { if !__cu && *result.multiplicity == G::ZERO { aiur_fn_431(__args, record, io_buffer, false)? } else { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_431] = unsafe { *(result.output.as_ptr() as *const [G; OUT_431]) }; __ret } } else { aiur_fn_431(__args, record, io_buffer, __cu)? } }; let __v_8: G = __r_arr[0]; let __v_9: G = G::from_u64(0); let __v_10: G = { let __values: [G; 3] = [__v_9, __v_5, __v_3]; let __mq = record.memory_queries.get_mut(&3).ok_or(ExecError::InvalidMemorySize(3))?; if let Some(result) = __mq.get_mut(&__values[..]) { if !unconstrained { *result.multiplicity += G::ONE; } result.output[0] } else { let __ptr = G::from_usize(__mq.len()); __mq.insert(&__values[..], &[__ptr], G::from_bool(!unconstrained)); __ptr } }; - let __r_arr: [G; OUT_435] = { let __args: [G; IN_435] = [__v_6, __v_10]; let __cu = unconstrained; if let Some(result) = record.function_queries[435].get_mut(&__args[..]) { if !__cu && *result.multiplicity == G::ZERO { aiur_fn_435(__args, record, io_buffer, false)? } else { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_435] = unsafe { *(result.output.as_ptr() as *const [G; OUT_435]) }; __ret } } else { aiur_fn_435(__args, record, io_buffer, __cu)? } }; + let __r_arr: [G; OUT_431] = { let __args: [G; IN_431] = [__v_6, __v_10]; let __cu = unconstrained; if let Some(result) = record.function_queries[431].get_mut(&__args[..]) { if !__cu && *result.multiplicity == G::ZERO { aiur_fn_431(__args, record, io_buffer, false)? } else { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_431] = unsafe { *(result.output.as_ptr() as *const [G; OUT_431]) }; __ret } } else { aiur_fn_431(__args, record, io_buffer, __cu)? } }; let __v_11: G = __r_arr[0]; let __v_12: G = G::from_u64(1); - let __r_arr: [G; OUT_332] = { let __args: [G; IN_332] = [__v_8, __v_11]; let __cu = unconstrained; if let Some(result) = record.function_queries[332].get_mut(&__args[..]) { if !__cu && *result.multiplicity == G::ZERO { aiur_fn_332(__args, record, io_buffer, false)? } else { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_332] = unsafe { *(result.output.as_ptr() as *const [G; OUT_332]) }; __ret } } else { aiur_fn_332(__args, record, io_buffer, __cu)? } }; + let __r_arr: [G; OUT_328] = { let __args: [G; IN_328] = [__v_8, __v_11]; let __cu = unconstrained; if let Some(result) = record.function_queries[328].get_mut(&__args[..]) { if !__cu && *result.multiplicity == G::ZERO { aiur_fn_328(__args, record, io_buffer, false)? } else { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_328] = unsafe { *(result.output.as_ptr() as *const [G; OUT_328]) }; __ret } } else { aiur_fn_328(__args, record, io_buffer, __cu)? } }; let __v_13: G = __r_arr[0]; let __v_14: G = G::from_u64(0); let __v_15: G = { let __values: [G; 4] = [__v_12, __v_13, __v_14, __v_14]; let __mq = record.memory_queries.get_mut(&4).ok_or(ExecError::InvalidMemorySize(4))?; if let Some(result) = __mq.get_mut(&__values[..]) { if !unconstrained { *result.multiplicity += G::ONE; } result.output[0] } else { let __ptr = G::from_usize(__mq.len()); __mq.insert(&__values[..], &[__ptr], G::from_bool(!unconstrained)); __ptr } }; - let __ret: [G; OUT_433] = [__v_15]; - if let Some(result) = record.function_queries[433].get_mut(&inp[..]) { debug_assert_eq!(result.output, &__ret[..]); if !unconstrained { *result.multiplicity += G::ONE; } } else { record.function_queries[433].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained)); }; + let __ret: [G; OUT_429] = [__v_15]; + if let Some(result) = record.function_queries[429].get_mut(&inp[..]) { debug_assert_eq!(result.output, &__ret[..]); if !unconstrained { *result.multiplicity += G::ONE; } } else { record.function_queries[429].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained)); }; return Ok(__ret); }, 6u64 => { let __v_8: G = G::from_u64(0); - let __r_arr: [G; OUT_368] = { let __args: [G; IN_368] = [__v_7, __v_6, __v_8]; let __cu = unconstrained; if let Some(result) = record.function_queries[368].get_mut(&__args[..]) { if !__cu && *result.multiplicity == G::ZERO { aiur_fn_368(__args, record, io_buffer, false)? } else { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_368] = unsafe { *(result.output.as_ptr() as *const [G; OUT_368]) }; __ret } } else { aiur_fn_368(__args, record, io_buffer, __cu)? } }; + let __r_arr: [G; OUT_364] = { let __args: [G; IN_364] = [__v_7, __v_6, __v_8]; let __cu = unconstrained; if let Some(result) = record.function_queries[364].get_mut(&__args[..]) { if !__cu && *result.multiplicity == G::ZERO { aiur_fn_364(__args, record, io_buffer, false)? } else { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_364] = unsafe { *(result.output.as_ptr() as *const [G; OUT_364]) }; __ret } } else { aiur_fn_364(__args, record, io_buffer, __cu)? } }; let __v_9: G = __r_arr[0]; - let __r_arr: [G; OUT_433] = { let __args: [G; IN_433] = [__v_9, __v_3]; let __cu = unconstrained; if let Some(result) = record.function_queries[433].get_mut(&__args[..]) { if !__cu && *result.multiplicity == G::ZERO { aiur_fn_433(__args, record, io_buffer, false)? } else { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_433] = unsafe { *(result.output.as_ptr() as *const [G; OUT_433]) }; __ret } } else { aiur_fn_433(__args, record, io_buffer, __cu)? } }; + let __r_arr: [G; OUT_429] = { let __args: [G; IN_429] = [__v_9, __v_3]; let __cu = unconstrained; if let Some(result) = record.function_queries[429].get_mut(&__args[..]) { if !__cu && *result.multiplicity == G::ZERO { aiur_fn_429(__args, record, io_buffer, false)? } else { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_429] = unsafe { *(result.output.as_ptr() as *const [G; OUT_429]) }; __ret } } else { aiur_fn_429(__args, record, io_buffer, __cu)? } }; let __v_10: G = __r_arr[0]; - let __ret: [G; OUT_433] = [__v_10]; - if let Some(result) = record.function_queries[433].get_mut(&inp[..]) { debug_assert_eq!(result.output, &__ret[..]); if !unconstrained { *result.multiplicity += G::ONE; } } else { record.function_queries[433].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained)); }; + let __ret: [G; OUT_429] = [__v_10]; + if let Some(result) = record.function_queries[429].get_mut(&inp[..]) { debug_assert_eq!(result.output, &__ret[..]); if !unconstrained { *result.multiplicity += G::ONE; } } else { record.function_queries[429].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained)); }; return Ok(__ret); }, 7u64 => { match __v_5.as_canonical_u64() { 0u64 => { let __v_8: G = G::from_u64(2); - let __r_arr: [G; OUT_382] = { let __args: [G; IN_382] = []; let __cu = unconstrained; if let Some(result) = record.function_queries[382].get_mut(&__args[..]) { if !__cu && *result.multiplicity == G::ZERO { aiur_fn_382(__args, record, io_buffer, false)? } else { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_382] = unsafe { *(result.output.as_ptr() as *const [G; OUT_382]) }; __ret } } else { aiur_fn_382(__args, record, io_buffer, __cu)? } }; + let __r_arr: [G; OUT_378] = { let __args: [G; IN_378] = []; let __cu = unconstrained; if let Some(result) = record.function_queries[378].get_mut(&__args[..]) { if !__cu && *result.multiplicity == G::ZERO { aiur_fn_378(__args, record, io_buffer, false)? } else { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_378] = unsafe { *(result.output.as_ptr() as *const [G; OUT_378]) }; __ret } } else { aiur_fn_378(__args, record, io_buffer, __cu)? } }; let __v_9: G = __r_arr[0]; let __v_10: G = G::from_u64(1); let __v_11: G = G::from_u64(1); let __v_12: G = { let __values: [G; 3] = [__v_10, __v_11, __v_11]; let __mq = record.memory_queries.get_mut(&3).ok_or(ExecError::InvalidMemorySize(3))?; if let Some(result) = __mq.get_mut(&__values[..]) { if !unconstrained { *result.multiplicity += G::ONE; } result.output[0] } else { let __ptr = G::from_usize(__mq.len()); __mq.insert(&__values[..], &[__ptr], G::from_bool(!unconstrained)); __ptr } }; let __v_13: G = G::from_u64(0); let __v_14: G = { let __values: [G; 4] = [__v_8, __v_9, __v_12, __v_13]; let __mq = record.memory_queries.get_mut(&4).ok_or(ExecError::InvalidMemorySize(4))?; if let Some(result) = __mq.get_mut(&__values[..]) { if !unconstrained { *result.multiplicity += G::ONE; } result.output[0] } else { let __ptr = G::from_usize(__mq.len()); __mq.insert(&__values[..], &[__ptr], G::from_bool(!unconstrained)); __ptr } }; - let __ret: [G; OUT_433] = [__v_14]; - if let Some(result) = record.function_queries[433].get_mut(&inp[..]) { debug_assert_eq!(result.output, &__ret[..]); if !unconstrained { *result.multiplicity += G::ONE; } } else { record.function_queries[433].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained)); }; + let __ret: [G; OUT_429] = [__v_14]; + if let Some(result) = record.function_queries[429].get_mut(&inp[..]) { debug_assert_eq!(result.output, &__ret[..]); if !unconstrained { *result.multiplicity += G::ONE; } } else { record.function_queries[429].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained)); }; return Ok(__ret); }, 1u64 => { let __v_8: G = G::from_u64(2); - let __r_arr: [G; OUT_218] = { let __args: [G; IN_218] = []; let __cu = unconstrained; if let Some(result) = record.function_queries[218].get_mut(&__args[..]) { if !__cu && *result.multiplicity == G::ZERO { aiur_fn_218(__args, record, io_buffer, false)? } else { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_218] = unsafe { *(result.output.as_ptr() as *const [G; OUT_218]) }; __ret } } else { aiur_fn_218(__args, record, io_buffer, __cu)? } }; + let __r_arr: [G; OUT_214] = { let __args: [G; IN_214] = []; let __cu = unconstrained; if let Some(result) = record.function_queries[214].get_mut(&__args[..]) { if !__cu && *result.multiplicity == G::ZERO { aiur_fn_214(__args, record, io_buffer, false)? } else { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_214] = unsafe { *(result.output.as_ptr() as *const [G; OUT_214]) }; __ret } } else { aiur_fn_214(__args, record, io_buffer, __cu)? } }; let __v_9: G = __r_arr[0]; let __v_10: G = G::from_u64(1); let __v_11: G = G::from_u64(1); let __v_12: G = { let __values: [G; 3] = [__v_10, __v_11, __v_11]; let __mq = record.memory_queries.get_mut(&3).ok_or(ExecError::InvalidMemorySize(3))?; if let Some(result) = __mq.get_mut(&__values[..]) { if !unconstrained { *result.multiplicity += G::ONE; } result.output[0] } else { let __ptr = G::from_usize(__mq.len()); __mq.insert(&__values[..], &[__ptr], G::from_bool(!unconstrained)); __ptr } }; let __v_13: G = G::from_u64(0); let __v_14: G = { let __values: [G; 4] = [__v_8, __v_9, __v_12, __v_13]; let __mq = record.memory_queries.get_mut(&4).ok_or(ExecError::InvalidMemorySize(4))?; if let Some(result) = __mq.get_mut(&__values[..]) { if !unconstrained { *result.multiplicity += G::ONE; } result.output[0] } else { let __ptr = G::from_usize(__mq.len()); __mq.insert(&__values[..], &[__ptr], G::from_bool(!unconstrained)); __ptr } }; - let __ret: [G; OUT_433] = [__v_14]; - if let Some(result) = record.function_queries[433].get_mut(&inp[..]) { debug_assert_eq!(result.output, &__ret[..]); if !unconstrained { *result.multiplicity += G::ONE; } } else { record.function_queries[433].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained)); }; + let __ret: [G; OUT_429] = [__v_14]; + if let Some(result) = record.function_queries[429].get_mut(&inp[..]) { debug_assert_eq!(result.output, &__ret[..]); if !unconstrained { *result.multiplicity += G::ONE; } } else { record.function_queries[429].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained)); }; return Ok(__ret); }, _ => { @@ -38797,9 +38523,9 @@ fn aiur_fn_433( } }, 8u64 => { - let __r_arr: [G; OUT_433] = { let __args: [G; IN_433] = [__v_7, __v_3]; let __cu = unconstrained; if let Some(result) = record.function_queries[433].get_mut(&__args[..]) { if !__cu && *result.multiplicity == G::ZERO { aiur_fn_433(__args, record, io_buffer, false)? } else { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_433] = unsafe { *(result.output.as_ptr() as *const [G; OUT_433]) }; __ret } } else { aiur_fn_433(__args, record, io_buffer, __cu)? } }; + let __r_arr: [G; OUT_429] = { let __args: [G; IN_429] = [__v_7, __v_3]; let __cu = unconstrained; if let Some(result) = record.function_queries[429].get_mut(&__args[..]) { if !__cu && *result.multiplicity == G::ZERO { aiur_fn_429(__args, record, io_buffer, false)? } else { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_429] = unsafe { *(result.output.as_ptr() as *const [G; OUT_429]) }; __ret } } else { aiur_fn_429(__args, record, io_buffer, __cu)? } }; let __v_8: G = __r_arr[0]; - let __r_arr: [G; OUT_418] = { let __args: [G; IN_418] = [__v_8, __v_3]; let __cu = unconstrained; if let Some(result) = record.function_queries[418].get_mut(&__args[..]) { if !__cu && *result.multiplicity == G::ZERO { aiur_fn_418(__args, record, io_buffer, false)? } else { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_418] = unsafe { *(result.output.as_ptr() as *const [G; OUT_418]) }; __ret } } else { aiur_fn_418(__args, record, io_buffer, __cu)? } }; + let __r_arr: [G; OUT_414] = { let __args: [G; IN_414] = [__v_8, __v_3]; let __cu = unconstrained; if let Some(result) = record.function_queries[414].get_mut(&__args[..]) { if !__cu && *result.multiplicity == G::ZERO { aiur_fn_414(__args, record, io_buffer, false)? } else { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_414] = unsafe { *(result.output.as_ptr() as *const [G; OUT_414]) }; __ret } } else { aiur_fn_414(__args, record, io_buffer, __cu)? } }; let __v_9: G = __r_arr[0]; let __r_arr: [G; OUT_111] = { let __args: [G; IN_111] = [__v_9]; let __cu = unconstrained; if let Some(result) = record.function_queries[111].get_mut(&__args[..]) { if !__cu && *result.multiplicity == G::ZERO { aiur_fn_111(__args, record, io_buffer, false)? } else { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_111] = unsafe { *(result.output.as_ptr() as *const [G; OUT_111]) }; __ret } } else { aiur_fn_111(__args, record, io_buffer, __cu)? } }; let __v_10: G = __r_arr[0]; @@ -38811,7 +38537,7 @@ fn aiur_fn_433( let __v_15: G = __loaded[3]; match __v_12.as_canonical_u64() { 2u64 => { - let __r_arr: [G; OUT_287] = { let __args: [G; IN_287] = [__v_13]; let __cu = unconstrained; if let Some(result) = record.function_queries[287].get_mut(&__args[..]) { if !__cu && *result.multiplicity == G::ZERO { aiur_fn_287(__args, record, io_buffer, false)? } else { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_287] = unsafe { *(result.output.as_ptr() as *const [G; OUT_287]) }; __ret } } else { aiur_fn_287(__args, record, io_buffer, __cu)? } }; + let __r_arr: [G; OUT_283] = { let __args: [G; IN_283] = [__v_13]; let __cu = unconstrained; if let Some(result) = record.function_queries[283].get_mut(&__args[..]) { if !__cu && *result.multiplicity == G::ZERO { aiur_fn_283(__args, record, io_buffer, false)? } else { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_283] = unsafe { *(result.output.as_ptr() as *const [G; OUT_283]) }; __ret } } else { aiur_fn_283(__args, record, io_buffer, __cu)? } }; let __v_16: G = __r_arr[0]; let __loaded: [G; 12] = { let __mq = record.memory_queries.get_mut(&12).ok_or(ExecError::InvalidMemorySize(12))?; let __ptr_u64 = __v_16.as_canonical_u64(); let __ptr_usize = usize::try_from(__ptr_u64).ok().ok_or(ExecError::PointerTooLarge(__ptr_u64))?; let (__args, __mult) = __mq.get_index_mut(__ptr_usize).ok_or(ExecError::UnboundPointer { ptr: __ptr_u64, size: 12 })?; if !unconstrained { *__mult += G::ONE; } let __arr: [G; 12] = __args[..12].try_into().unwrap(); __arr }; let __v_17: G = __loaded[0]; @@ -38832,7 +38558,7 @@ fn aiur_fn_433( match __v_17.as_canonical_u64() { 5u64 => { let __v_29: G = G::from_u64(0); - let __r_arr: [G; OUT_290] = { let __args: [G; IN_290] = [__v_24, __v_25, __v_29]; let __cu = unconstrained; if let Some(result) = record.function_queries[290].get_mut(&__args[..]) { if !__cu && *result.multiplicity == G::ZERO { aiur_fn_290(__args, record, io_buffer, false)? } else { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_290] = unsafe { *(result.output.as_ptr() as *const [G; OUT_290]) }; __ret } } else { aiur_fn_290(__args, record, io_buffer, __cu)? } }; + let __r_arr: [G; OUT_286] = { let __args: [G; IN_286] = [__v_24, __v_25, __v_29]; let __cu = unconstrained; if let Some(result) = record.function_queries[286].get_mut(&__args[..]) { if !__cu && *result.multiplicity == G::ZERO { aiur_fn_286(__args, record, io_buffer, false)? } else { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_286] = unsafe { *(result.output.as_ptr() as *const [G; OUT_286]) }; __ret } } else { aiur_fn_286(__args, record, io_buffer, __cu)? } }; let __v_30: G = __r_arr[0]; let __loaded: [G; 12] = { let __mq = record.memory_queries.get_mut(&12).ok_or(ExecError::InvalidMemorySize(12))?; let __ptr_u64 = __v_30.as_canonical_u64(); let __ptr_usize = usize::try_from(__ptr_u64).ok().ok_or(ExecError::PointerTooLarge(__ptr_u64))?; let (__args, __mult) = __mq.get_index_mut(__ptr_usize).ok_or(ExecError::UnboundPointer { ptr: __ptr_u64, size: 12 })?; if !unconstrained { *__mult += G::ONE; } let __arr: [G; 12] = __args[..12].try_into().unwrap(); __arr }; let __v_31: G = __loaded[0]; @@ -38853,15 +38579,15 @@ fn aiur_fn_433( } match __v_31.as_canonical_u64() { 6u64 => { - let __r_arr: [G; OUT_336] = { let __args: [G; IN_336] = [__v_33, __v_14]; let __cu = unconstrained; if let Some(result) = record.function_queries[336].get_mut(&__args[..]) { if !__cu && *result.multiplicity == G::ZERO { aiur_fn_336(__args, record, io_buffer, false)? } else { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_336] = unsafe { *(result.output.as_ptr() as *const [G; OUT_336]) }; __ret } } else { aiur_fn_336(__args, record, io_buffer, __cu)? } }; + let __r_arr: [G; OUT_332] = { let __args: [G; IN_332] = [__v_33, __v_14]; let __cu = unconstrained; if let Some(result) = record.function_queries[332].get_mut(&__args[..]) { if !__cu && *result.multiplicity == G::ZERO { aiur_fn_332(__args, record, io_buffer, false)? } else { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_332] = unsafe { *(result.output.as_ptr() as *const [G; OUT_332]) }; __ret } } else { aiur_fn_332(__args, record, io_buffer, __cu)? } }; let __v_44: G = __r_arr[0]; - let __r_arr: [G; OUT_436] = { let __args: [G; IN_436] = [__v_44, __v_11, __v_20]; let __cu = unconstrained; if let Some(result) = record.function_queries[436].get_mut(&__args[..]) { if !__cu && *result.multiplicity == G::ZERO { aiur_fn_436(__args, record, io_buffer, false)? } else { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_436] = unsafe { *(result.output.as_ptr() as *const [G; OUT_436]) }; __ret } } else { aiur_fn_436(__args, record, io_buffer, __cu)? } }; + let __r_arr: [G; OUT_432] = { let __args: [G; IN_432] = [__v_44, __v_11, __v_20]; let __cu = unconstrained; if let Some(result) = record.function_queries[432].get_mut(&__args[..]) { if !__cu && *result.multiplicity == G::ZERO { aiur_fn_432(__args, record, io_buffer, false)? } else { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_432] = unsafe { *(result.output.as_ptr() as *const [G; OUT_432]) }; __ret } } else { aiur_fn_432(__args, record, io_buffer, __cu)? } }; let __v_45: G = __r_arr[0]; let __v_46: G = G::from_u64(0); - let __r_arr: [G; OUT_437] = { let __args: [G; IN_437] = [__v_45, __v_6, __v_46, __v_5, __v_7]; let __cu = unconstrained; if let Some(result) = record.function_queries[437].get_mut(&__args[..]) { if !__cu && *result.multiplicity == G::ZERO { aiur_fn_437(__args, record, io_buffer, false)? } else { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_437] = unsafe { *(result.output.as_ptr() as *const [G; OUT_437]) }; __ret } } else { aiur_fn_437(__args, record, io_buffer, __cu)? } }; + let __r_arr: [G; OUT_433] = { let __args: [G; IN_433] = [__v_45, __v_6, __v_46, __v_5, __v_7]; let __cu = unconstrained; if let Some(result) = record.function_queries[433].get_mut(&__args[..]) { if !__cu && *result.multiplicity == G::ZERO { aiur_fn_433(__args, record, io_buffer, false)? } else { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_433] = unsafe { *(result.output.as_ptr() as *const [G; OUT_433]) }; __ret } } else { aiur_fn_433(__args, record, io_buffer, __cu)? } }; let __v_47: G = __r_arr[0]; - let __ret: [G; OUT_433] = [__v_47]; - if let Some(result) = record.function_queries[433].get_mut(&inp[..]) { debug_assert_eq!(result.output, &__ret[..]); if !unconstrained { *result.multiplicity += G::ONE; } } else { record.function_queries[433].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained)); }; + let __ret: [G; OUT_429] = [__v_47]; + if let Some(result) = record.function_queries[429].get_mut(&inp[..]) { debug_assert_eq!(result.output, &__ret[..]); if !unconstrained { *result.multiplicity += G::ONE; } } else { record.function_queries[429].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained)); }; return Ok(__ret); }, _ => { @@ -38886,15 +38612,15 @@ fn aiur_fn_433( }) } -const INPUT_SIZE_434: usize = 2; -const IN_434: usize = 2; -const OUT_434: usize = 1; -fn aiur_fn_434( - inp: [G; IN_434], +const INPUT_SIZE_430: usize = 2; +const IN_430: usize = 2; +const OUT_430: usize = 1; +fn aiur_fn_430( + inp: [G; IN_430], record: &mut QueryRecord, io_buffer: &mut IOBuffer, unconstrained: bool, -) -> Result<[G; OUT_434], ExecError> { +) -> Result<[G; OUT_430], ExecError> { stacker::maybe_grow(64 * 1024, 4 * 1024 * 1024, || { let __v_0: G = inp[0]; let __v_1: G = inp[1]; @@ -38905,15 +38631,15 @@ fn aiur_fn_434( let __v_5: G = __loaded[3]; match __v_2.as_canonical_u64() { 0u64 => { - let __r_arr: [G; OUT_766] = { let __args: [G; IN_766] = [__v_1, __v_3]; let __cu = unconstrained; if let Some(result) = record.function_queries[766].get_mut(&__args[..]) { if !__cu && *result.multiplicity == G::ZERO { aiur_fn_766(__args, record, io_buffer, false)? } else { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_766] = unsafe { *(result.output.as_ptr() as *const [G; OUT_766]) }; __ret } } else { aiur_fn_766(__args, record, io_buffer, __cu)? } }; + let __r_arr: [G; OUT_762] = { let __args: [G; IN_762] = [__v_1, __v_3]; let __cu = unconstrained; if let Some(result) = record.function_queries[762].get_mut(&__args[..]) { if !__cu && *result.multiplicity == G::ZERO { aiur_fn_762(__args, record, io_buffer, false)? } else { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_762] = unsafe { *(result.output.as_ptr() as *const [G; OUT_762]) }; __ret } } else { aiur_fn_762(__args, record, io_buffer, __cu)? } }; let __v_6: G = __r_arr[0]; let __v_7: G = G::from_u64(1); let __v_8: G = (__v_3 + __v_7); let __v_9: G = G::from_u64(0); - let __r_arr: [G; OUT_359] = { let __args: [G; IN_359] = [__v_6, __v_8, __v_9]; let __cu = unconstrained; if let Some(result) = record.function_queries[359].get_mut(&__args[..]) { if !__cu && *result.multiplicity == G::ZERO { aiur_fn_359(__args, record, io_buffer, false)? } else { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_359] = unsafe { *(result.output.as_ptr() as *const [G; OUT_359]) }; __ret } } else { aiur_fn_359(__args, record, io_buffer, __cu)? } }; + let __r_arr: [G; OUT_355] = { let __args: [G; IN_355] = [__v_6, __v_8, __v_9]; let __cu = unconstrained; if let Some(result) = record.function_queries[355].get_mut(&__args[..]) { if !__cu && *result.multiplicity == G::ZERO { aiur_fn_355(__args, record, io_buffer, false)? } else { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_355] = unsafe { *(result.output.as_ptr() as *const [G; OUT_355]) }; __ret } } else { aiur_fn_355(__args, record, io_buffer, __cu)? } }; let __v_10: G = __r_arr[0]; - let __ret: [G; OUT_434] = [__v_10]; - if let Some(result) = record.function_queries[434].get_mut(&inp[..]) { debug_assert_eq!(result.output, &__ret[..]); if !unconstrained { *result.multiplicity += G::ONE; } } else { record.function_queries[434].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained)); }; + let __ret: [G; OUT_430] = [__v_10]; + if let Some(result) = record.function_queries[430].get_mut(&inp[..]) { debug_assert_eq!(result.output, &__ret[..]); if !unconstrained { *result.multiplicity += G::ONE; } } else { record.function_queries[430].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained)); }; return Ok(__ret); }, 1u64 => { @@ -38921,16 +38647,16 @@ fn aiur_fn_434( let __v_7: G = G::from_u64(1); let __v_8: G = G::from_u64(0); let __v_9: G = { let __values: [G; 3] = [__v_7, __v_3, __v_8]; let __mq = record.memory_queries.get_mut(&3).ok_or(ExecError::InvalidMemorySize(3))?; if let Some(result) = __mq.get_mut(&__values[..]) { if !unconstrained { *result.multiplicity += G::ONE; } result.output[0] } else { let __ptr = G::from_usize(__mq.len()); __mq.insert(&__values[..], &[__ptr], G::from_bool(!unconstrained)); __ptr } }; - let __r_arr: [G; OUT_333] = { let __args: [G; IN_333] = [__v_9]; let __cu = unconstrained; if let Some(result) = record.function_queries[333].get_mut(&__args[..]) { if !__cu && *result.multiplicity == G::ZERO { aiur_fn_333(__args, record, io_buffer, false)? } else { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_333] = unsafe { *(result.output.as_ptr() as *const [G; OUT_333]) }; __ret } } else { aiur_fn_333(__args, record, io_buffer, __cu)? } }; + let __r_arr: [G; OUT_329] = { let __args: [G; IN_329] = [__v_9]; let __cu = unconstrained; if let Some(result) = record.function_queries[329].get_mut(&__args[..]) { if !__cu && *result.multiplicity == G::ZERO { aiur_fn_329(__args, record, io_buffer, false)? } else { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_329] = unsafe { *(result.output.as_ptr() as *const [G; OUT_329]) }; __ret } } else { aiur_fn_329(__args, record, io_buffer, __cu)? } }; let __v_10: G = __r_arr[0]; let __v_11: G = G::from_u64(0); let __v_12: G = { let __values: [G; 4] = [__v_6, __v_10, __v_11, __v_11]; let __mq = record.memory_queries.get_mut(&4).ok_or(ExecError::InvalidMemorySize(4))?; if let Some(result) = __mq.get_mut(&__values[..]) { if !unconstrained { *result.multiplicity += G::ONE; } result.output[0] } else { let __ptr = G::from_usize(__mq.len()); __mq.insert(&__values[..], &[__ptr], G::from_bool(!unconstrained)); __ptr } }; - let __ret: [G; OUT_434] = [__v_12]; - if let Some(result) = record.function_queries[434].get_mut(&inp[..]) { debug_assert_eq!(result.output, &__ret[..]); if !unconstrained { *result.multiplicity += G::ONE; } } else { record.function_queries[434].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained)); }; + let __ret: [G; OUT_430] = [__v_12]; + if let Some(result) = record.function_queries[430].get_mut(&inp[..]) { debug_assert_eq!(result.output, &__ret[..]); if !unconstrained { *result.multiplicity += G::ONE; } } else { record.function_queries[430].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained)); }; return Ok(__ret); }, 2u64 => { - let __r_arr: [G; OUT_287] = { let __args: [G; IN_287] = [__v_3]; let __cu = unconstrained; if let Some(result) = record.function_queries[287].get_mut(&__args[..]) { if !__cu && *result.multiplicity == G::ZERO { aiur_fn_287(__args, record, io_buffer, false)? } else { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_287] = unsafe { *(result.output.as_ptr() as *const [G; OUT_287]) }; __ret } } else { aiur_fn_287(__args, record, io_buffer, __cu)? } }; + let __r_arr: [G; OUT_283] = { let __args: [G; IN_283] = [__v_3]; let __cu = unconstrained; if let Some(result) = record.function_queries[283].get_mut(&__args[..]) { if !__cu && *result.multiplicity == G::ZERO { aiur_fn_283(__args, record, io_buffer, false)? } else { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_283] = unsafe { *(result.output.as_ptr() as *const [G; OUT_283]) }; __ret } } else { aiur_fn_283(__args, record, io_buffer, __cu)? } }; let __v_6: G = __r_arr[0]; let __loaded: [G; 12] = { let __mq = record.memory_queries.get_mut(&12).ok_or(ExecError::InvalidMemorySize(12))?; let __ptr_u64 = __v_6.as_canonical_u64(); let __ptr_usize = usize::try_from(__ptr_u64).ok().ok_or(ExecError::PointerTooLarge(__ptr_u64))?; let (__args, __mult) = __mq.get_index_mut(__ptr_usize).ok_or(ExecError::UnboundPointer { ptr: __ptr_u64, size: 12 })?; if !unconstrained { *__mult += G::ONE; } let __arr: [G; 12] = __args[..12].try_into().unwrap(); __arr }; let __v_7: G = __loaded[0]; @@ -38945,23 +38671,23 @@ fn aiur_fn_434( let __v_16: G = __loaded[9]; let __v_17: G = __loaded[10]; let __v_18: G = __loaded[11]; - let __r_arr: [G; OUT_431] = { let __args: [G; IN_431] = [__v_7, __v_8, __v_9, __v_10, __v_11, __v_12, __v_13, __v_14, __v_15, __v_16, __v_17, __v_18]; let __cu = unconstrained; if let Some(result) = record.function_queries[431].get_mut(&__args[..]) { if !__cu && *result.multiplicity == G::ZERO { aiur_fn_431(__args, record, io_buffer, false)? } else { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_431] = unsafe { *(result.output.as_ptr() as *const [G; OUT_431]) }; __ret } } else { aiur_fn_431(__args, record, io_buffer, __cu)? } }; + let __r_arr: [G; OUT_427] = { let __args: [G; IN_427] = [__v_7, __v_8, __v_9, __v_10, __v_11, __v_12, __v_13, __v_14, __v_15, __v_16, __v_17, __v_18]; let __cu = unconstrained; if let Some(result) = record.function_queries[427].get_mut(&__args[..]) { if !__cu && *result.multiplicity == G::ZERO { aiur_fn_427(__args, record, io_buffer, false)? } else { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_427] = unsafe { *(result.output.as_ptr() as *const [G; OUT_427]) }; __ret } } else { aiur_fn_427(__args, record, io_buffer, __cu)? } }; let __v_19: G = __r_arr[0]; - let __r_arr: [G; OUT_432] = { let __args: [G; IN_432] = [__v_7, __v_8, __v_9, __v_10, __v_11, __v_12, __v_13, __v_14, __v_15, __v_16, __v_17, __v_18]; let __cu = unconstrained; if let Some(result) = record.function_queries[432].get_mut(&__args[..]) { if !__cu && *result.multiplicity == G::ZERO { aiur_fn_432(__args, record, io_buffer, false)? } else { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_432] = unsafe { *(result.output.as_ptr() as *const [G; OUT_432]) }; __ret } } else { aiur_fn_432(__args, record, io_buffer, __cu)? } }; + let __r_arr: [G; OUT_428] = { let __args: [G; IN_428] = [__v_7, __v_8, __v_9, __v_10, __v_11, __v_12, __v_13, __v_14, __v_15, __v_16, __v_17, __v_18]; let __cu = unconstrained; if let Some(result) = record.function_queries[428].get_mut(&__args[..]) { if !__cu && *result.multiplicity == G::ZERO { aiur_fn_428(__args, record, io_buffer, false)? } else { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_428] = unsafe { *(result.output.as_ptr() as *const [G; OUT_428]) }; __ret } } else { aiur_fn_428(__args, record, io_buffer, __cu)? } }; let __v_20: G = __r_arr[0]; - let __r_arr: [G; OUT_764] = { let __args: [G; IN_764] = [__v_4]; let __cu = unconstrained; if let Some(result) = record.function_queries[764].get_mut(&__args[..]) { if !__cu && *result.multiplicity == G::ZERO { aiur_fn_764(__args, record, io_buffer, false)? } else { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_764] = unsafe { *(result.output.as_ptr() as *const [G; OUT_764]) }; __ret } } else { aiur_fn_764(__args, record, io_buffer, __cu)? } }; + let __r_arr: [G; OUT_760] = { let __args: [G; IN_760] = [__v_4]; let __cu = unconstrained; if let Some(result) = record.function_queries[760].get_mut(&__args[..]) { if !__cu && *result.multiplicity == G::ZERO { aiur_fn_760(__args, record, io_buffer, false)? } else { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_760] = unsafe { *(result.output.as_ptr() as *const [G; OUT_760]) }; __ret } } else { aiur_fn_760(__args, record, io_buffer, __cu)? } }; let __v_21: G = __r_arr[0]; if (__v_21 != __v_19) { return Err(ExecError::AssertEqMismatch { lhs: __v_21.as_canonical_u64(), rhs: __v_19.as_canonical_u64(), msg: Some("Const applied to wrong number of universe levels".to_string()) }); } - let __r_arr: [G; OUT_336] = { let __args: [G; IN_336] = [__v_20, __v_4]; let __cu = unconstrained; if let Some(result) = record.function_queries[336].get_mut(&__args[..]) { if !__cu && *result.multiplicity == G::ZERO { aiur_fn_336(__args, record, io_buffer, false)? } else { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_336] = unsafe { *(result.output.as_ptr() as *const [G; OUT_336]) }; __ret } } else { aiur_fn_336(__args, record, io_buffer, __cu)? } }; + let __r_arr: [G; OUT_332] = { let __args: [G; IN_332] = [__v_20, __v_4]; let __cu = unconstrained; if let Some(result) = record.function_queries[332].get_mut(&__args[..]) { if !__cu && *result.multiplicity == G::ZERO { aiur_fn_332(__args, record, io_buffer, false)? } else { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_332] = unsafe { *(result.output.as_ptr() as *const [G; OUT_332]) }; __ret } } else { aiur_fn_332(__args, record, io_buffer, __cu)? } }; let __v_22: G = __r_arr[0]; - let __ret: [G; OUT_434] = [__v_22]; - if let Some(result) = record.function_queries[434].get_mut(&inp[..]) { debug_assert_eq!(result.output, &__ret[..]); if !unconstrained { *result.multiplicity += G::ONE; } } else { record.function_queries[434].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained)); }; + let __ret: [G; OUT_430] = [__v_22]; + if let Some(result) = record.function_queries[430].get_mut(&inp[..]) { debug_assert_eq!(result.output, &__ret[..]); if !unconstrained { *result.multiplicity += G::ONE; } } else { record.function_queries[430].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained)); }; return Ok(__ret); }, 3u64 => { - let __r_arr: [G; OUT_433] = { let __args: [G; IN_433] = [__v_3, __v_1]; let __cu = unconstrained; if let Some(result) = record.function_queries[433].get_mut(&__args[..]) { if !__cu && *result.multiplicity == G::ZERO { aiur_fn_433(__args, record, io_buffer, false)? } else { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_433] = unsafe { *(result.output.as_ptr() as *const [G; OUT_433]) }; __ret } } else { aiur_fn_433(__args, record, io_buffer, __cu)? } }; + let __r_arr: [G; OUT_429] = { let __args: [G; IN_429] = [__v_3, __v_1]; let __cu = unconstrained; if let Some(result) = record.function_queries[429].get_mut(&__args[..]) { if !__cu && *result.multiplicity == G::ZERO { aiur_fn_429(__args, record, io_buffer, false)? } else { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_429] = unsafe { *(result.output.as_ptr() as *const [G; OUT_429]) }; __ret } } else { aiur_fn_429(__args, record, io_buffer, __cu)? } }; let __v_6: G = __r_arr[0]; let __loaded: [G; 4] = { let __mq = record.memory_queries.get_mut(&4).ok_or(ExecError::InvalidMemorySize(4))?; let __ptr_u64 = __v_6.as_canonical_u64(); let __ptr_usize = usize::try_from(__ptr_u64).ok().ok_or(ExecError::PointerTooLarge(__ptr_u64))?; let (__args, __mult) = __mq.get_index_mut(__ptr_usize).ok_or(ExecError::UnboundPointer { ptr: __ptr_u64, size: 4 })?; if !unconstrained { *__mult += G::ONE; } let __arr: [G; 4] = __args[..4].try_into().unwrap(); __arr }; let __v_7: G = __loaded[0]; @@ -38971,14 +38697,14 @@ fn aiur_fn_434( match __v_7.as_canonical_u64() { 5u64 => { let __v_11: G = G::from_u64(0); - let __r_arr: [G; OUT_368] = { let __args: [G; IN_368] = [__v_9, __v_4, __v_11]; let __cu = unconstrained; if let Some(result) = record.function_queries[368].get_mut(&__args[..]) { if !__cu && *result.multiplicity == G::ZERO { aiur_fn_368(__args, record, io_buffer, false)? } else { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_368] = unsafe { *(result.output.as_ptr() as *const [G; OUT_368]) }; __ret } } else { aiur_fn_368(__args, record, io_buffer, __cu)? } }; + let __r_arr: [G; OUT_364] = { let __args: [G; IN_364] = [__v_9, __v_4, __v_11]; let __cu = unconstrained; if let Some(result) = record.function_queries[364].get_mut(&__args[..]) { if !__cu && *result.multiplicity == G::ZERO { aiur_fn_364(__args, record, io_buffer, false)? } else { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_364] = unsafe { *(result.output.as_ptr() as *const [G; OUT_364]) }; __ret } } else { aiur_fn_364(__args, record, io_buffer, __cu)? } }; let __v_12: G = __r_arr[0]; - let __ret: [G; OUT_434] = [__v_12]; - if let Some(result) = record.function_queries[434].get_mut(&inp[..]) { debug_assert_eq!(result.output, &__ret[..]); if !unconstrained { *result.multiplicity += G::ONE; } } else { record.function_queries[434].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained)); }; + let __ret: [G; OUT_430] = [__v_12]; + if let Some(result) = record.function_queries[430].get_mut(&inp[..]) { debug_assert_eq!(result.output, &__ret[..]); if !unconstrained { *result.multiplicity += G::ONE; } } else { record.function_queries[430].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained)); }; return Ok(__ret); }, _ => { - let __r_arr: [G; OUT_418] = { let __args: [G; IN_418] = [__v_6, __v_1]; let __cu = unconstrained; if let Some(result) = record.function_queries[418].get_mut(&__args[..]) { if !__cu && *result.multiplicity == G::ZERO { aiur_fn_418(__args, record, io_buffer, false)? } else { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_418] = unsafe { *(result.output.as_ptr() as *const [G; OUT_418]) }; __ret } } else { aiur_fn_418(__args, record, io_buffer, __cu)? } }; + let __r_arr: [G; OUT_414] = { let __args: [G; IN_414] = [__v_6, __v_1]; let __cu = unconstrained; if let Some(result) = record.function_queries[414].get_mut(&__args[..]) { if !__cu && *result.multiplicity == G::ZERO { aiur_fn_414(__args, record, io_buffer, false)? } else { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_414] = unsafe { *(result.output.as_ptr() as *const [G; OUT_414]) }; __ret } } else { aiur_fn_414(__args, record, io_buffer, __cu)? } }; let __v_11: G = __r_arr[0]; let __loaded: [G; 4] = { let __mq = record.memory_queries.get_mut(&4).ok_or(ExecError::InvalidMemorySize(4))?; let __ptr_u64 = __v_11.as_canonical_u64(); let __ptr_usize = usize::try_from(__ptr_u64).ok().ok_or(ExecError::PointerTooLarge(__ptr_u64))?; let (__args, __mult) = __mq.get_index_mut(__ptr_usize).ok_or(ExecError::UnboundPointer { ptr: __ptr_u64, size: 4 })?; if !unconstrained { *__mult += G::ONE; } let __arr: [G; 4] = __args[..4].try_into().unwrap(); __arr }; let __v_12: G = __loaded[0]; @@ -38988,10 +38714,10 @@ fn aiur_fn_434( match __v_12.as_canonical_u64() { 5u64 => { let __v_16: G = G::from_u64(0); - let __r_arr: [G; OUT_368] = { let __args: [G; IN_368] = [__v_14, __v_4, __v_16]; let __cu = unconstrained; if let Some(result) = record.function_queries[368].get_mut(&__args[..]) { if !__cu && *result.multiplicity == G::ZERO { aiur_fn_368(__args, record, io_buffer, false)? } else { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_368] = unsafe { *(result.output.as_ptr() as *const [G; OUT_368]) }; __ret } } else { aiur_fn_368(__args, record, io_buffer, __cu)? } }; + let __r_arr: [G; OUT_364] = { let __args: [G; IN_364] = [__v_14, __v_4, __v_16]; let __cu = unconstrained; if let Some(result) = record.function_queries[364].get_mut(&__args[..]) { if !__cu && *result.multiplicity == G::ZERO { aiur_fn_364(__args, record, io_buffer, false)? } else { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_364] = unsafe { *(result.output.as_ptr() as *const [G; OUT_364]) }; __ret } } else { aiur_fn_364(__args, record, io_buffer, __cu)? } }; let __v_17: G = __r_arr[0]; - let __ret: [G; OUT_434] = [__v_17]; - if let Some(result) = record.function_queries[434].get_mut(&inp[..]) { debug_assert_eq!(result.output, &__ret[..]); if !unconstrained { *result.multiplicity += G::ONE; } } else { record.function_queries[434].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained)); }; + let __ret: [G; OUT_430] = [__v_17]; + if let Some(result) = record.function_queries[430].get_mut(&inp[..]) { debug_assert_eq!(result.output, &__ret[..]); if !unconstrained { *result.multiplicity += G::ONE; } } else { record.function_queries[430].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained)); }; return Ok(__ret); }, _ => { @@ -39004,67 +38730,67 @@ fn aiur_fn_434( 4u64 => { let __v_6: G = G::from_u64(0); let __v_7: G = { let __values: [G; 3] = [__v_6, __v_3, __v_1]; let __mq = record.memory_queries.get_mut(&3).ok_or(ExecError::InvalidMemorySize(3))?; if let Some(result) = __mq.get_mut(&__values[..]) { if !unconstrained { *result.multiplicity += G::ONE; } result.output[0] } else { let __ptr = G::from_usize(__mq.len()); __mq.insert(&__values[..], &[__ptr], G::from_bool(!unconstrained)); __ptr } }; - let __r_arr: [G; OUT_433] = { let __args: [G; IN_433] = [__v_4, __v_7]; let __cu = unconstrained; if let Some(result) = record.function_queries[433].get_mut(&__args[..]) { if !__cu && *result.multiplicity == G::ZERO { aiur_fn_433(__args, record, io_buffer, false)? } else { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_433] = unsafe { *(result.output.as_ptr() as *const [G; OUT_433]) }; __ret } } else { aiur_fn_433(__args, record, io_buffer, __cu)? } }; + let __r_arr: [G; OUT_429] = { let __args: [G; IN_429] = [__v_4, __v_7]; let __cu = unconstrained; if let Some(result) = record.function_queries[429].get_mut(&__args[..]) { if !__cu && *result.multiplicity == G::ZERO { aiur_fn_429(__args, record, io_buffer, false)? } else { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_429] = unsafe { *(result.output.as_ptr() as *const [G; OUT_429]) }; __ret } } else { aiur_fn_429(__args, record, io_buffer, __cu)? } }; let __v_8: G = __r_arr[0]; let __v_9: G = G::from_u64(5); let __v_10: G = G::from_u64(0); let __v_11: G = { let __values: [G; 4] = [__v_9, __v_3, __v_8, __v_10]; let __mq = record.memory_queries.get_mut(&4).ok_or(ExecError::InvalidMemorySize(4))?; if let Some(result) = __mq.get_mut(&__values[..]) { if !unconstrained { *result.multiplicity += G::ONE; } result.output[0] } else { let __ptr = G::from_usize(__mq.len()); __mq.insert(&__values[..], &[__ptr], G::from_bool(!unconstrained)); __ptr } }; - let __ret: [G; OUT_434] = [__v_11]; - if let Some(result) = record.function_queries[434].get_mut(&inp[..]) { debug_assert_eq!(result.output, &__ret[..]); if !unconstrained { *result.multiplicity += G::ONE; } } else { record.function_queries[434].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained)); }; + let __ret: [G; OUT_430] = [__v_11]; + if let Some(result) = record.function_queries[430].get_mut(&inp[..]) { debug_assert_eq!(result.output, &__ret[..]); if !unconstrained { *result.multiplicity += G::ONE; } } else { record.function_queries[430].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained)); }; return Ok(__ret); }, 5u64 => { - let __r_arr: [G; OUT_435] = { let __args: [G; IN_435] = [__v_3, __v_1]; let __cu = unconstrained; if let Some(result) = record.function_queries[435].get_mut(&__args[..]) { if !__cu && *result.multiplicity == G::ZERO { aiur_fn_435(__args, record, io_buffer, false)? } else { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_435] = unsafe { *(result.output.as_ptr() as *const [G; OUT_435]) }; __ret } } else { aiur_fn_435(__args, record, io_buffer, __cu)? } }; + let __r_arr: [G; OUT_431] = { let __args: [G; IN_431] = [__v_3, __v_1]; let __cu = unconstrained; if let Some(result) = record.function_queries[431].get_mut(&__args[..]) { if !__cu && *result.multiplicity == G::ZERO { aiur_fn_431(__args, record, io_buffer, false)? } else { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_431] = unsafe { *(result.output.as_ptr() as *const [G; OUT_431]) }; __ret } } else { aiur_fn_431(__args, record, io_buffer, __cu)? } }; let __v_6: G = __r_arr[0]; let __v_7: G = G::from_u64(0); let __v_8: G = { let __values: [G; 3] = [__v_7, __v_3, __v_1]; let __mq = record.memory_queries.get_mut(&3).ok_or(ExecError::InvalidMemorySize(3))?; if let Some(result) = __mq.get_mut(&__values[..]) { if !unconstrained { *result.multiplicity += G::ONE; } result.output[0] } else { let __ptr = G::from_usize(__mq.len()); __mq.insert(&__values[..], &[__ptr], G::from_bool(!unconstrained)); __ptr } }; - let __r_arr: [G; OUT_435] = { let __args: [G; IN_435] = [__v_4, __v_8]; let __cu = unconstrained; if let Some(result) = record.function_queries[435].get_mut(&__args[..]) { if !__cu && *result.multiplicity == G::ZERO { aiur_fn_435(__args, record, io_buffer, false)? } else { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_435] = unsafe { *(result.output.as_ptr() as *const [G; OUT_435]) }; __ret } } else { aiur_fn_435(__args, record, io_buffer, __cu)? } }; + let __r_arr: [G; OUT_431] = { let __args: [G; IN_431] = [__v_4, __v_8]; let __cu = unconstrained; if let Some(result) = record.function_queries[431].get_mut(&__args[..]) { if !__cu && *result.multiplicity == G::ZERO { aiur_fn_431(__args, record, io_buffer, false)? } else { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_431] = unsafe { *(result.output.as_ptr() as *const [G; OUT_431]) }; __ret } } else { aiur_fn_431(__args, record, io_buffer, __cu)? } }; let __v_9: G = __r_arr[0]; let __v_10: G = G::from_u64(1); - let __r_arr: [G; OUT_332] = { let __args: [G; IN_332] = [__v_6, __v_9]; let __cu = unconstrained; if let Some(result) = record.function_queries[332].get_mut(&__args[..]) { if !__cu && *result.multiplicity == G::ZERO { aiur_fn_332(__args, record, io_buffer, false)? } else { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_332] = unsafe { *(result.output.as_ptr() as *const [G; OUT_332]) }; __ret } } else { aiur_fn_332(__args, record, io_buffer, __cu)? } }; + let __r_arr: [G; OUT_328] = { let __args: [G; IN_328] = [__v_6, __v_9]; let __cu = unconstrained; if let Some(result) = record.function_queries[328].get_mut(&__args[..]) { if !__cu && *result.multiplicity == G::ZERO { aiur_fn_328(__args, record, io_buffer, false)? } else { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_328] = unsafe { *(result.output.as_ptr() as *const [G; OUT_328]) }; __ret } } else { aiur_fn_328(__args, record, io_buffer, __cu)? } }; let __v_11: G = __r_arr[0]; let __v_12: G = G::from_u64(0); let __v_13: G = { let __values: [G; 4] = [__v_10, __v_11, __v_12, __v_12]; let __mq = record.memory_queries.get_mut(&4).ok_or(ExecError::InvalidMemorySize(4))?; if let Some(result) = __mq.get_mut(&__values[..]) { if !unconstrained { *result.multiplicity += G::ONE; } result.output[0] } else { let __ptr = G::from_usize(__mq.len()); __mq.insert(&__values[..], &[__ptr], G::from_bool(!unconstrained)); __ptr } }; - let __ret: [G; OUT_434] = [__v_13]; - if let Some(result) = record.function_queries[434].get_mut(&inp[..]) { debug_assert_eq!(result.output, &__ret[..]); if !unconstrained { *result.multiplicity += G::ONE; } } else { record.function_queries[434].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained)); }; + let __ret: [G; OUT_430] = [__v_13]; + if let Some(result) = record.function_queries[430].get_mut(&inp[..]) { debug_assert_eq!(result.output, &__ret[..]); if !unconstrained { *result.multiplicity += G::ONE; } } else { record.function_queries[430].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained)); }; return Ok(__ret); }, 6u64 => { let __v_6: G = G::from_u64(0); - let __r_arr: [G; OUT_368] = { let __args: [G; IN_368] = [__v_5, __v_4, __v_6]; let __cu = unconstrained; if let Some(result) = record.function_queries[368].get_mut(&__args[..]) { if !__cu && *result.multiplicity == G::ZERO { aiur_fn_368(__args, record, io_buffer, false)? } else { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_368] = unsafe { *(result.output.as_ptr() as *const [G; OUT_368]) }; __ret } } else { aiur_fn_368(__args, record, io_buffer, __cu)? } }; + let __r_arr: [G; OUT_364] = { let __args: [G; IN_364] = [__v_5, __v_4, __v_6]; let __cu = unconstrained; if let Some(result) = record.function_queries[364].get_mut(&__args[..]) { if !__cu && *result.multiplicity == G::ZERO { aiur_fn_364(__args, record, io_buffer, false)? } else { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_364] = unsafe { *(result.output.as_ptr() as *const [G; OUT_364]) }; __ret } } else { aiur_fn_364(__args, record, io_buffer, __cu)? } }; let __v_7: G = __r_arr[0]; - let __r_arr: [G; OUT_433] = { let __args: [G; IN_433] = [__v_7, __v_1]; let __cu = unconstrained; if let Some(result) = record.function_queries[433].get_mut(&__args[..]) { if !__cu && *result.multiplicity == G::ZERO { aiur_fn_433(__args, record, io_buffer, false)? } else { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_433] = unsafe { *(result.output.as_ptr() as *const [G; OUT_433]) }; __ret } } else { aiur_fn_433(__args, record, io_buffer, __cu)? } }; + let __r_arr: [G; OUT_429] = { let __args: [G; IN_429] = [__v_7, __v_1]; let __cu = unconstrained; if let Some(result) = record.function_queries[429].get_mut(&__args[..]) { if !__cu && *result.multiplicity == G::ZERO { aiur_fn_429(__args, record, io_buffer, false)? } else { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_429] = unsafe { *(result.output.as_ptr() as *const [G; OUT_429]) }; __ret } } else { aiur_fn_429(__args, record, io_buffer, __cu)? } }; let __v_8: G = __r_arr[0]; - let __ret: [G; OUT_434] = [__v_8]; - if let Some(result) = record.function_queries[434].get_mut(&inp[..]) { debug_assert_eq!(result.output, &__ret[..]); if !unconstrained { *result.multiplicity += G::ONE; } } else { record.function_queries[434].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained)); }; + let __ret: [G; OUT_430] = [__v_8]; + if let Some(result) = record.function_queries[430].get_mut(&inp[..]) { debug_assert_eq!(result.output, &__ret[..]); if !unconstrained { *result.multiplicity += G::ONE; } } else { record.function_queries[430].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained)); }; return Ok(__ret); }, 7u64 => { match __v_3.as_canonical_u64() { 0u64 => { let __v_6: G = G::from_u64(2); - let __r_arr: [G; OUT_382] = { let __args: [G; IN_382] = []; let __cu = unconstrained; if let Some(result) = record.function_queries[382].get_mut(&__args[..]) { if !__cu && *result.multiplicity == G::ZERO { aiur_fn_382(__args, record, io_buffer, false)? } else { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_382] = unsafe { *(result.output.as_ptr() as *const [G; OUT_382]) }; __ret } } else { aiur_fn_382(__args, record, io_buffer, __cu)? } }; + let __r_arr: [G; OUT_378] = { let __args: [G; IN_378] = []; let __cu = unconstrained; if let Some(result) = record.function_queries[378].get_mut(&__args[..]) { if !__cu && *result.multiplicity == G::ZERO { aiur_fn_378(__args, record, io_buffer, false)? } else { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_378] = unsafe { *(result.output.as_ptr() as *const [G; OUT_378]) }; __ret } } else { aiur_fn_378(__args, record, io_buffer, __cu)? } }; let __v_7: G = __r_arr[0]; let __v_8: G = G::from_u64(1); let __v_9: G = G::from_u64(1); let __v_10: G = { let __values: [G; 3] = [__v_8, __v_9, __v_9]; let __mq = record.memory_queries.get_mut(&3).ok_or(ExecError::InvalidMemorySize(3))?; if let Some(result) = __mq.get_mut(&__values[..]) { if !unconstrained { *result.multiplicity += G::ONE; } result.output[0] } else { let __ptr = G::from_usize(__mq.len()); __mq.insert(&__values[..], &[__ptr], G::from_bool(!unconstrained)); __ptr } }; let __v_11: G = G::from_u64(0); let __v_12: G = { let __values: [G; 4] = [__v_6, __v_7, __v_10, __v_11]; let __mq = record.memory_queries.get_mut(&4).ok_or(ExecError::InvalidMemorySize(4))?; if let Some(result) = __mq.get_mut(&__values[..]) { if !unconstrained { *result.multiplicity += G::ONE; } result.output[0] } else { let __ptr = G::from_usize(__mq.len()); __mq.insert(&__values[..], &[__ptr], G::from_bool(!unconstrained)); __ptr } }; - let __ret: [G; OUT_434] = [__v_12]; - if let Some(result) = record.function_queries[434].get_mut(&inp[..]) { debug_assert_eq!(result.output, &__ret[..]); if !unconstrained { *result.multiplicity += G::ONE; } } else { record.function_queries[434].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained)); }; + let __ret: [G; OUT_430] = [__v_12]; + if let Some(result) = record.function_queries[430].get_mut(&inp[..]) { debug_assert_eq!(result.output, &__ret[..]); if !unconstrained { *result.multiplicity += G::ONE; } } else { record.function_queries[430].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained)); }; return Ok(__ret); }, 1u64 => { let __v_6: G = G::from_u64(2); - let __r_arr: [G; OUT_218] = { let __args: [G; IN_218] = []; let __cu = unconstrained; if let Some(result) = record.function_queries[218].get_mut(&__args[..]) { if !__cu && *result.multiplicity == G::ZERO { aiur_fn_218(__args, record, io_buffer, false)? } else { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_218] = unsafe { *(result.output.as_ptr() as *const [G; OUT_218]) }; __ret } } else { aiur_fn_218(__args, record, io_buffer, __cu)? } }; + let __r_arr: [G; OUT_214] = { let __args: [G; IN_214] = []; let __cu = unconstrained; if let Some(result) = record.function_queries[214].get_mut(&__args[..]) { if !__cu && *result.multiplicity == G::ZERO { aiur_fn_214(__args, record, io_buffer, false)? } else { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_214] = unsafe { *(result.output.as_ptr() as *const [G; OUT_214]) }; __ret } } else { aiur_fn_214(__args, record, io_buffer, __cu)? } }; let __v_7: G = __r_arr[0]; let __v_8: G = G::from_u64(1); let __v_9: G = G::from_u64(1); let __v_10: G = { let __values: [G; 3] = [__v_8, __v_9, __v_9]; let __mq = record.memory_queries.get_mut(&3).ok_or(ExecError::InvalidMemorySize(3))?; if let Some(result) = __mq.get_mut(&__values[..]) { if !unconstrained { *result.multiplicity += G::ONE; } result.output[0] } else { let __ptr = G::from_usize(__mq.len()); __mq.insert(&__values[..], &[__ptr], G::from_bool(!unconstrained)); __ptr } }; let __v_11: G = G::from_u64(0); let __v_12: G = { let __values: [G; 4] = [__v_6, __v_7, __v_10, __v_11]; let __mq = record.memory_queries.get_mut(&4).ok_or(ExecError::InvalidMemorySize(4))?; if let Some(result) = __mq.get_mut(&__values[..]) { if !unconstrained { *result.multiplicity += G::ONE; } result.output[0] } else { let __ptr = G::from_usize(__mq.len()); __mq.insert(&__values[..], &[__ptr], G::from_bool(!unconstrained)); __ptr } }; - let __ret: [G; OUT_434] = [__v_12]; - if let Some(result) = record.function_queries[434].get_mut(&inp[..]) { debug_assert_eq!(result.output, &__ret[..]); if !unconstrained { *result.multiplicity += G::ONE; } } else { record.function_queries[434].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained)); }; + let __ret: [G; OUT_430] = [__v_12]; + if let Some(result) = record.function_queries[430].get_mut(&inp[..]) { debug_assert_eq!(result.output, &__ret[..]); if !unconstrained { *result.multiplicity += G::ONE; } } else { record.function_queries[430].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained)); }; return Ok(__ret); }, _ => { @@ -39073,9 +38799,9 @@ fn aiur_fn_434( } }, 8u64 => { - let __r_arr: [G; OUT_433] = { let __args: [G; IN_433] = [__v_5, __v_1]; let __cu = unconstrained; if let Some(result) = record.function_queries[433].get_mut(&__args[..]) { if !__cu && *result.multiplicity == G::ZERO { aiur_fn_433(__args, record, io_buffer, false)? } else { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_433] = unsafe { *(result.output.as_ptr() as *const [G; OUT_433]) }; __ret } } else { aiur_fn_433(__args, record, io_buffer, __cu)? } }; + let __r_arr: [G; OUT_429] = { let __args: [G; IN_429] = [__v_5, __v_1]; let __cu = unconstrained; if let Some(result) = record.function_queries[429].get_mut(&__args[..]) { if !__cu && *result.multiplicity == G::ZERO { aiur_fn_429(__args, record, io_buffer, false)? } else { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_429] = unsafe { *(result.output.as_ptr() as *const [G; OUT_429]) }; __ret } } else { aiur_fn_429(__args, record, io_buffer, __cu)? } }; let __v_6: G = __r_arr[0]; - let __r_arr: [G; OUT_418] = { let __args: [G; IN_418] = [__v_6, __v_1]; let __cu = unconstrained; if let Some(result) = record.function_queries[418].get_mut(&__args[..]) { if !__cu && *result.multiplicity == G::ZERO { aiur_fn_418(__args, record, io_buffer, false)? } else { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_418] = unsafe { *(result.output.as_ptr() as *const [G; OUT_418]) }; __ret } } else { aiur_fn_418(__args, record, io_buffer, __cu)? } }; + let __r_arr: [G; OUT_414] = { let __args: [G; IN_414] = [__v_6, __v_1]; let __cu = unconstrained; if let Some(result) = record.function_queries[414].get_mut(&__args[..]) { if !__cu && *result.multiplicity == G::ZERO { aiur_fn_414(__args, record, io_buffer, false)? } else { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_414] = unsafe { *(result.output.as_ptr() as *const [G; OUT_414]) }; __ret } } else { aiur_fn_414(__args, record, io_buffer, __cu)? } }; let __v_7: G = __r_arr[0]; let __r_arr: [G; OUT_111] = { let __args: [G; IN_111] = [__v_7]; let __cu = unconstrained; if let Some(result) = record.function_queries[111].get_mut(&__args[..]) { if !__cu && *result.multiplicity == G::ZERO { aiur_fn_111(__args, record, io_buffer, false)? } else { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_111] = unsafe { *(result.output.as_ptr() as *const [G; OUT_111]) }; __ret } } else { aiur_fn_111(__args, record, io_buffer, __cu)? } }; let __v_8: G = __r_arr[0]; @@ -39087,7 +38813,7 @@ fn aiur_fn_434( let __v_13: G = __loaded[3]; match __v_10.as_canonical_u64() { 2u64 => { - let __r_arr: [G; OUT_287] = { let __args: [G; IN_287] = [__v_11]; let __cu = unconstrained; if let Some(result) = record.function_queries[287].get_mut(&__args[..]) { if !__cu && *result.multiplicity == G::ZERO { aiur_fn_287(__args, record, io_buffer, false)? } else { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_287] = unsafe { *(result.output.as_ptr() as *const [G; OUT_287]) }; __ret } } else { aiur_fn_287(__args, record, io_buffer, __cu)? } }; + let __r_arr: [G; OUT_283] = { let __args: [G; IN_283] = [__v_11]; let __cu = unconstrained; if let Some(result) = record.function_queries[283].get_mut(&__args[..]) { if !__cu && *result.multiplicity == G::ZERO { aiur_fn_283(__args, record, io_buffer, false)? } else { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_283] = unsafe { *(result.output.as_ptr() as *const [G; OUT_283]) }; __ret } } else { aiur_fn_283(__args, record, io_buffer, __cu)? } }; let __v_14: G = __r_arr[0]; let __loaded: [G; 12] = { let __mq = record.memory_queries.get_mut(&12).ok_or(ExecError::InvalidMemorySize(12))?; let __ptr_u64 = __v_14.as_canonical_u64(); let __ptr_usize = usize::try_from(__ptr_u64).ok().ok_or(ExecError::PointerTooLarge(__ptr_u64))?; let (__args, __mult) = __mq.get_index_mut(__ptr_usize).ok_or(ExecError::UnboundPointer { ptr: __ptr_u64, size: 12 })?; if !unconstrained { *__mult += G::ONE; } let __arr: [G; 12] = __args[..12].try_into().unwrap(); __arr }; let __v_15: G = __loaded[0]; @@ -39108,7 +38834,7 @@ fn aiur_fn_434( match __v_15.as_canonical_u64() { 5u64 => { let __v_27: G = G::from_u64(0); - let __r_arr: [G; OUT_290] = { let __args: [G; IN_290] = [__v_22, __v_23, __v_27]; let __cu = unconstrained; if let Some(result) = record.function_queries[290].get_mut(&__args[..]) { if !__cu && *result.multiplicity == G::ZERO { aiur_fn_290(__args, record, io_buffer, false)? } else { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_290] = unsafe { *(result.output.as_ptr() as *const [G; OUT_290]) }; __ret } } else { aiur_fn_290(__args, record, io_buffer, __cu)? } }; + let __r_arr: [G; OUT_286] = { let __args: [G; IN_286] = [__v_22, __v_23, __v_27]; let __cu = unconstrained; if let Some(result) = record.function_queries[286].get_mut(&__args[..]) { if !__cu && *result.multiplicity == G::ZERO { aiur_fn_286(__args, record, io_buffer, false)? } else { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_286] = unsafe { *(result.output.as_ptr() as *const [G; OUT_286]) }; __ret } } else { aiur_fn_286(__args, record, io_buffer, __cu)? } }; let __v_28: G = __r_arr[0]; let __loaded: [G; 12] = { let __mq = record.memory_queries.get_mut(&12).ok_or(ExecError::InvalidMemorySize(12))?; let __ptr_u64 = __v_28.as_canonical_u64(); let __ptr_usize = usize::try_from(__ptr_u64).ok().ok_or(ExecError::PointerTooLarge(__ptr_u64))?; let (__args, __mult) = __mq.get_index_mut(__ptr_usize).ok_or(ExecError::UnboundPointer { ptr: __ptr_u64, size: 12 })?; if !unconstrained { *__mult += G::ONE; } let __arr: [G; 12] = __args[..12].try_into().unwrap(); __arr }; let __v_29: G = __loaded[0]; @@ -39129,15 +38855,15 @@ fn aiur_fn_434( } match __v_29.as_canonical_u64() { 6u64 => { - let __r_arr: [G; OUT_336] = { let __args: [G; IN_336] = [__v_31, __v_12]; let __cu = unconstrained; if let Some(result) = record.function_queries[336].get_mut(&__args[..]) { if !__cu && *result.multiplicity == G::ZERO { aiur_fn_336(__args, record, io_buffer, false)? } else { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_336] = unsafe { *(result.output.as_ptr() as *const [G; OUT_336]) }; __ret } } else { aiur_fn_336(__args, record, io_buffer, __cu)? } }; + let __r_arr: [G; OUT_332] = { let __args: [G; IN_332] = [__v_31, __v_12]; let __cu = unconstrained; if let Some(result) = record.function_queries[332].get_mut(&__args[..]) { if !__cu && *result.multiplicity == G::ZERO { aiur_fn_332(__args, record, io_buffer, false)? } else { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_332] = unsafe { *(result.output.as_ptr() as *const [G; OUT_332]) }; __ret } } else { aiur_fn_332(__args, record, io_buffer, __cu)? } }; let __v_42: G = __r_arr[0]; - let __r_arr: [G; OUT_436] = { let __args: [G; IN_436] = [__v_42, __v_9, __v_18]; let __cu = unconstrained; if let Some(result) = record.function_queries[436].get_mut(&__args[..]) { if !__cu && *result.multiplicity == G::ZERO { aiur_fn_436(__args, record, io_buffer, false)? } else { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_436] = unsafe { *(result.output.as_ptr() as *const [G; OUT_436]) }; __ret } } else { aiur_fn_436(__args, record, io_buffer, __cu)? } }; + let __r_arr: [G; OUT_432] = { let __args: [G; IN_432] = [__v_42, __v_9, __v_18]; let __cu = unconstrained; if let Some(result) = record.function_queries[432].get_mut(&__args[..]) { if !__cu && *result.multiplicity == G::ZERO { aiur_fn_432(__args, record, io_buffer, false)? } else { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_432] = unsafe { *(result.output.as_ptr() as *const [G; OUT_432]) }; __ret } } else { aiur_fn_432(__args, record, io_buffer, __cu)? } }; let __v_43: G = __r_arr[0]; let __v_44: G = G::from_u64(0); - let __r_arr: [G; OUT_437] = { let __args: [G; IN_437] = [__v_43, __v_4, __v_44, __v_3, __v_5]; let __cu = unconstrained; if let Some(result) = record.function_queries[437].get_mut(&__args[..]) { if !__cu && *result.multiplicity == G::ZERO { aiur_fn_437(__args, record, io_buffer, false)? } else { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_437] = unsafe { *(result.output.as_ptr() as *const [G; OUT_437]) }; __ret } } else { aiur_fn_437(__args, record, io_buffer, __cu)? } }; + let __r_arr: [G; OUT_433] = { let __args: [G; IN_433] = [__v_43, __v_4, __v_44, __v_3, __v_5]; let __cu = unconstrained; if let Some(result) = record.function_queries[433].get_mut(&__args[..]) { if !__cu && *result.multiplicity == G::ZERO { aiur_fn_433(__args, record, io_buffer, false)? } else { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_433] = unsafe { *(result.output.as_ptr() as *const [G; OUT_433]) }; __ret } } else { aiur_fn_433(__args, record, io_buffer, __cu)? } }; let __v_45: G = __r_arr[0]; - let __ret: [G; OUT_434] = [__v_45]; - if let Some(result) = record.function_queries[434].get_mut(&inp[..]) { debug_assert_eq!(result.output, &__ret[..]); if !unconstrained { *result.multiplicity += G::ONE; } } else { record.function_queries[434].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained)); }; + let __ret: [G; OUT_430] = [__v_45]; + if let Some(result) = record.function_queries[430].get_mut(&inp[..]) { debug_assert_eq!(result.output, &__ret[..]); if !unconstrained { *result.multiplicity += G::ONE; } } else { record.function_queries[430].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained)); }; return Ok(__ret); }, _ => { @@ -39162,19 +38888,19 @@ fn aiur_fn_434( }) } -const INPUT_SIZE_435: usize = 2; -const IN_435: usize = 2; -const OUT_435: usize = 1; -fn aiur_fn_435( - inp: [G; IN_435], +const INPUT_SIZE_431: usize = 2; +const IN_431: usize = 2; +const OUT_431: usize = 1; +fn aiur_fn_431( + inp: [G; IN_431], record: &mut QueryRecord, io_buffer: &mut IOBuffer, unconstrained: bool, -) -> Result<[G; OUT_435], ExecError> { +) -> Result<[G; OUT_431], ExecError> { stacker::maybe_grow(64 * 1024, 4 * 1024 * 1024, || { let __v_0: G = inp[0]; let __v_1: G = inp[1]; - let __r_arr: [G; OUT_433] = { let __args: [G; IN_433] = [__v_0, __v_1]; let __cu = unconstrained; if let Some(result) = record.function_queries[433].get_mut(&__args[..]) { if !__cu && *result.multiplicity == G::ZERO { aiur_fn_433(__args, record, io_buffer, false)? } else { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_433] = unsafe { *(result.output.as_ptr() as *const [G; OUT_433]) }; __ret } } else { aiur_fn_433(__args, record, io_buffer, __cu)? } }; + let __r_arr: [G; OUT_429] = { let __args: [G; IN_429] = [__v_0, __v_1]; let __cu = unconstrained; if let Some(result) = record.function_queries[429].get_mut(&__args[..]) { if !__cu && *result.multiplicity == G::ZERO { aiur_fn_429(__args, record, io_buffer, false)? } else { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_429] = unsafe { *(result.output.as_ptr() as *const [G; OUT_429]) }; __ret } } else { aiur_fn_429(__args, record, io_buffer, __cu)? } }; let __v_2: G = __r_arr[0]; let __loaded: [G; 4] = { let __mq = record.memory_queries.get_mut(&4).ok_or(ExecError::InvalidMemorySize(4))?; let __ptr_u64 = __v_2.as_canonical_u64(); let __ptr_usize = usize::try_from(__ptr_u64).ok().ok_or(ExecError::PointerTooLarge(__ptr_u64))?; let (__args, __mult) = __mq.get_index_mut(__ptr_usize).ok_or(ExecError::UnboundPointer { ptr: __ptr_u64, size: 4 })?; if !unconstrained { *__mult += G::ONE; } let __arr: [G; 4] = __args[..4].try_into().unwrap(); __arr }; let __v_3: G = __loaded[0]; @@ -39183,12 +38909,12 @@ fn aiur_fn_435( let __v_6: G = __loaded[3]; match __v_3.as_canonical_u64() { 1u64 => { - let __ret: [G; OUT_435] = [__v_4]; - if let Some(result) = record.function_queries[435].get_mut(&inp[..]) { debug_assert_eq!(result.output, &__ret[..]); if !unconstrained { *result.multiplicity += G::ONE; } } else { record.function_queries[435].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained)); }; + let __ret: [G; OUT_431] = [__v_4]; + if let Some(result) = record.function_queries[431].get_mut(&inp[..]) { debug_assert_eq!(result.output, &__ret[..]); if !unconstrained { *result.multiplicity += G::ONE; } } else { record.function_queries[431].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained)); }; return Ok(__ret); }, _ => { - let __r_arr: [G; OUT_418] = { let __args: [G; IN_418] = [__v_2, __v_1]; let __cu = unconstrained; if let Some(result) = record.function_queries[418].get_mut(&__args[..]) { if !__cu && *result.multiplicity == G::ZERO { aiur_fn_418(__args, record, io_buffer, false)? } else { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_418] = unsafe { *(result.output.as_ptr() as *const [G; OUT_418]) }; __ret } } else { aiur_fn_418(__args, record, io_buffer, __cu)? } }; + let __r_arr: [G; OUT_414] = { let __args: [G; IN_414] = [__v_2, __v_1]; let __cu = unconstrained; if let Some(result) = record.function_queries[414].get_mut(&__args[..]) { if !__cu && *result.multiplicity == G::ZERO { aiur_fn_414(__args, record, io_buffer, false)? } else { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_414] = unsafe { *(result.output.as_ptr() as *const [G; OUT_414]) }; __ret } } else { aiur_fn_414(__args, record, io_buffer, __cu)? } }; let __v_7: G = __r_arr[0]; let __loaded: [G; 4] = { let __mq = record.memory_queries.get_mut(&4).ok_or(ExecError::InvalidMemorySize(4))?; let __ptr_u64 = __v_7.as_canonical_u64(); let __ptr_usize = usize::try_from(__ptr_u64).ok().ok_or(ExecError::PointerTooLarge(__ptr_u64))?; let (__args, __mult) = __mq.get_index_mut(__ptr_usize).ok_or(ExecError::UnboundPointer { ptr: __ptr_u64, size: 4 })?; if !unconstrained { *__mult += G::ONE; } let __arr: [G; 4] = __args[..4].try_into().unwrap(); __arr }; let __v_8: G = __loaded[0]; @@ -39197,8 +38923,8 @@ fn aiur_fn_435( let __v_11: G = __loaded[3]; match __v_8.as_canonical_u64() { 1u64 => { - let __ret: [G; OUT_435] = [__v_9]; - if let Some(result) = record.function_queries[435].get_mut(&inp[..]) { debug_assert_eq!(result.output, &__ret[..]); if !unconstrained { *result.multiplicity += G::ONE; } } else { record.function_queries[435].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained)); }; + let __ret: [G; OUT_431] = [__v_9]; + if let Some(result) = record.function_queries[431].get_mut(&inp[..]) { debug_assert_eq!(result.output, &__ret[..]); if !unconstrained { *result.multiplicity += G::ONE; } } else { record.function_queries[431].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained)); }; return Ok(__ret); }, _ => { @@ -39210,23 +38936,23 @@ fn aiur_fn_435( }) } -const INPUT_SIZE_436: usize = 3; -const IN_436: usize = 3; -const OUT_436: usize = 1; -fn aiur_fn_436( - inp: [G; IN_436], +const INPUT_SIZE_432: usize = 3; +const IN_432: usize = 3; +const OUT_432: usize = 1; +fn aiur_fn_432( + inp: [G; IN_432], record: &mut QueryRecord, io_buffer: &mut IOBuffer, unconstrained: bool, -) -> Result<[G; OUT_436], ExecError> { +) -> Result<[G; OUT_432], ExecError> { stacker::maybe_grow(64 * 1024, 4 * 1024 * 1024, || { let __v_0: G = inp[0]; let __v_1: G = inp[1]; let __v_2: G = inp[2]; match __v_2.as_canonical_u64() { 0u64 => { - let __ret: [G; OUT_436] = [__v_0]; - if let Some(result) = record.function_queries[436].get_mut(&inp[..]) { debug_assert_eq!(result.output, &__ret[..]); if !unconstrained { *result.multiplicity += G::ONE; } } else { record.function_queries[436].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained)); }; + let __ret: [G; OUT_432] = [__v_0]; + if let Some(result) = record.function_queries[432].get_mut(&inp[..]) { debug_assert_eq!(result.output, &__ret[..]); if !unconstrained { *result.multiplicity += G::ONE; } } else { record.function_queries[432].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained)); }; return Ok(__ret); }, _ => { @@ -39244,14 +38970,14 @@ fn aiur_fn_436( match __v_7.as_canonical_u64() { 0u64 => { let __v_10: G = G::from_u64(0); - let __r_arr: [G; OUT_368] = { let __args: [G; IN_368] = [__v_5, __v_8, __v_10]; let __cu = unconstrained; if let Some(result) = record.function_queries[368].get_mut(&__args[..]) { if !__cu && *result.multiplicity == G::ZERO { aiur_fn_368(__args, record, io_buffer, false)? } else { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_368] = unsafe { *(result.output.as_ptr() as *const [G; OUT_368]) }; __ret } } else { aiur_fn_368(__args, record, io_buffer, __cu)? } }; + let __r_arr: [G; OUT_364] = { let __args: [G; IN_364] = [__v_5, __v_8, __v_10]; let __cu = unconstrained; if let Some(result) = record.function_queries[364].get_mut(&__args[..]) { if !__cu && *result.multiplicity == G::ZERO { aiur_fn_364(__args, record, io_buffer, false)? } else { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_364] = unsafe { *(result.output.as_ptr() as *const [G; OUT_364]) }; __ret } } else { aiur_fn_364(__args, record, io_buffer, __cu)? } }; let __v_11: G = __r_arr[0]; let __v_12: G = G::from_u64(1); let __v_13: G = (__v_2 - __v_12); - let __r_arr: [G; OUT_436] = { let __args: [G; IN_436] = [__v_11, __v_9, __v_13]; let __cu = unconstrained; if let Some(result) = record.function_queries[436].get_mut(&__args[..]) { if !__cu && *result.multiplicity == G::ZERO { aiur_fn_436(__args, record, io_buffer, false)? } else { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_436] = unsafe { *(result.output.as_ptr() as *const [G; OUT_436]) }; __ret } } else { aiur_fn_436(__args, record, io_buffer, __cu)? } }; + let __r_arr: [G; OUT_432] = { let __args: [G; IN_432] = [__v_11, __v_9, __v_13]; let __cu = unconstrained; if let Some(result) = record.function_queries[432].get_mut(&__args[..]) { if !__cu && *result.multiplicity == G::ZERO { aiur_fn_432(__args, record, io_buffer, false)? } else { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_432] = unsafe { *(result.output.as_ptr() as *const [G; OUT_432]) }; __ret } } else { aiur_fn_432(__args, record, io_buffer, __cu)? } }; let __v_14: G = __r_arr[0]; - let __ret: [G; OUT_436] = [__v_14]; - if let Some(result) = record.function_queries[436].get_mut(&inp[..]) { debug_assert_eq!(result.output, &__ret[..]); if !unconstrained { *result.multiplicity += G::ONE; } } else { record.function_queries[436].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained)); }; + let __ret: [G; OUT_432] = [__v_14]; + if let Some(result) = record.function_queries[432].get_mut(&inp[..]) { debug_assert_eq!(result.output, &__ret[..]); if !unconstrained { *result.multiplicity += G::ONE; } } else { record.function_queries[432].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained)); }; return Ok(__ret); }, _ => { @@ -39268,15 +38994,15 @@ fn aiur_fn_436( }) } -const INPUT_SIZE_437: usize = 5; -const IN_437: usize = 5; -const OUT_437: usize = 1; -fn aiur_fn_437( - inp: [G; IN_437], +const INPUT_SIZE_433: usize = 5; +const IN_433: usize = 5; +const OUT_433: usize = 1; +fn aiur_fn_433( + inp: [G; IN_433], record: &mut QueryRecord, io_buffer: &mut IOBuffer, unconstrained: bool, -) -> Result<[G; OUT_437], ExecError> { +) -> Result<[G; OUT_433], ExecError> { stacker::maybe_grow(64 * 1024, 4 * 1024 * 1024, || { let __v_0: G = inp[0]; let __v_1: G = inp[1]; @@ -39293,22 +39019,22 @@ fn aiur_fn_437( let __v_9: G = (__v_1 - __v_2); match __v_9.as_canonical_u64() { 0u64 => { - let __ret: [G; OUT_437] = [__v_6]; - if let Some(result) = record.function_queries[437].get_mut(&inp[..]) { debug_assert_eq!(result.output, &__ret[..]); if !unconstrained { *result.multiplicity += G::ONE; } } else { record.function_queries[437].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained)); }; + let __ret: [G; OUT_433] = [__v_6]; + if let Some(result) = record.function_queries[433].get_mut(&inp[..]) { debug_assert_eq!(result.output, &__ret[..]); if !unconstrained { *result.multiplicity += G::ONE; } } else { record.function_queries[433].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained)); }; return Ok(__ret); }, _ => { let __v_10: G = G::from_u64(8); let __v_11: G = { let __values: [G; 4] = [__v_10, __v_3, __v_2, __v_4]; let __mq = record.memory_queries.get_mut(&4).ok_or(ExecError::InvalidMemorySize(4))?; if let Some(result) = __mq.get_mut(&__values[..]) { if !unconstrained { *result.multiplicity += G::ONE; } result.output[0] } else { let __ptr = G::from_usize(__mq.len()); __mq.insert(&__values[..], &[__ptr], G::from_bool(!unconstrained)); __ptr } }; let __v_12: G = G::from_u64(0); - let __r_arr: [G; OUT_368] = { let __args: [G; IN_368] = [__v_7, __v_11, __v_12]; let __cu = unconstrained; if let Some(result) = record.function_queries[368].get_mut(&__args[..]) { if !__cu && *result.multiplicity == G::ZERO { aiur_fn_368(__args, record, io_buffer, false)? } else { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_368] = unsafe { *(result.output.as_ptr() as *const [G; OUT_368]) }; __ret } } else { aiur_fn_368(__args, record, io_buffer, __cu)? } }; + let __r_arr: [G; OUT_364] = { let __args: [G; IN_364] = [__v_7, __v_11, __v_12]; let __cu = unconstrained; if let Some(result) = record.function_queries[364].get_mut(&__args[..]) { if !__cu && *result.multiplicity == G::ZERO { aiur_fn_364(__args, record, io_buffer, false)? } else { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_364] = unsafe { *(result.output.as_ptr() as *const [G; OUT_364]) }; __ret } } else { aiur_fn_364(__args, record, io_buffer, __cu)? } }; let __v_13: G = __r_arr[0]; let __v_14: G = G::from_u64(1); let __v_15: G = (__v_2 + __v_14); - let __r_arr: [G; OUT_437] = { let __args: [G; IN_437] = [__v_13, __v_1, __v_15, __v_3, __v_4]; let __cu = unconstrained; if let Some(result) = record.function_queries[437].get_mut(&__args[..]) { if !__cu && *result.multiplicity == G::ZERO { aiur_fn_437(__args, record, io_buffer, false)? } else { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_437] = unsafe { *(result.output.as_ptr() as *const [G; OUT_437]) }; __ret } } else { aiur_fn_437(__args, record, io_buffer, __cu)? } }; + let __r_arr: [G; OUT_433] = { let __args: [G; IN_433] = [__v_13, __v_1, __v_15, __v_3, __v_4]; let __cu = unconstrained; if let Some(result) = record.function_queries[433].get_mut(&__args[..]) { if !__cu && *result.multiplicity == G::ZERO { aiur_fn_433(__args, record, io_buffer, false)? } else { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_433] = unsafe { *(result.output.as_ptr() as *const [G; OUT_433]) }; __ret } } else { aiur_fn_433(__args, record, io_buffer, __cu)? } }; let __v_16: G = __r_arr[0]; - let __ret: [G; OUT_437] = [__v_16]; - if let Some(result) = record.function_queries[437].get_mut(&inp[..]) { debug_assert_eq!(result.output, &__ret[..]); if !unconstrained { *result.multiplicity += G::ONE; } } else { record.function_queries[437].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained)); }; + let __ret: [G; OUT_433] = [__v_16]; + if let Some(result) = record.function_queries[433].get_mut(&inp[..]) { debug_assert_eq!(result.output, &__ret[..]); if !unconstrained { *result.multiplicity += G::ONE; } } else { record.function_queries[433].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained)); }; return Ok(__ret); }, } @@ -39320,15 +39046,15 @@ fn aiur_fn_437( }) } -const INPUT_SIZE_438: usize = 2; -const IN_438: usize = 2; -const OUT_438: usize = 1; -fn aiur_fn_438( - inp: [G; IN_438], +const INPUT_SIZE_434: usize = 2; +const IN_434: usize = 2; +const OUT_434: usize = 1; +fn aiur_fn_434( + inp: [G; IN_434], record: &mut QueryRecord, io_buffer: &mut IOBuffer, unconstrained: bool, -) -> Result<[G; OUT_438], ExecError> { +) -> Result<[G; OUT_434], ExecError> { stacker::maybe_grow(64 * 1024, 4 * 1024 * 1024, || { let __v_0: G = inp[0]; let __v_1: G = inp[1]; @@ -39345,14 +39071,14 @@ fn aiur_fn_438( match __v_5.as_canonical_u64() { 1u64 => { let __v_8: G = G::from_u64(1); - let __ret: [G; OUT_438] = [__v_8]; - if let Some(result) = record.function_queries[438].get_mut(&inp[..]) { debug_assert_eq!(result.output, &__ret[..]); if !unconstrained { *result.multiplicity += G::ONE; } } else { record.function_queries[438].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained)); }; + let __ret: [G; OUT_434] = [__v_8]; + if let Some(result) = record.function_queries[434].get_mut(&inp[..]) { debug_assert_eq!(result.output, &__ret[..]); if !unconstrained { *result.multiplicity += G::ONE; } } else { record.function_queries[434].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained)); }; return Ok(__ret); }, _ => { let __v_8: G = G::from_u64(0); - let __ret: [G; OUT_438] = [__v_8]; - if let Some(result) = record.function_queries[438].get_mut(&inp[..]) { debug_assert_eq!(result.output, &__ret[..]); if !unconstrained { *result.multiplicity += G::ONE; } } else { record.function_queries[438].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained)); }; + let __ret: [G; OUT_434] = [__v_8]; + if let Some(result) = record.function_queries[434].get_mut(&inp[..]) { debug_assert_eq!(result.output, &__ret[..]); if !unconstrained { *result.multiplicity += G::ONE; } } else { record.function_queries[434].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained)); }; return Ok(__ret); }, } @@ -39365,25 +39091,25 @@ fn aiur_fn_438( match __v_5.as_canonical_u64() { 1u64 => { let __v_8: G = G::from_u64(0); - let __ret: [G; OUT_438] = [__v_8]; - if let Some(result) = record.function_queries[438].get_mut(&inp[..]) { debug_assert_eq!(result.output, &__ret[..]); if !unconstrained { *result.multiplicity += G::ONE; } } else { record.function_queries[438].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained)); }; + let __ret: [G; OUT_434] = [__v_8]; + if let Some(result) = record.function_queries[434].get_mut(&inp[..]) { debug_assert_eq!(result.output, &__ret[..]); if !unconstrained { *result.multiplicity += G::ONE; } } else { record.function_queries[434].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained)); }; return Ok(__ret); }, 0u64 => { - let __r_arr: [G; OUT_324] = { let __args: [G; IN_324] = [__v_3, __v_6]; let __cu = unconstrained; if let Some(result) = record.function_queries[324].get_mut(&__args[..]) { if !__cu && *result.multiplicity == G::ZERO { aiur_fn_324(__args, record, io_buffer, false)? } else { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_324] = unsafe { *(result.output.as_ptr() as *const [G; OUT_324]) }; __ret } } else { aiur_fn_324(__args, record, io_buffer, __cu)? } }; + let __r_arr: [G; OUT_320] = { let __args: [G; IN_320] = [__v_3, __v_6]; let __cu = unconstrained; if let Some(result) = record.function_queries[320].get_mut(&__args[..]) { if !__cu && *result.multiplicity == G::ZERO { aiur_fn_320(__args, record, io_buffer, false)? } else { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_320] = unsafe { *(result.output.as_ptr() as *const [G; OUT_320]) }; __ret } } else { aiur_fn_320(__args, record, io_buffer, __cu)? } }; let __v_8: G = __r_arr[0]; match __v_8.as_canonical_u64() { 0u64 => { let __v_9: G = G::from_u64(0); - let __ret: [G; OUT_438] = [__v_9]; - if let Some(result) = record.function_queries[438].get_mut(&inp[..]) { debug_assert_eq!(result.output, &__ret[..]); if !unconstrained { *result.multiplicity += G::ONE; } } else { record.function_queries[438].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained)); }; + let __ret: [G; OUT_434] = [__v_9]; + if let Some(result) = record.function_queries[434].get_mut(&inp[..]) { debug_assert_eq!(result.output, &__ret[..]); if !unconstrained { *result.multiplicity += G::ONE; } } else { record.function_queries[434].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained)); }; return Ok(__ret); }, _ => { - let __r_arr: [G; OUT_438] = { let __args: [G; IN_438] = [__v_4, __v_7]; let __cu = unconstrained; if let Some(result) = record.function_queries[438].get_mut(&__args[..]) { if !__cu && *result.multiplicity == G::ZERO { aiur_fn_438(__args, record, io_buffer, false)? } else { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_438] = unsafe { *(result.output.as_ptr() as *const [G; OUT_438]) }; __ret } } else { aiur_fn_438(__args, record, io_buffer, __cu)? } }; + let __r_arr: [G; OUT_434] = { let __args: [G; IN_434] = [__v_4, __v_7]; let __cu = unconstrained; if let Some(result) = record.function_queries[434].get_mut(&__args[..]) { if !__cu && *result.multiplicity == G::ZERO { aiur_fn_434(__args, record, io_buffer, false)? } else { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_434] = unsafe { *(result.output.as_ptr() as *const [G; OUT_434]) }; __ret } } else { aiur_fn_434(__args, record, io_buffer, __cu)? } }; let __v_9: G = __r_arr[0]; - let __ret: [G; OUT_438] = [__v_9]; - if let Some(result) = record.function_queries[438].get_mut(&inp[..]) { debug_assert_eq!(result.output, &__ret[..]); if !unconstrained { *result.multiplicity += G::ONE; } } else { record.function_queries[438].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained)); }; + let __ret: [G; OUT_434] = [__v_9]; + if let Some(result) = record.function_queries[434].get_mut(&inp[..]) { debug_assert_eq!(result.output, &__ret[..]); if !unconstrained { *result.multiplicity += G::ONE; } } else { record.function_queries[434].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained)); }; return Ok(__ret); }, } @@ -39400,15 +39126,15 @@ fn aiur_fn_438( }) } -const INPUT_SIZE_439: usize = 3; -const IN_439: usize = 3; -const OUT_439: usize = 1; -fn aiur_fn_439( - inp: [G; IN_439], +const INPUT_SIZE_435: usize = 3; +const IN_435: usize = 3; +const OUT_435: usize = 1; +fn aiur_fn_435( + inp: [G; IN_435], record: &mut QueryRecord, io_buffer: &mut IOBuffer, unconstrained: bool, -) -> Result<[G; OUT_439], ExecError> { +) -> Result<[G; OUT_435], ExecError> { stacker::maybe_grow(64 * 1024, 4 * 1024 * 1024, || { let __v_0: G = inp[0]; let __v_1: G = inp[1]; @@ -39417,33 +39143,33 @@ fn aiur_fn_439( match __v_3.as_canonical_u64() { 0u64 => { let __v_4: G = G::from_u64(1); - let __ret: [G; OUT_439] = [__v_4]; - if let Some(result) = record.function_queries[439].get_mut(&inp[..]) { debug_assert_eq!(result.output, &__ret[..]); if !unconstrained { *result.multiplicity += G::ONE; } } else { record.function_queries[439].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained)); }; + let __ret: [G; OUT_435] = [__v_4]; + if let Some(result) = record.function_queries[435].get_mut(&inp[..]) { debug_assert_eq!(result.output, &__ret[..]); if !unconstrained { *result.multiplicity += G::ONE; } } else { record.function_queries[435].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained)); }; return Ok(__ret); }, _ => { - let __r_arr: [G; OUT_341] = { let __args: [G; IN_341] = [__v_0]; let __cu = unconstrained; if let Some(result) = record.function_queries[341].get_mut(&__args[..]) { if !__cu && *result.multiplicity == G::ZERO { aiur_fn_341(__args, record, io_buffer, false)? } else { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_341] = unsafe { *(result.output.as_ptr() as *const [G; OUT_341]) }; __ret } } else { aiur_fn_341(__args, record, io_buffer, __cu)? } }; + let __r_arr: [G; OUT_337] = { let __args: [G; IN_337] = [__v_0]; let __cu = unconstrained; if let Some(result) = record.function_queries[337].get_mut(&__args[..]) { if !__cu && *result.multiplicity == G::ZERO { aiur_fn_337(__args, record, io_buffer, false)? } else { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_337] = unsafe { *(result.output.as_ptr() as *const [G; OUT_337]) }; __ret } } else { aiur_fn_337(__args, record, io_buffer, __cu)? } }; let __v_4: G = __r_arr[0]; - let __r_arr: [G; OUT_341] = { let __args: [G; IN_341] = [__v_1]; let __cu = unconstrained; if let Some(result) = record.function_queries[341].get_mut(&__args[..]) { if !__cu && *result.multiplicity == G::ZERO { aiur_fn_341(__args, record, io_buffer, false)? } else { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_341] = unsafe { *(result.output.as_ptr() as *const [G; OUT_341]) }; __ret } } else { aiur_fn_341(__args, record, io_buffer, __cu)? } }; + let __r_arr: [G; OUT_337] = { let __args: [G; IN_337] = [__v_1]; let __cu = unconstrained; if let Some(result) = record.function_queries[337].get_mut(&__args[..]) { if !__cu && *result.multiplicity == G::ZERO { aiur_fn_337(__args, record, io_buffer, false)? } else { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_337] = unsafe { *(result.output.as_ptr() as *const [G; OUT_337]) }; __ret } } else { aiur_fn_337(__args, record, io_buffer, __cu)? } }; let __v_5: G = __r_arr[0]; - let __r_arr: [G; OUT_343] = { let __args: [G; IN_343] = [__v_4, __v_5]; let __cu = unconstrained; if let Some(result) = record.function_queries[343].get_mut(&__args[..]) { if !__cu && *result.multiplicity == G::ZERO { aiur_fn_343(__args, record, io_buffer, false)? } else { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_343] = unsafe { *(result.output.as_ptr() as *const [G; OUT_343]) }; __ret } } else { aiur_fn_343(__args, record, io_buffer, __cu)? } }; + let __r_arr: [G; OUT_339] = { let __args: [G; IN_339] = [__v_4, __v_5]; let __cu = unconstrained; if let Some(result) = record.function_queries[339].get_mut(&__args[..]) { if !__cu && *result.multiplicity == G::ZERO { aiur_fn_339(__args, record, io_buffer, false)? } else { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_339] = unsafe { *(result.output.as_ptr() as *const [G; OUT_339]) }; __ret } } else { aiur_fn_339(__args, record, io_buffer, __cu)? } }; let __v_6: G = __r_arr[0]; match __v_6.as_canonical_u64() { 0u64 => { let __v_7: G = G::from_u64(1); let __v_8: G = G::from_u64(1); let __v_9: G = { let __values: [G; 3] = [__v_7, __v_8, __v_8]; let __mq = record.memory_queries.get_mut(&3).ok_or(ExecError::InvalidMemorySize(3))?; if let Some(result) = __mq.get_mut(&__values[..]) { if !unconstrained { *result.multiplicity += G::ONE; } result.output[0] } else { let __ptr = G::from_usize(__mq.len()); __mq.insert(&__values[..], &[__ptr], G::from_bool(!unconstrained)); __ptr } }; - let __r_arr: [G; OUT_441] = { let __args: [G; IN_441] = [__v_0, __v_1, __v_9]; let __cu = unconstrained; if let Some(result) = record.function_queries[441].get_mut(&__args[..]) { if !__cu && *result.multiplicity == G::ZERO { aiur_fn_441(__args, record, io_buffer, false)? } else { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_441] = unsafe { *(result.output.as_ptr() as *const [G; OUT_441]) }; __ret } } else { aiur_fn_441(__args, record, io_buffer, __cu)? } }; + let __r_arr: [G; OUT_437] = { let __args: [G; IN_437] = [__v_0, __v_1, __v_9]; let __cu = unconstrained; if let Some(result) = record.function_queries[437].get_mut(&__args[..]) { if !__cu && *result.multiplicity == G::ZERO { aiur_fn_437(__args, record, io_buffer, false)? } else { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_437] = unsafe { *(result.output.as_ptr() as *const [G; OUT_437]) }; __ret } } else { aiur_fn_437(__args, record, io_buffer, __cu)? } }; let __v_10: G = __r_arr[0]; - let __ret: [G; OUT_439] = [__v_10]; - if let Some(result) = record.function_queries[439].get_mut(&inp[..]) { debug_assert_eq!(result.output, &__ret[..]); if !unconstrained { *result.multiplicity += G::ONE; } } else { record.function_queries[439].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained)); }; + let __ret: [G; OUT_435] = [__v_10]; + if let Some(result) = record.function_queries[435].get_mut(&inp[..]) { debug_assert_eq!(result.output, &__ret[..]); if !unconstrained { *result.multiplicity += G::ONE; } } else { record.function_queries[435].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained)); }; return Ok(__ret); }, _ => { - let __r_arr: [G; OUT_440] = { let __args: [G; IN_440] = [__v_0, __v_1, __v_2, __v_6]; let __cu = unconstrained; if let Some(result) = record.function_queries[440].get_mut(&__args[..]) { if !__cu && *result.multiplicity == G::ZERO { aiur_fn_440(__args, record, io_buffer, false)? } else { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_440] = unsafe { *(result.output.as_ptr() as *const [G; OUT_440]) }; __ret } } else { aiur_fn_440(__args, record, io_buffer, __cu)? } }; + let __r_arr: [G; OUT_436] = { let __args: [G; IN_436] = [__v_0, __v_1, __v_2, __v_6]; let __cu = unconstrained; if let Some(result) = record.function_queries[436].get_mut(&__args[..]) { if !__cu && *result.multiplicity == G::ZERO { aiur_fn_436(__args, record, io_buffer, false)? } else { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_436] = unsafe { *(result.output.as_ptr() as *const [G; OUT_436]) }; __ret } } else { aiur_fn_436(__args, record, io_buffer, __cu)? } }; let __v_7: G = __r_arr[0]; - let __ret: [G; OUT_439] = [__v_7]; - if let Some(result) = record.function_queries[439].get_mut(&inp[..]) { debug_assert_eq!(result.output, &__ret[..]); if !unconstrained { *result.multiplicity += G::ONE; } } else { record.function_queries[439].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained)); }; + let __ret: [G; OUT_435] = [__v_7]; + if let Some(result) = record.function_queries[435].get_mut(&inp[..]) { debug_assert_eq!(result.output, &__ret[..]); if !unconstrained { *result.multiplicity += G::ONE; } } else { record.function_queries[435].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained)); }; return Ok(__ret); }, } @@ -39452,73 +39178,73 @@ fn aiur_fn_439( }) } -const INPUT_SIZE_440: usize = 4; -const IN_440: usize = 4; -const OUT_440: usize = 1; -fn aiur_fn_440( - inp: [G; IN_440], +const INPUT_SIZE_436: usize = 4; +const IN_436: usize = 4; +const OUT_436: usize = 1; +fn aiur_fn_436( + inp: [G; IN_436], record: &mut QueryRecord, io_buffer: &mut IOBuffer, unconstrained: bool, -) -> Result<[G; OUT_440], ExecError> { +) -> Result<[G; OUT_436], ExecError> { stacker::maybe_grow(64 * 1024, 4 * 1024 * 1024, || { let __v_0: G = inp[0]; let __v_1: G = inp[1]; let __v_2: G = inp[2]; let __v_3: G = inp[3]; let __v_4: G = G::from_u64(0); - let __r_arr: [G; OUT_355] = { let __args: [G; IN_355] = [__v_0, __v_4]; let __cu = unconstrained; if let Some(result) = record.function_queries[355].get_mut(&__args[..]) { if !__cu && *result.multiplicity == G::ZERO { aiur_fn_355(__args, record, io_buffer, false)? } else { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_355] = unsafe { *(result.output.as_ptr() as *const [G; OUT_355]) }; __ret } } else { aiur_fn_355(__args, record, io_buffer, __cu)? } }; + let __r_arr: [G; OUT_351] = { let __args: [G; IN_351] = [__v_0, __v_4]; let __cu = unconstrained; if let Some(result) = record.function_queries[351].get_mut(&__args[..]) { if !__cu && *result.multiplicity == G::ZERO { aiur_fn_351(__args, record, io_buffer, false)? } else { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_351] = unsafe { *(result.output.as_ptr() as *const [G; OUT_351]) }; __ret } } else { aiur_fn_351(__args, record, io_buffer, __cu)? } }; let __v_5: G = __r_arr[0]; let __v_6: G = G::from_u64(0); - let __r_arr: [G; OUT_355] = { let __args: [G; IN_355] = [__v_1, __v_6]; let __cu = unconstrained; if let Some(result) = record.function_queries[355].get_mut(&__args[..]) { if !__cu && *result.multiplicity == G::ZERO { aiur_fn_355(__args, record, io_buffer, false)? } else { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_355] = unsafe { *(result.output.as_ptr() as *const [G; OUT_355]) }; __ret } } else { aiur_fn_355(__args, record, io_buffer, __cu)? } }; + let __r_arr: [G; OUT_351] = { let __args: [G; IN_351] = [__v_1, __v_6]; let __cu = unconstrained; if let Some(result) = record.function_queries[351].get_mut(&__args[..]) { if !__cu && *result.multiplicity == G::ZERO { aiur_fn_351(__args, record, io_buffer, false)? } else { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_351] = unsafe { *(result.output.as_ptr() as *const [G; OUT_351]) }; __ret } } else { aiur_fn_351(__args, record, io_buffer, __cu)? } }; let __v_7: G = __r_arr[0]; - let __r_arr: [G; OUT_345] = { let __args: [G; IN_345] = [__v_5, __v_7]; let __cu = unconstrained; if let Some(result) = record.function_queries[345].get_mut(&__args[..]) { if !__cu && *result.multiplicity == G::ZERO { aiur_fn_345(__args, record, io_buffer, false)? } else { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_345] = unsafe { *(result.output.as_ptr() as *const [G; OUT_345]) }; __ret } } else { aiur_fn_345(__args, record, io_buffer, __cu)? } }; + let __r_arr: [G; OUT_341] = { let __args: [G; IN_341] = [__v_5, __v_7]; let __cu = unconstrained; if let Some(result) = record.function_queries[341].get_mut(&__args[..]) { if !__cu && *result.multiplicity == G::ZERO { aiur_fn_341(__args, record, io_buffer, false)? } else { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_341] = unsafe { *(result.output.as_ptr() as *const [G; OUT_341]) }; __ret } } else { aiur_fn_341(__args, record, io_buffer, __cu)? } }; let __v_8: G = __r_arr[0]; - let __r_arr: [G; OUT_764] = { let __args: [G; IN_764] = [__v_2]; let __cu = unconstrained; if let Some(result) = record.function_queries[764].get_mut(&__args[..]) { if !__cu && *result.multiplicity == G::ZERO { aiur_fn_764(__args, record, io_buffer, false)? } else { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_764] = unsafe { *(result.output.as_ptr() as *const [G; OUT_764]) }; __ret } } else { aiur_fn_764(__args, record, io_buffer, __cu)? } }; + let __r_arr: [G; OUT_760] = { let __args: [G; IN_760] = [__v_2]; let __cu = unconstrained; if let Some(result) = record.function_queries[760].get_mut(&__args[..]) { if !__cu && *result.multiplicity == G::ZERO { aiur_fn_760(__args, record, io_buffer, false)? } else { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_760] = unsafe { *(result.output.as_ptr() as *const [G; OUT_760]) }; __ret } } else { aiur_fn_760(__args, record, io_buffer, __cu)? } }; let __v_9: G = __r_arr[0]; - let __r_arr: [G; OUT_345] = { let __args: [G; IN_345] = [__v_8, __v_9]; let __cu = unconstrained; if let Some(result) = record.function_queries[345].get_mut(&__args[..]) { if !__cu && *result.multiplicity == G::ZERO { aiur_fn_345(__args, record, io_buffer, false)? } else { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_345] = unsafe { *(result.output.as_ptr() as *const [G; OUT_345]) }; __ret } } else { aiur_fn_345(__args, record, io_buffer, __cu)? } }; + let __r_arr: [G; OUT_341] = { let __args: [G; IN_341] = [__v_8, __v_9]; let __cu = unconstrained; if let Some(result) = record.function_queries[341].get_mut(&__args[..]) { if !__cu && *result.multiplicity == G::ZERO { aiur_fn_341(__args, record, io_buffer, false)? } else { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_341] = unsafe { *(result.output.as_ptr() as *const [G; OUT_341]) }; __ret } } else { aiur_fn_341(__args, record, io_buffer, __cu)? } }; let __v_10: G = __r_arr[0]; match __v_10.as_canonical_u64() { 0u64 => { - let __r_arr: [G; OUT_354] = { let __args: [G; IN_354] = [__v_2, __v_3]; let __cu = unconstrained; if let Some(result) = record.function_queries[354].get_mut(&__args[..]) { if !__cu && *result.multiplicity == G::ZERO { aiur_fn_354(__args, record, io_buffer, false)? } else { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_354] = unsafe { *(result.output.as_ptr() as *const [G; OUT_354]) }; __ret } } else { aiur_fn_354(__args, record, io_buffer, __cu)? } }; + let __r_arr: [G; OUT_350] = { let __args: [G; IN_350] = [__v_2, __v_3]; let __cu = unconstrained; if let Some(result) = record.function_queries[350].get_mut(&__args[..]) { if !__cu && *result.multiplicity == G::ZERO { aiur_fn_350(__args, record, io_buffer, false)? } else { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_350] = unsafe { *(result.output.as_ptr() as *const [G; OUT_350]) }; __ret } } else { aiur_fn_350(__args, record, io_buffer, __cu)? } }; let __v_11: G = __r_arr[0]; - let __r_arr: [G; OUT_441] = { let __args: [G; IN_441] = [__v_0, __v_1, __v_11]; let __cu = unconstrained; if let Some(result) = record.function_queries[441].get_mut(&__args[..]) { if !__cu && *result.multiplicity == G::ZERO { aiur_fn_441(__args, record, io_buffer, false)? } else { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_441] = unsafe { *(result.output.as_ptr() as *const [G; OUT_441]) }; __ret } } else { aiur_fn_441(__args, record, io_buffer, __cu)? } }; + let __r_arr: [G; OUT_437] = { let __args: [G; IN_437] = [__v_0, __v_1, __v_11]; let __cu = unconstrained; if let Some(result) = record.function_queries[437].get_mut(&__args[..]) { if !__cu && *result.multiplicity == G::ZERO { aiur_fn_437(__args, record, io_buffer, false)? } else { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_437] = unsafe { *(result.output.as_ptr() as *const [G; OUT_437]) }; __ret } } else { aiur_fn_437(__args, record, io_buffer, __cu)? } }; let __v_12: G = __r_arr[0]; - let __ret: [G; OUT_440] = [__v_12]; - if let Some(result) = record.function_queries[440].get_mut(&inp[..]) { debug_assert_eq!(result.output, &__ret[..]); if !unconstrained { *result.multiplicity += G::ONE; } } else { record.function_queries[440].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained)); }; + let __ret: [G; OUT_436] = [__v_12]; + if let Some(result) = record.function_queries[436].get_mut(&inp[..]) { debug_assert_eq!(result.output, &__ret[..]); if !unconstrained { *result.multiplicity += G::ONE; } } else { record.function_queries[436].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained)); }; return Ok(__ret); }, _ => { let __v_11: G = G::from_u64(0); - let __r_arr: [G; OUT_363] = { let __args: [G; IN_363] = [__v_0, __v_10, __v_11]; let __cu = unconstrained; if let Some(result) = record.function_queries[363].get_mut(&__args[..]) { if !__cu && *result.multiplicity == G::ZERO { aiur_fn_363(__args, record, io_buffer, false)? } else { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_363] = unsafe { *(result.output.as_ptr() as *const [G; OUT_363]) }; __ret } } else { aiur_fn_363(__args, record, io_buffer, __cu)? } }; + let __r_arr: [G; OUT_359] = { let __args: [G; IN_359] = [__v_0, __v_10, __v_11]; let __cu = unconstrained; if let Some(result) = record.function_queries[359].get_mut(&__args[..]) { if !__cu && *result.multiplicity == G::ZERO { aiur_fn_359(__args, record, io_buffer, false)? } else { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_359] = unsafe { *(result.output.as_ptr() as *const [G; OUT_359]) }; __ret } } else { aiur_fn_359(__args, record, io_buffer, __cu)? } }; let __v_12: G = __r_arr[0]; let __v_13: G = G::from_u64(0); - let __r_arr: [G; OUT_363] = { let __args: [G; IN_363] = [__v_1, __v_10, __v_13]; let __cu = unconstrained; if let Some(result) = record.function_queries[363].get_mut(&__args[..]) { if !__cu && *result.multiplicity == G::ZERO { aiur_fn_363(__args, record, io_buffer, false)? } else { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_363] = unsafe { *(result.output.as_ptr() as *const [G; OUT_363]) }; __ret } } else { aiur_fn_363(__args, record, io_buffer, __cu)? } }; + let __r_arr: [G; OUT_359] = { let __args: [G; IN_359] = [__v_1, __v_10, __v_13]; let __cu = unconstrained; if let Some(result) = record.function_queries[359].get_mut(&__args[..]) { if !__cu && *result.multiplicity == G::ZERO { aiur_fn_359(__args, record, io_buffer, false)? } else { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_359] = unsafe { *(result.output.as_ptr() as *const [G; OUT_359]) }; __ret } } else { aiur_fn_359(__args, record, io_buffer, __cu)? } }; let __v_14: G = __r_arr[0]; - let __r_arr: [G; OUT_775] = { let __args: [G; IN_775] = [__v_2, __v_10]; let __cu = unconstrained; if let Some(result) = record.function_queries[775].get_mut(&__args[..]) { if !__cu && *result.multiplicity == G::ZERO { aiur_fn_775(__args, record, io_buffer, false)? } else { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_775] = unsafe { *(result.output.as_ptr() as *const [G; OUT_775]) }; __ret } } else { aiur_fn_775(__args, record, io_buffer, __cu)? } }; + let __r_arr: [G; OUT_771] = { let __args: [G; IN_771] = [__v_2, __v_10]; let __cu = unconstrained; if let Some(result) = record.function_queries[771].get_mut(&__args[..]) { if !__cu && *result.multiplicity == G::ZERO { aiur_fn_771(__args, record, io_buffer, false)? } else { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_771] = unsafe { *(result.output.as_ptr() as *const [G; OUT_771]) }; __ret } } else { aiur_fn_771(__args, record, io_buffer, __cu)? } }; let __v_15: G = __r_arr[0]; let __v_16: G = (__v_3 - __v_10); - let __r_arr: [G; OUT_354] = { let __args: [G; IN_354] = [__v_15, __v_16]; let __cu = unconstrained; if let Some(result) = record.function_queries[354].get_mut(&__args[..]) { if !__cu && *result.multiplicity == G::ZERO { aiur_fn_354(__args, record, io_buffer, false)? } else { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_354] = unsafe { *(result.output.as_ptr() as *const [G; OUT_354]) }; __ret } } else { aiur_fn_354(__args, record, io_buffer, __cu)? } }; + let __r_arr: [G; OUT_350] = { let __args: [G; IN_350] = [__v_15, __v_16]; let __cu = unconstrained; if let Some(result) = record.function_queries[350].get_mut(&__args[..]) { if !__cu && *result.multiplicity == G::ZERO { aiur_fn_350(__args, record, io_buffer, false)? } else { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_350] = unsafe { *(result.output.as_ptr() as *const [G; OUT_350]) }; __ret } } else { aiur_fn_350(__args, record, io_buffer, __cu)? } }; let __v_17: G = __r_arr[0]; - let __r_arr: [G; OUT_441] = { let __args: [G; IN_441] = [__v_12, __v_14, __v_17]; let __cu = unconstrained; if let Some(result) = record.function_queries[441].get_mut(&__args[..]) { if !__cu && *result.multiplicity == G::ZERO { aiur_fn_441(__args, record, io_buffer, false)? } else { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_441] = unsafe { *(result.output.as_ptr() as *const [G; OUT_441]) }; __ret } } else { aiur_fn_441(__args, record, io_buffer, __cu)? } }; + let __r_arr: [G; OUT_437] = { let __args: [G; IN_437] = [__v_12, __v_14, __v_17]; let __cu = unconstrained; if let Some(result) = record.function_queries[437].get_mut(&__args[..]) { if !__cu && *result.multiplicity == G::ZERO { aiur_fn_437(__args, record, io_buffer, false)? } else { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_437] = unsafe { *(result.output.as_ptr() as *const [G; OUT_437]) }; __ret } } else { aiur_fn_437(__args, record, io_buffer, __cu)? } }; let __v_18: G = __r_arr[0]; - let __ret: [G; OUT_440] = [__v_18]; - if let Some(result) = record.function_queries[440].get_mut(&inp[..]) { debug_assert_eq!(result.output, &__ret[..]); if !unconstrained { *result.multiplicity += G::ONE; } } else { record.function_queries[440].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained)); }; + let __ret: [G; OUT_436] = [__v_18]; + if let Some(result) = record.function_queries[436].get_mut(&inp[..]) { debug_assert_eq!(result.output, &__ret[..]); if !unconstrained { *result.multiplicity += G::ONE; } } else { record.function_queries[436].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained)); }; return Ok(__ret); }, } }) } -const INPUT_SIZE_441: usize = 3; -const IN_441: usize = 3; -const OUT_441: usize = 1; -fn aiur_fn_441( - inp: [G; IN_441], +const INPUT_SIZE_437: usize = 3; +const IN_437: usize = 3; +const OUT_437: usize = 1; +fn aiur_fn_437( + inp: [G; IN_437], record: &mut QueryRecord, io_buffer: &mut IOBuffer, unconstrained: bool, -) -> Result<[G; OUT_441], ExecError> { +) -> Result<[G; OUT_437], ExecError> { stacker::maybe_grow(64 * 1024, 4 * 1024 * 1024, || { let __v_0: G = inp[0]; let __v_1: G = inp[1]; @@ -39526,65 +39252,65 @@ fn aiur_fn_441( let __v_3: G = { let __a_val = __v_0.as_canonical_u64(); let __b_val = __v_1.as_canonical_u64(); let __a_u32 = u32::try_from(__a_val).ok().ok_or(ExecError::U32OutOfRange(__a_val))?; let __b_u32 = u32::try_from(__b_val).ok().ok_or(ExecError::U32OutOfRange(__b_val))?; let __result = G::from_bool(__a_u32 < __b_u32); if !unconstrained { let __x_bytes = __a_u32.to_le_bytes(); let __z_bytes = __b_u32.to_le_bytes(); let __c_u32 = __b_u32.wrapping_sub(__a_u32).wrapping_sub(1); let __y_bytes = __c_u32.to_le_bytes(); record.bytes2_queries.bump_range_check(&G::from_u8(__x_bytes[0]), &G::from_u8(__x_bytes[1])); record.bytes2_queries.bump_range_check(&G::from_u8(__x_bytes[2]), &G::from_u8(__x_bytes[3])); record.bytes2_queries.bump_range_check(&G::from_u8(__y_bytes[0]), &G::from_u8(__y_bytes[1])); record.bytes2_queries.bump_range_check(&G::from_u8(__y_bytes[2]), &G::from_u8(__y_bytes[3])); record.bytes2_queries.bump_range_check(&G::from_u8(__z_bytes[0]), &G::from_u8(__z_bytes[1])); record.bytes2_queries.bump_range_check(&G::from_u8(__z_bytes[2]), &G::from_u8(__z_bytes[3])); } __result }; match __v_3.as_canonical_u64() { 1u64 => { - let __r_arr: [G; OUT_442] = { let __args: [G; IN_442] = [__v_0, __v_1, __v_2]; let __cu = unconstrained; if let Some(result) = record.function_queries[442].get_mut(&__args[..]) { if !__cu && *result.multiplicity == G::ZERO { aiur_fn_442(__args, record, io_buffer, false)? } else { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_442] = unsafe { *(result.output.as_ptr() as *const [G; OUT_442]) }; __ret } } else { aiur_fn_442(__args, record, io_buffer, __cu)? } }; + let __r_arr: [G; OUT_438] = { let __args: [G; IN_438] = [__v_0, __v_1, __v_2]; let __cu = unconstrained; if let Some(result) = record.function_queries[438].get_mut(&__args[..]) { if !__cu && *result.multiplicity == G::ZERO { aiur_fn_438(__args, record, io_buffer, false)? } else { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_438] = unsafe { *(result.output.as_ptr() as *const [G; OUT_438]) }; __ret } } else { aiur_fn_438(__args, record, io_buffer, __cu)? } }; let __v_4: G = __r_arr[0]; - let __ret: [G; OUT_441] = [__v_4]; - if let Some(result) = record.function_queries[441].get_mut(&inp[..]) { debug_assert_eq!(result.output, &__ret[..]); if !unconstrained { *result.multiplicity += G::ONE; } } else { record.function_queries[441].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained)); }; + let __ret: [G; OUT_437] = [__v_4]; + if let Some(result) = record.function_queries[437].get_mut(&inp[..]) { debug_assert_eq!(result.output, &__ret[..]); if !unconstrained { *result.multiplicity += G::ONE; } } else { record.function_queries[437].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained)); }; return Ok(__ret); }, _ => { - let __r_arr: [G; OUT_442] = { let __args: [G; IN_442] = [__v_1, __v_0, __v_2]; let __cu = unconstrained; if let Some(result) = record.function_queries[442].get_mut(&__args[..]) { if !__cu && *result.multiplicity == G::ZERO { aiur_fn_442(__args, record, io_buffer, false)? } else { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_442] = unsafe { *(result.output.as_ptr() as *const [G; OUT_442]) }; __ret } } else { aiur_fn_442(__args, record, io_buffer, __cu)? } }; + let __r_arr: [G; OUT_438] = { let __args: [G; IN_438] = [__v_1, __v_0, __v_2]; let __cu = unconstrained; if let Some(result) = record.function_queries[438].get_mut(&__args[..]) { if !__cu && *result.multiplicity == G::ZERO { aiur_fn_438(__args, record, io_buffer, false)? } else { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_438] = unsafe { *(result.output.as_ptr() as *const [G; OUT_438]) }; __ret } } else { aiur_fn_438(__args, record, io_buffer, __cu)? } }; let __v_4: G = __r_arr[0]; - let __ret: [G; OUT_441] = [__v_4]; - if let Some(result) = record.function_queries[441].get_mut(&inp[..]) { debug_assert_eq!(result.output, &__ret[..]); if !unconstrained { *result.multiplicity += G::ONE; } } else { record.function_queries[441].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained)); }; + let __ret: [G; OUT_437] = [__v_4]; + if let Some(result) = record.function_queries[437].get_mut(&inp[..]) { debug_assert_eq!(result.output, &__ret[..]); if !unconstrained { *result.multiplicity += G::ONE; } } else { record.function_queries[437].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained)); }; return Ok(__ret); }, } }) } -const INPUT_SIZE_442: usize = 3; -const IN_442: usize = 3; -const OUT_442: usize = 1; -fn aiur_fn_442( - inp: [G; IN_442], +const INPUT_SIZE_438: usize = 3; +const IN_438: usize = 3; +const OUT_438: usize = 1; +fn aiur_fn_438( + inp: [G; IN_438], record: &mut QueryRecord, io_buffer: &mut IOBuffer, unconstrained: bool, -) -> Result<[G; OUT_442], ExecError> { +) -> Result<[G; OUT_438], ExecError> { stacker::maybe_grow(64 * 1024, 4 * 1024 * 1024, || { let __v_0: G = inp[0]; let __v_1: G = inp[1]; let __v_2: G = inp[2]; - let __r_arr: [G; OUT_443] = { let __args: [G; IN_443] = [__v_0, __v_1, __v_2]; let __cu = unconstrained; if let Some(result) = record.function_queries[443].get_mut(&__args[..]) { if !__cu && *result.multiplicity == G::ZERO { aiur_fn_443(__args, record, io_buffer, false)? } else { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_443] = unsafe { *(result.output.as_ptr() as *const [G; OUT_443]) }; __ret } } else { aiur_fn_443(__args, record, io_buffer, __cu)? } }; + let __r_arr: [G; OUT_439] = { let __args: [G; IN_439] = [__v_0, __v_1, __v_2]; let __cu = unconstrained; if let Some(result) = record.function_queries[439].get_mut(&__args[..]) { if !__cu && *result.multiplicity == G::ZERO { aiur_fn_439(__args, record, io_buffer, false)? } else { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_439] = unsafe { *(result.output.as_ptr() as *const [G; OUT_439]) }; __ret } } else { aiur_fn_439(__args, record, io_buffer, __cu)? } }; let __v_3: G = __r_arr[0]; match __v_3.as_canonical_u64() { 1u64 => { let __v_4: G = G::from_u64(1); - let __ret: [G; OUT_442] = [__v_4]; - if let Some(result) = record.function_queries[442].get_mut(&inp[..]) { debug_assert_eq!(result.output, &__ret[..]); if !unconstrained { *result.multiplicity += G::ONE; } } else { record.function_queries[442].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained)); }; + let __ret: [G; OUT_438] = [__v_4]; + if let Some(result) = record.function_queries[438].get_mut(&inp[..]) { debug_assert_eq!(result.output, &__ret[..]); if !unconstrained { *result.multiplicity += G::ONE; } } else { record.function_queries[438].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained)); }; return Ok(__ret); }, _ => { - let __r_arr: [G; OUT_450] = { let __args: [G; IN_450] = [__v_0, __v_1, __v_2]; let __cu = unconstrained; if let Some(result) = record.function_queries[450].get_mut(&__args[..]) { if !__cu && *result.multiplicity == G::ZERO { aiur_fn_450(__args, record, io_buffer, false)? } else { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_450] = unsafe { *(result.output.as_ptr() as *const [G; OUT_450]) }; __ret } } else { aiur_fn_450(__args, record, io_buffer, __cu)? } }; + let __r_arr: [G; OUT_446] = { let __args: [G; IN_446] = [__v_0, __v_1, __v_2]; let __cu = unconstrained; if let Some(result) = record.function_queries[446].get_mut(&__args[..]) { if !__cu && *result.multiplicity == G::ZERO { aiur_fn_446(__args, record, io_buffer, false)? } else { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_446] = unsafe { *(result.output.as_ptr() as *const [G; OUT_446]) }; __ret } } else { aiur_fn_446(__args, record, io_buffer, __cu)? } }; let __v_4: G = __r_arr[0]; - let __ret: [G; OUT_442] = [__v_4]; - if let Some(result) = record.function_queries[442].get_mut(&inp[..]) { debug_assert_eq!(result.output, &__ret[..]); if !unconstrained { *result.multiplicity += G::ONE; } } else { record.function_queries[442].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained)); }; + let __ret: [G; OUT_438] = [__v_4]; + if let Some(result) = record.function_queries[438].get_mut(&inp[..]) { debug_assert_eq!(result.output, &__ret[..]); if !unconstrained { *result.multiplicity += G::ONE; } } else { record.function_queries[438].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained)); }; return Ok(__ret); }, } }) } -const INPUT_SIZE_443: usize = 3; -const IN_443: usize = 3; -const OUT_443: usize = 1; -fn aiur_fn_443( - inp: [G; IN_443], +const INPUT_SIZE_439: usize = 3; +const IN_439: usize = 3; +const OUT_439: usize = 1; +fn aiur_fn_439( + inp: [G; IN_439], record: &mut QueryRecord, io_buffer: &mut IOBuffer, unconstrained: bool, -) -> Result<[G; OUT_443], ExecError> { +) -> Result<[G; OUT_439], ExecError> { stacker::maybe_grow(64 * 1024, 4 * 1024 * 1024, || { let __v_0: G = inp[0]; let __v_1: G = inp[1]; @@ -39612,33 +39338,33 @@ fn aiur_fn_443( let __v_15: G = (__v_8 - __v_12); match __v_15.as_canonical_u64() { 0u64 => { - let __r_arr: [G; OUT_438] = { let __args: [G; IN_438] = [__v_9, __v_13]; let __cu = unconstrained; if let Some(result) = record.function_queries[438].get_mut(&__args[..]) { if !__cu && *result.multiplicity == G::ZERO { aiur_fn_438(__args, record, io_buffer, false)? } else { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_438] = unsafe { *(result.output.as_ptr() as *const [G; OUT_438]) }; __ret } } else { aiur_fn_438(__args, record, io_buffer, __cu)? } }; + let __r_arr: [G; OUT_434] = { let __args: [G; IN_434] = [__v_9, __v_13]; let __cu = unconstrained; if let Some(result) = record.function_queries[434].get_mut(&__args[..]) { if !__cu && *result.multiplicity == G::ZERO { aiur_fn_434(__args, record, io_buffer, false)? } else { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_434] = unsafe { *(result.output.as_ptr() as *const [G; OUT_434]) }; __ret } } else { aiur_fn_434(__args, record, io_buffer, __cu)? } }; let __v_16: G = __r_arr[0]; match __v_16.as_canonical_u64() { 0u64 => { let __v_17: G = G::from_u64(0); - let __ret: [G; OUT_443] = [__v_17]; - if let Some(result) = record.function_queries[443].get_mut(&inp[..]) { debug_assert_eq!(result.output, &__ret[..]); if !unconstrained { *result.multiplicity += G::ONE; } } else { record.function_queries[443].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained)); }; + let __ret: [G; OUT_439] = [__v_17]; + if let Some(result) = record.function_queries[439].get_mut(&inp[..]) { debug_assert_eq!(result.output, &__ret[..]); if !unconstrained { *result.multiplicity += G::ONE; } } else { record.function_queries[439].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained)); }; return Ok(__ret); }, _ => { - let __r_arr: [G; OUT_764] = { let __args: [G; IN_764] = [__v_4]; let __cu = unconstrained; if let Some(result) = record.function_queries[764].get_mut(&__args[..]) { if !__cu && *result.multiplicity == G::ZERO { aiur_fn_764(__args, record, io_buffer, false)? } else { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_764] = unsafe { *(result.output.as_ptr() as *const [G; OUT_764]) }; __ret } } else { aiur_fn_764(__args, record, io_buffer, __cu)? } }; + let __r_arr: [G; OUT_760] = { let __args: [G; IN_760] = [__v_4]; let __cu = unconstrained; if let Some(result) = record.function_queries[760].get_mut(&__args[..]) { if !__cu && *result.multiplicity == G::ZERO { aiur_fn_760(__args, record, io_buffer, false)? } else { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_760] = unsafe { *(result.output.as_ptr() as *const [G; OUT_760]) }; __ret } } else { aiur_fn_760(__args, record, io_buffer, __cu)? } }; let __v_17: G = __r_arr[0]; - let __r_arr: [G; OUT_764] = { let __args: [G; IN_764] = [__v_6]; let __cu = unconstrained; if let Some(result) = record.function_queries[764].get_mut(&__args[..]) { if !__cu && *result.multiplicity == G::ZERO { aiur_fn_764(__args, record, io_buffer, false)? } else { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_764] = unsafe { *(result.output.as_ptr() as *const [G; OUT_764]) }; __ret } } else { aiur_fn_764(__args, record, io_buffer, __cu)? } }; + let __r_arr: [G; OUT_760] = { let __args: [G; IN_760] = [__v_6]; let __cu = unconstrained; if let Some(result) = record.function_queries[760].get_mut(&__args[..]) { if !__cu && *result.multiplicity == G::ZERO { aiur_fn_760(__args, record, io_buffer, false)? } else { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_760] = unsafe { *(result.output.as_ptr() as *const [G; OUT_760]) }; __ret } } else { aiur_fn_760(__args, record, io_buffer, __cu)? } }; let __v_18: G = __r_arr[0]; let __v_19: G = (__v_17 - __v_18); match __v_19.as_canonical_u64() { 0u64 => { - let __r_arr: [G; OUT_444] = { let __args: [G; IN_444] = [__v_4, __v_6, __v_2]; let __cu = unconstrained; if let Some(result) = record.function_queries[444].get_mut(&__args[..]) { if !__cu && *result.multiplicity == G::ZERO { aiur_fn_444(__args, record, io_buffer, false)? } else { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_444] = unsafe { *(result.output.as_ptr() as *const [G; OUT_444]) }; __ret } } else { aiur_fn_444(__args, record, io_buffer, __cu)? } }; + let __r_arr: [G; OUT_440] = { let __args: [G; IN_440] = [__v_4, __v_6, __v_2]; let __cu = unconstrained; if let Some(result) = record.function_queries[440].get_mut(&__args[..]) { if !__cu && *result.multiplicity == G::ZERO { aiur_fn_440(__args, record, io_buffer, false)? } else { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_440] = unsafe { *(result.output.as_ptr() as *const [G; OUT_440]) }; __ret } } else { aiur_fn_440(__args, record, io_buffer, __cu)? } }; let __v_20: G = __r_arr[0]; - let __ret: [G; OUT_443] = [__v_20]; - if let Some(result) = record.function_queries[443].get_mut(&inp[..]) { debug_assert_eq!(result.output, &__ret[..]); if !unconstrained { *result.multiplicity += G::ONE; } } else { record.function_queries[443].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained)); }; + let __ret: [G; OUT_439] = [__v_20]; + if let Some(result) = record.function_queries[439].get_mut(&inp[..]) { debug_assert_eq!(result.output, &__ret[..]); if !unconstrained { *result.multiplicity += G::ONE; } } else { record.function_queries[439].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained)); }; return Ok(__ret); }, _ => { let __v_20: G = G::from_u64(0); - let __ret: [G; OUT_443] = [__v_20]; - if let Some(result) = record.function_queries[443].get_mut(&inp[..]) { debug_assert_eq!(result.output, &__ret[..]); if !unconstrained { *result.multiplicity += G::ONE; } } else { record.function_queries[443].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained)); }; + let __ret: [G; OUT_439] = [__v_20]; + if let Some(result) = record.function_queries[439].get_mut(&inp[..]) { debug_assert_eq!(result.output, &__ret[..]); if !unconstrained { *result.multiplicity += G::ONE; } } else { record.function_queries[439].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained)); }; return Ok(__ret); }, } @@ -39647,39 +39373,39 @@ fn aiur_fn_443( }, _ => { let __v_16: G = G::from_u64(0); - let __ret: [G; OUT_443] = [__v_16]; - if let Some(result) = record.function_queries[443].get_mut(&inp[..]) { debug_assert_eq!(result.output, &__ret[..]); if !unconstrained { *result.multiplicity += G::ONE; } } else { record.function_queries[443].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained)); }; + let __ret: [G; OUT_439] = [__v_16]; + if let Some(result) = record.function_queries[439].get_mut(&inp[..]) { debug_assert_eq!(result.output, &__ret[..]); if !unconstrained { *result.multiplicity += G::ONE; } } else { record.function_queries[439].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained)); }; return Ok(__ret); }, } }, _ => { let __v_15: G = G::from_u64(0); - let __ret: [G; OUT_443] = [__v_15]; - if let Some(result) = record.function_queries[443].get_mut(&inp[..]) { debug_assert_eq!(result.output, &__ret[..]); if !unconstrained { *result.multiplicity += G::ONE; } } else { record.function_queries[443].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained)); }; + let __ret: [G; OUT_439] = [__v_15]; + if let Some(result) = record.function_queries[439].get_mut(&inp[..]) { debug_assert_eq!(result.output, &__ret[..]); if !unconstrained { *result.multiplicity += G::ONE; } } else { record.function_queries[439].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained)); }; return Ok(__ret); }, } }, _ => { let __v_11: G = G::from_u64(0); - let __ret: [G; OUT_443] = [__v_11]; - if let Some(result) = record.function_queries[443].get_mut(&inp[..]) { debug_assert_eq!(result.output, &__ret[..]); if !unconstrained { *result.multiplicity += G::ONE; } } else { record.function_queries[443].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained)); }; + let __ret: [G; OUT_439] = [__v_11]; + if let Some(result) = record.function_queries[439].get_mut(&inp[..]) { debug_assert_eq!(result.output, &__ret[..]); if !unconstrained { *result.multiplicity += G::ONE; } } else { record.function_queries[439].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained)); }; return Ok(__ret); }, } }) } -const INPUT_SIZE_444: usize = 3; -const IN_444: usize = 3; -const OUT_444: usize = 1; -fn aiur_fn_444( - inp: [G; IN_444], +const INPUT_SIZE_440: usize = 3; +const IN_440: usize = 3; +const OUT_440: usize = 1; +fn aiur_fn_440( + inp: [G; IN_440], record: &mut QueryRecord, io_buffer: &mut IOBuffer, unconstrained: bool, -) -> Result<[G; OUT_444], ExecError> { +) -> Result<[G; OUT_440], ExecError> { stacker::maybe_grow(64 * 1024, 4 * 1024 * 1024, || { let __v_0: G = inp[0]; let __v_1: G = inp[1]; @@ -39697,14 +39423,14 @@ fn aiur_fn_444( match __v_6.as_canonical_u64() { 1u64 => { let __v_9: G = G::from_u64(1); - let __ret: [G; OUT_444] = [__v_9]; - if let Some(result) = record.function_queries[444].get_mut(&inp[..]) { debug_assert_eq!(result.output, &__ret[..]); if !unconstrained { *result.multiplicity += G::ONE; } } else { record.function_queries[444].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained)); }; + let __ret: [G; OUT_440] = [__v_9]; + if let Some(result) = record.function_queries[440].get_mut(&inp[..]) { debug_assert_eq!(result.output, &__ret[..]); if !unconstrained { *result.multiplicity += G::ONE; } } else { record.function_queries[440].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained)); }; return Ok(__ret); }, _ => { let __v_9: G = G::from_u64(0); - let __ret: [G; OUT_444] = [__v_9]; - if let Some(result) = record.function_queries[444].get_mut(&inp[..]) { debug_assert_eq!(result.output, &__ret[..]); if !unconstrained { *result.multiplicity += G::ONE; } } else { record.function_queries[444].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained)); }; + let __ret: [G; OUT_440] = [__v_9]; + if let Some(result) = record.function_queries[440].get_mut(&inp[..]) { debug_assert_eq!(result.output, &__ret[..]); if !unconstrained { *result.multiplicity += G::ONE; } } else { record.function_queries[440].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained)); }; return Ok(__ret); }, } @@ -39717,25 +39443,25 @@ fn aiur_fn_444( match __v_6.as_canonical_u64() { 1u64 => { let __v_9: G = G::from_u64(0); - let __ret: [G; OUT_444] = [__v_9]; - if let Some(result) = record.function_queries[444].get_mut(&inp[..]) { debug_assert_eq!(result.output, &__ret[..]); if !unconstrained { *result.multiplicity += G::ONE; } } else { record.function_queries[444].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained)); }; + let __ret: [G; OUT_440] = [__v_9]; + if let Some(result) = record.function_queries[440].get_mut(&inp[..]) { debug_assert_eq!(result.output, &__ret[..]); if !unconstrained { *result.multiplicity += G::ONE; } } else { record.function_queries[440].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained)); }; return Ok(__ret); }, 0u64 => { - let __r_arr: [G; OUT_439] = { let __args: [G; IN_439] = [__v_4, __v_7, __v_2]; let __cu = unconstrained; if let Some(result) = record.function_queries[439].get_mut(&__args[..]) { if !__cu && *result.multiplicity == G::ZERO { aiur_fn_439(__args, record, io_buffer, false)? } else { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_439] = unsafe { *(result.output.as_ptr() as *const [G; OUT_439]) }; __ret } } else { aiur_fn_439(__args, record, io_buffer, __cu)? } }; + let __r_arr: [G; OUT_435] = { let __args: [G; IN_435] = [__v_4, __v_7, __v_2]; let __cu = unconstrained; if let Some(result) = record.function_queries[435].get_mut(&__args[..]) { if !__cu && *result.multiplicity == G::ZERO { aiur_fn_435(__args, record, io_buffer, false)? } else { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_435] = unsafe { *(result.output.as_ptr() as *const [G; OUT_435]) }; __ret } } else { aiur_fn_435(__args, record, io_buffer, __cu)? } }; let __v_9: G = __r_arr[0]; match __v_9.as_canonical_u64() { 0u64 => { let __v_10: G = G::from_u64(0); - let __ret: [G; OUT_444] = [__v_10]; - if let Some(result) = record.function_queries[444].get_mut(&inp[..]) { debug_assert_eq!(result.output, &__ret[..]); if !unconstrained { *result.multiplicity += G::ONE; } } else { record.function_queries[444].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained)); }; + let __ret: [G; OUT_440] = [__v_10]; + if let Some(result) = record.function_queries[440].get_mut(&inp[..]) { debug_assert_eq!(result.output, &__ret[..]); if !unconstrained { *result.multiplicity += G::ONE; } } else { record.function_queries[440].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained)); }; return Ok(__ret); }, _ => { - let __r_arr: [G; OUT_444] = { let __args: [G; IN_444] = [__v_5, __v_8, __v_2]; let __cu = unconstrained; if let Some(result) = record.function_queries[444].get_mut(&__args[..]) { if !__cu && *result.multiplicity == G::ZERO { aiur_fn_444(__args, record, io_buffer, false)? } else { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_444] = unsafe { *(result.output.as_ptr() as *const [G; OUT_444]) }; __ret } } else { aiur_fn_444(__args, record, io_buffer, __cu)? } }; + let __r_arr: [G; OUT_440] = { let __args: [G; IN_440] = [__v_5, __v_8, __v_2]; let __cu = unconstrained; if let Some(result) = record.function_queries[440].get_mut(&__args[..]) { if !__cu && *result.multiplicity == G::ZERO { aiur_fn_440(__args, record, io_buffer, false)? } else { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_440] = unsafe { *(result.output.as_ptr() as *const [G; OUT_440]) }; __ret } } else { aiur_fn_440(__args, record, io_buffer, __cu)? } }; let __v_10: G = __r_arr[0]; - let __ret: [G; OUT_444] = [__v_10]; - if let Some(result) = record.function_queries[444].get_mut(&inp[..]) { debug_assert_eq!(result.output, &__ret[..]); if !unconstrained { *result.multiplicity += G::ONE; } } else { record.function_queries[444].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained)); }; + let __ret: [G; OUT_440] = [__v_10]; + if let Some(result) = record.function_queries[440].get_mut(&inp[..]) { debug_assert_eq!(result.output, &__ret[..]); if !unconstrained { *result.multiplicity += G::ONE; } } else { record.function_queries[440].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained)); }; return Ok(__ret); }, } @@ -39752,15 +39478,15 @@ fn aiur_fn_444( }) } -const INPUT_SIZE_445: usize = 1; -const IN_445: usize = 1; -const OUT_445: usize = 1; -fn aiur_fn_445( - inp: [G; IN_445], +const INPUT_SIZE_441: usize = 1; +const IN_441: usize = 1; +const OUT_441: usize = 1; +fn aiur_fn_441( + inp: [G; IN_441], record: &mut QueryRecord, io_buffer: &mut IOBuffer, unconstrained: bool, -) -> Result<[G; OUT_445], ExecError> { +) -> Result<[G; OUT_441], ExecError> { stacker::maybe_grow(64 * 1024, 4 * 1024 * 1024, || { let __v_0: G = inp[0]; let __loaded: [G; 4] = { let __mq = record.memory_queries.get_mut(&4).ok_or(ExecError::InvalidMemorySize(4))?; let __ptr_u64 = __v_0.as_canonical_u64(); let __ptr_usize = usize::try_from(__ptr_u64).ok().ok_or(ExecError::PointerTooLarge(__ptr_u64))?; let (__args, __mult) = __mq.get_index_mut(__ptr_usize).ok_or(ExecError::UnboundPointer { ptr: __ptr_u64, size: 4 })?; if !unconstrained { *__mult += G::ONE; } let __arr: [G; 4] = __args[..4].try_into().unwrap(); __arr }; @@ -39774,14 +39500,14 @@ fn aiur_fn_445( 0u64 => { let __r_arr: [G; OUT_129] = { let __args: [G; IN_129] = [__v_3]; let __cu = unconstrained; if let Some(result) = record.function_queries[129].get_mut(&__args[..]) { if !__cu && *result.multiplicity == G::ZERO { aiur_fn_129(__args, record, io_buffer, false)? } else { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_129] = unsafe { *(result.output.as_ptr() as *const [G; OUT_129]) }; __ret } } else { aiur_fn_129(__args, record, io_buffer, __cu)? } }; let __v_5: G = __r_arr[0]; - let __ret: [G; OUT_445] = [__v_5]; - if let Some(result) = record.function_queries[445].get_mut(&inp[..]) { debug_assert_eq!(result.output, &__ret[..]); if !unconstrained { *result.multiplicity += G::ONE; } } else { record.function_queries[445].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained)); }; + let __ret: [G; OUT_441] = [__v_5]; + if let Some(result) = record.function_queries[441].get_mut(&inp[..]) { debug_assert_eq!(result.output, &__ret[..]); if !unconstrained { *result.multiplicity += G::ONE; } } else { record.function_queries[441].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained)); }; return Ok(__ret); }, _ => { let __v_5: G = G::from_u64(0); - let __ret: [G; OUT_445] = [__v_5]; - if let Some(result) = record.function_queries[445].get_mut(&inp[..]) { debug_assert_eq!(result.output, &__ret[..]); if !unconstrained { *result.multiplicity += G::ONE; } } else { record.function_queries[445].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained)); }; + let __ret: [G; OUT_441] = [__v_5]; + if let Some(result) = record.function_queries[441].get_mut(&inp[..]) { debug_assert_eq!(result.output, &__ret[..]); if !unconstrained { *result.multiplicity += G::ONE; } } else { record.function_queries[441].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained)); }; return Ok(__ret); }, } @@ -39791,29 +39517,29 @@ fn aiur_fn_445( let __v_5: G = __r_arr[0]; let __r_arr: [G; OUT_1] = { let __args: [G; IN_1] = [__v_2, __v_5]; let __cu = unconstrained; if let Some(result) = record.function_queries[1].get_mut(&__args[..]) { if !__cu && *result.multiplicity == G::ZERO { aiur_fn_1(__args, record, io_buffer, false)? } else { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_1] = unsafe { *(result.output.as_ptr() as *const [G; OUT_1]) }; __ret } } else { aiur_fn_1(__args, record, io_buffer, __cu)? } }; let __v_6: G = __r_arr[0]; - let __ret: [G; OUT_445] = [__v_6]; - if let Some(result) = record.function_queries[445].get_mut(&inp[..]) { debug_assert_eq!(result.output, &__ret[..]); if !unconstrained { *result.multiplicity += G::ONE; } } else { record.function_queries[445].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained)); }; + let __ret: [G; OUT_441] = [__v_6]; + if let Some(result) = record.function_queries[441].get_mut(&inp[..]) { debug_assert_eq!(result.output, &__ret[..]); if !unconstrained { *result.multiplicity += G::ONE; } } else { record.function_queries[441].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained)); }; return Ok(__ret); }, _ => { let __v_5: G = G::from_u64(0); - let __ret: [G; OUT_445] = [__v_5]; - if let Some(result) = record.function_queries[445].get_mut(&inp[..]) { debug_assert_eq!(result.output, &__ret[..]); if !unconstrained { *result.multiplicity += G::ONE; } } else { record.function_queries[445].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained)); }; + let __ret: [G; OUT_441] = [__v_5]; + if let Some(result) = record.function_queries[441].get_mut(&inp[..]) { debug_assert_eq!(result.output, &__ret[..]); if !unconstrained { *result.multiplicity += G::ONE; } } else { record.function_queries[441].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained)); }; return Ok(__ret); }, } }) } -const INPUT_SIZE_446: usize = 1; -const IN_446: usize = 1; -const OUT_446: usize = 3; -fn aiur_fn_446( - inp: [G; IN_446], +const INPUT_SIZE_442: usize = 1; +const IN_442: usize = 1; +const OUT_442: usize = 3; +fn aiur_fn_442( + inp: [G; IN_442], record: &mut QueryRecord, io_buffer: &mut IOBuffer, unconstrained: bool, -) -> Result<[G; OUT_446], ExecError> { +) -> Result<[G; OUT_442], ExecError> { stacker::maybe_grow(64 * 1024, 4 * 1024 * 1024, || { let __v_0: G = inp[0]; let __loaded: [G; 4] = { let __mq = record.memory_queries.get_mut(&4).ok_or(ExecError::InvalidMemorySize(4))?; let __ptr_u64 = __v_0.as_canonical_u64(); let __ptr_usize = usize::try_from(__ptr_u64).ok().ok_or(ExecError::PointerTooLarge(__ptr_u64))?; let (__args, __mult) = __mq.get_index_mut(__ptr_usize).ok_or(ExecError::UnboundPointer { ptr: __ptr_u64, size: 4 })?; if !unconstrained { *__mult += G::ONE; } let __arr: [G; 4] = __args[..4].try_into().unwrap(); __arr }; @@ -39829,10 +39555,10 @@ fn aiur_fn_446( let __v_6: G = G::from_u64(1); let __v_7: G = G::from_u64(1); let __v_8: G = { let __values: [G; 10] = [__v_6, __v_7, __v_7, __v_7, __v_7, __v_7, __v_7, __v_7, __v_7, __v_7]; let __mq = record.memory_queries.get_mut(&10).ok_or(ExecError::InvalidMemorySize(10))?; if let Some(result) = __mq.get_mut(&__values[..]) { if !unconstrained { *result.multiplicity += G::ONE; } result.output[0] } else { let __ptr = G::from_usize(__mq.len()); __mq.insert(&__values[..], &[__ptr], G::from_bool(!unconstrained)); __ptr } }; - let __r_arr: [G; OUT_245] = { let __args: [G; IN_245] = [__v_8]; let __cu = unconstrained; if let Some(result) = record.function_queries[245].get_mut(&__args[..]) { if !__cu && *result.multiplicity == G::ZERO { aiur_fn_245(__args, record, io_buffer, false)? } else { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_245] = unsafe { *(result.output.as_ptr() as *const [G; OUT_245]) }; __ret } } else { aiur_fn_245(__args, record, io_buffer, __cu)? } }; + let __r_arr: [G; OUT_241] = { let __args: [G; IN_241] = [__v_8]; let __cu = unconstrained; if let Some(result) = record.function_queries[241].get_mut(&__args[..]) { if !__cu && *result.multiplicity == G::ZERO { aiur_fn_241(__args, record, io_buffer, false)? } else { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_241] = unsafe { *(result.output.as_ptr() as *const [G; OUT_241]) }; __ret } } else { aiur_fn_241(__args, record, io_buffer, __cu)? } }; let __v_9: G = __r_arr[0]; - let __ret: [G; OUT_446] = [__v_5, __v_9, __v_3]; - if let Some(result) = record.function_queries[446].get_mut(&inp[..]) { debug_assert_eq!(result.output, &__ret[..]); if !unconstrained { *result.multiplicity += G::ONE; } } else { record.function_queries[446].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained)); }; + let __ret: [G; OUT_442] = [__v_5, __v_9, __v_3]; + if let Some(result) = record.function_queries[442].get_mut(&inp[..]) { debug_assert_eq!(result.output, &__ret[..]); if !unconstrained { *result.multiplicity += G::ONE; } } else { record.function_queries[442].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained)); }; return Ok(__ret); }, _ => { @@ -39840,8 +39566,8 @@ fn aiur_fn_446( let __v_6: G = G::from_u64(1); let __v_7: G = G::from_u64(1); let __v_8: G = { let __values: [G; 10] = [__v_6, __v_7, __v_7, __v_7, __v_7, __v_7, __v_7, __v_7, __v_7, __v_7]; let __mq = record.memory_queries.get_mut(&10).ok_or(ExecError::InvalidMemorySize(10))?; if let Some(result) = __mq.get_mut(&__values[..]) { if !unconstrained { *result.multiplicity += G::ONE; } result.output[0] } else { let __ptr = G::from_usize(__mq.len()); __mq.insert(&__values[..], &[__ptr], G::from_bool(!unconstrained)); __ptr } }; - let __ret: [G; OUT_446] = [__v_5, __v_0, __v_8]; - if let Some(result) = record.function_queries[446].get_mut(&inp[..]) { debug_assert_eq!(result.output, &__ret[..]); if !unconstrained { *result.multiplicity += G::ONE; } } else { record.function_queries[446].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained)); }; + let __ret: [G; OUT_442] = [__v_5, __v_0, __v_8]; + if let Some(result) = record.function_queries[442].get_mut(&inp[..]) { debug_assert_eq!(result.output, &__ret[..]); if !unconstrained { *result.multiplicity += G::ONE; } } else { record.function_queries[442].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained)); }; return Ok(__ret); }, } @@ -39860,15 +39586,15 @@ fn aiur_fn_446( let __v_10: G = __r_arr[0]; match __v_10.as_canonical_u64() { 1u64 => { - let __r_arr: [G; OUT_446] = { let __args: [G; IN_446] = [__v_3]; let __cu = unconstrained; if let Some(result) = record.function_queries[446].get_mut(&__args[..]) { if !__cu && *result.multiplicity == G::ZERO { aiur_fn_446(__args, record, io_buffer, false)? } else { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_446] = unsafe { *(result.output.as_ptr() as *const [G; OUT_446]) }; __ret } } else { aiur_fn_446(__args, record, io_buffer, __cu)? } }; + let __r_arr: [G; OUT_442] = { let __args: [G; IN_442] = [__v_3]; let __cu = unconstrained; if let Some(result) = record.function_queries[442].get_mut(&__args[..]) { if !__cu && *result.multiplicity == G::ZERO { aiur_fn_442(__args, record, io_buffer, false)? } else { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_442] = unsafe { *(result.output.as_ptr() as *const [G; OUT_442]) }; __ret } } else { aiur_fn_442(__args, record, io_buffer, __cu)? } }; let __v_11: G = __r_arr[0]; let __v_12: G = __r_arr[1]; let __v_13: G = __r_arr[2]; let __v_14: G = G::from_u64(1); let __r_arr: [G; OUT_112] = { let __args: [G; IN_112] = [__v_13]; let __cu = unconstrained; if let Some(result) = record.function_queries[112].get_mut(&__args[..]) { if !__cu && *result.multiplicity == G::ZERO { aiur_fn_112(__args, record, io_buffer, false)? } else { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_112] = unsafe { *(result.output.as_ptr() as *const [G; OUT_112]) }; __ret } } else { aiur_fn_112(__args, record, io_buffer, __cu)? } }; let __v_15: G = __r_arr[0]; - let __ret: [G; OUT_446] = [__v_14, __v_12, __v_15]; - if let Some(result) = record.function_queries[446].get_mut(&inp[..]) { debug_assert_eq!(result.output, &__ret[..]); if !unconstrained { *result.multiplicity += G::ONE; } } else { record.function_queries[446].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained)); }; + let __ret: [G; OUT_442] = [__v_14, __v_12, __v_15]; + if let Some(result) = record.function_queries[442].get_mut(&inp[..]) { debug_assert_eq!(result.output, &__ret[..]); if !unconstrained { *result.multiplicity += G::ONE; } } else { record.function_queries[442].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained)); }; return Ok(__ret); }, _ => { @@ -39876,8 +39602,8 @@ fn aiur_fn_446( let __v_12: G = G::from_u64(1); let __v_13: G = G::from_u64(1); let __v_14: G = { let __values: [G; 10] = [__v_12, __v_13, __v_13, __v_13, __v_13, __v_13, __v_13, __v_13, __v_13, __v_13]; let __mq = record.memory_queries.get_mut(&10).ok_or(ExecError::InvalidMemorySize(10))?; if let Some(result) = __mq.get_mut(&__values[..]) { if !unconstrained { *result.multiplicity += G::ONE; } result.output[0] } else { let __ptr = G::from_usize(__mq.len()); __mq.insert(&__values[..], &[__ptr], G::from_bool(!unconstrained)); __ptr } }; - let __ret: [G; OUT_446] = [__v_11, __v_0, __v_14]; - if let Some(result) = record.function_queries[446].get_mut(&inp[..]) { debug_assert_eq!(result.output, &__ret[..]); if !unconstrained { *result.multiplicity += G::ONE; } } else { record.function_queries[446].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained)); }; + let __ret: [G; OUT_442] = [__v_11, __v_0, __v_14]; + if let Some(result) = record.function_queries[442].get_mut(&inp[..]) { debug_assert_eq!(result.output, &__ret[..]); if !unconstrained { *result.multiplicity += G::ONE; } } else { record.function_queries[442].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained)); }; return Ok(__ret); }, } @@ -39905,7 +39631,7 @@ fn aiur_fn_446( 7u64 => { match __v_16.as_canonical_u64() { 0u64 => { - let __r_arr: [G; OUT_446] = { let __args: [G; IN_446] = [__v_7]; let __cu = unconstrained; if let Some(result) = record.function_queries[446].get_mut(&__args[..]) { if !__cu && *result.multiplicity == G::ZERO { aiur_fn_446(__args, record, io_buffer, false)? } else { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_446] = unsafe { *(result.output.as_ptr() as *const [G; OUT_446]) }; __ret } } else { aiur_fn_446(__args, record, io_buffer, __cu)? } }; + let __r_arr: [G; OUT_442] = { let __args: [G; IN_442] = [__v_7]; let __cu = unconstrained; if let Some(result) = record.function_queries[442].get_mut(&__args[..]) { if !__cu && *result.multiplicity == G::ZERO { aiur_fn_442(__args, record, io_buffer, false)? } else { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_442] = unsafe { *(result.output.as_ptr() as *const [G; OUT_442]) }; __ret } } else { aiur_fn_442(__args, record, io_buffer, __cu)? } }; let __v_19: G = __r_arr[0]; let __v_20: G = __r_arr[1]; let __v_21: G = __r_arr[2]; @@ -39914,14 +39640,14 @@ fn aiur_fn_446( let __v_22: G = G::from_u64(1); let __r_arr: [G; OUT_114] = { let __args: [G; IN_114] = [__v_21, __v_17]; let __cu = unconstrained; if let Some(result) = record.function_queries[114].get_mut(&__args[..]) { if !__cu && *result.multiplicity == G::ZERO { aiur_fn_114(__args, record, io_buffer, false)? } else { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_114] = unsafe { *(result.output.as_ptr() as *const [G; OUT_114]) }; __ret } } else { aiur_fn_114(__args, record, io_buffer, __cu)? } }; let __v_23: G = __r_arr[0]; - let __ret: [G; OUT_446] = [__v_22, __v_20, __v_23]; - if let Some(result) = record.function_queries[446].get_mut(&inp[..]) { debug_assert_eq!(result.output, &__ret[..]); if !unconstrained { *result.multiplicity += G::ONE; } } else { record.function_queries[446].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained)); }; + let __ret: [G; OUT_442] = [__v_22, __v_20, __v_23]; + if let Some(result) = record.function_queries[442].get_mut(&inp[..]) { debug_assert_eq!(result.output, &__ret[..]); if !unconstrained { *result.multiplicity += G::ONE; } } else { record.function_queries[442].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained)); }; return Ok(__ret); }, _ => { let __v_22: G = G::from_u64(1); - let __ret: [G; OUT_446] = [__v_22, __v_7, __v_17]; - if let Some(result) = record.function_queries[446].get_mut(&inp[..]) { debug_assert_eq!(result.output, &__ret[..]); if !unconstrained { *result.multiplicity += G::ONE; } } else { record.function_queries[446].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained)); }; + let __ret: [G; OUT_442] = [__v_22, __v_7, __v_17]; + if let Some(result) = record.function_queries[442].get_mut(&inp[..]) { debug_assert_eq!(result.output, &__ret[..]); if !unconstrained { *result.multiplicity += G::ONE; } } else { record.function_queries[442].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained)); }; return Ok(__ret); }, } @@ -39931,8 +39657,8 @@ fn aiur_fn_446( let __v_20: G = G::from_u64(1); let __v_21: G = G::from_u64(1); let __v_22: G = { let __values: [G; 10] = [__v_20, __v_21, __v_21, __v_21, __v_21, __v_21, __v_21, __v_21, __v_21, __v_21]; let __mq = record.memory_queries.get_mut(&10).ok_or(ExecError::InvalidMemorySize(10))?; if let Some(result) = __mq.get_mut(&__values[..]) { if !unconstrained { *result.multiplicity += G::ONE; } result.output[0] } else { let __ptr = G::from_usize(__mq.len()); __mq.insert(&__values[..], &[__ptr], G::from_bool(!unconstrained)); __ptr } }; - let __ret: [G; OUT_446] = [__v_19, __v_0, __v_22]; - if let Some(result) = record.function_queries[446].get_mut(&inp[..]) { debug_assert_eq!(result.output, &__ret[..]); if !unconstrained { *result.multiplicity += G::ONE; } } else { record.function_queries[446].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained)); }; + let __ret: [G; OUT_442] = [__v_19, __v_0, __v_22]; + if let Some(result) = record.function_queries[442].get_mut(&inp[..]) { debug_assert_eq!(result.output, &__ret[..]); if !unconstrained { *result.multiplicity += G::ONE; } } else { record.function_queries[442].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained)); }; return Ok(__ret); }, } @@ -39942,8 +39668,8 @@ fn aiur_fn_446( let __v_20: G = G::from_u64(1); let __v_21: G = G::from_u64(1); let __v_22: G = { let __values: [G; 10] = [__v_20, __v_21, __v_21, __v_21, __v_21, __v_21, __v_21, __v_21, __v_21, __v_21]; let __mq = record.memory_queries.get_mut(&10).ok_or(ExecError::InvalidMemorySize(10))?; if let Some(result) = __mq.get_mut(&__values[..]) { if !unconstrained { *result.multiplicity += G::ONE; } result.output[0] } else { let __ptr = G::from_usize(__mq.len()); __mq.insert(&__values[..], &[__ptr], G::from_bool(!unconstrained)); __ptr } }; - let __ret: [G; OUT_446] = [__v_19, __v_0, __v_22]; - if let Some(result) = record.function_queries[446].get_mut(&inp[..]) { debug_assert_eq!(result.output, &__ret[..]); if !unconstrained { *result.multiplicity += G::ONE; } } else { record.function_queries[446].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained)); }; + let __ret: [G; OUT_442] = [__v_19, __v_0, __v_22]; + if let Some(result) = record.function_queries[442].get_mut(&inp[..]) { debug_assert_eq!(result.output, &__ret[..]); if !unconstrained { *result.multiplicity += G::ONE; } } else { record.function_queries[442].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained)); }; return Ok(__ret); }, } @@ -39953,8 +39679,8 @@ fn aiur_fn_446( let __v_16: G = G::from_u64(1); let __v_17: G = G::from_u64(1); let __v_18: G = { let __values: [G; 10] = [__v_16, __v_17, __v_17, __v_17, __v_17, __v_17, __v_17, __v_17, __v_17, __v_17]; let __mq = record.memory_queries.get_mut(&10).ok_or(ExecError::InvalidMemorySize(10))?; if let Some(result) = __mq.get_mut(&__values[..]) { if !unconstrained { *result.multiplicity += G::ONE; } result.output[0] } else { let __ptr = G::from_usize(__mq.len()); __mq.insert(&__values[..], &[__ptr], G::from_bool(!unconstrained)); __ptr } }; - let __ret: [G; OUT_446] = [__v_15, __v_0, __v_18]; - if let Some(result) = record.function_queries[446].get_mut(&inp[..]) { debug_assert_eq!(result.output, &__ret[..]); if !unconstrained { *result.multiplicity += G::ONE; } } else { record.function_queries[446].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained)); }; + let __ret: [G; OUT_442] = [__v_15, __v_0, __v_18]; + if let Some(result) = record.function_queries[442].get_mut(&inp[..]) { debug_assert_eq!(result.output, &__ret[..]); if !unconstrained { *result.multiplicity += G::ONE; } } else { record.function_queries[442].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained)); }; return Ok(__ret); }, } @@ -39964,8 +39690,8 @@ fn aiur_fn_446( let __v_14: G = G::from_u64(1); let __v_15: G = G::from_u64(1); let __v_16: G = { let __values: [G; 10] = [__v_14, __v_15, __v_15, __v_15, __v_15, __v_15, __v_15, __v_15, __v_15, __v_15]; let __mq = record.memory_queries.get_mut(&10).ok_or(ExecError::InvalidMemorySize(10))?; if let Some(result) = __mq.get_mut(&__values[..]) { if !unconstrained { *result.multiplicity += G::ONE; } result.output[0] } else { let __ptr = G::from_usize(__mq.len()); __mq.insert(&__values[..], &[__ptr], G::from_bool(!unconstrained)); __ptr } }; - let __ret: [G; OUT_446] = [__v_13, __v_0, __v_16]; - if let Some(result) = record.function_queries[446].get_mut(&inp[..]) { debug_assert_eq!(result.output, &__ret[..]); if !unconstrained { *result.multiplicity += G::ONE; } } else { record.function_queries[446].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained)); }; + let __ret: [G; OUT_442] = [__v_13, __v_0, __v_16]; + if let Some(result) = record.function_queries[442].get_mut(&inp[..]) { debug_assert_eq!(result.output, &__ret[..]); if !unconstrained { *result.multiplicity += G::ONE; } } else { record.function_queries[442].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained)); }; return Ok(__ret); }, } @@ -39975,8 +39701,8 @@ fn aiur_fn_446( let __v_10: G = G::from_u64(1); let __v_11: G = G::from_u64(1); let __v_12: G = { let __values: [G; 10] = [__v_10, __v_11, __v_11, __v_11, __v_11, __v_11, __v_11, __v_11, __v_11, __v_11]; let __mq = record.memory_queries.get_mut(&10).ok_or(ExecError::InvalidMemorySize(10))?; if let Some(result) = __mq.get_mut(&__values[..]) { if !unconstrained { *result.multiplicity += G::ONE; } result.output[0] } else { let __ptr = G::from_usize(__mq.len()); __mq.insert(&__values[..], &[__ptr], G::from_bool(!unconstrained)); __ptr } }; - let __ret: [G; OUT_446] = [__v_9, __v_0, __v_12]; - if let Some(result) = record.function_queries[446].get_mut(&inp[..]) { debug_assert_eq!(result.output, &__ret[..]); if !unconstrained { *result.multiplicity += G::ONE; } } else { record.function_queries[446].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained)); }; + let __ret: [G; OUT_442] = [__v_9, __v_0, __v_12]; + if let Some(result) = record.function_queries[442].get_mut(&inp[..]) { debug_assert_eq!(result.output, &__ret[..]); if !unconstrained { *result.multiplicity += G::ONE; } } else { record.function_queries[442].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained)); }; return Ok(__ret); }, } @@ -39986,46 +39712,46 @@ fn aiur_fn_446( let __v_6: G = G::from_u64(1); let __v_7: G = G::from_u64(1); let __v_8: G = { let __values: [G; 10] = [__v_6, __v_7, __v_7, __v_7, __v_7, __v_7, __v_7, __v_7, __v_7, __v_7]; let __mq = record.memory_queries.get_mut(&10).ok_or(ExecError::InvalidMemorySize(10))?; if let Some(result) = __mq.get_mut(&__values[..]) { if !unconstrained { *result.multiplicity += G::ONE; } result.output[0] } else { let __ptr = G::from_usize(__mq.len()); __mq.insert(&__values[..], &[__ptr], G::from_bool(!unconstrained)); __ptr } }; - let __ret: [G; OUT_446] = [__v_5, __v_0, __v_8]; - if let Some(result) = record.function_queries[446].get_mut(&inp[..]) { debug_assert_eq!(result.output, &__ret[..]); if !unconstrained { *result.multiplicity += G::ONE; } } else { record.function_queries[446].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained)); }; + let __ret: [G; OUT_442] = [__v_5, __v_0, __v_8]; + if let Some(result) = record.function_queries[442].get_mut(&inp[..]) { debug_assert_eq!(result.output, &__ret[..]); if !unconstrained { *result.multiplicity += G::ONE; } } else { record.function_queries[442].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained)); }; return Ok(__ret); }, } }) } -const INPUT_SIZE_447: usize = 3; -const IN_447: usize = 3; -const OUT_447: usize = 2; -fn aiur_fn_447( - inp: [G; IN_447], +const INPUT_SIZE_443: usize = 3; +const IN_443: usize = 3; +const OUT_443: usize = 2; +fn aiur_fn_443( + inp: [G; IN_443], record: &mut QueryRecord, io_buffer: &mut IOBuffer, unconstrained: bool, -) -> Result<[G; OUT_447], ExecError> { +) -> Result<[G; OUT_443], ExecError> { stacker::maybe_grow(64 * 1024, 4 * 1024 * 1024, || { let __v_0: G = inp[0]; let __v_1: G = inp[1]; let __v_2: G = inp[2]; - let __r_arr: [G; OUT_445] = { let __args: [G; IN_445] = [__v_0]; let __cu = unconstrained; if let Some(result) = record.function_queries[445].get_mut(&__args[..]) { if !__cu && *result.multiplicity == G::ZERO { aiur_fn_445(__args, record, io_buffer, false)? } else { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_445] = unsafe { *(result.output.as_ptr() as *const [G; OUT_445]) }; __ret } } else { aiur_fn_445(__args, record, io_buffer, __cu)? } }; + let __r_arr: [G; OUT_441] = { let __args: [G; IN_441] = [__v_0]; let __cu = unconstrained; if let Some(result) = record.function_queries[441].get_mut(&__args[..]) { if !__cu && *result.multiplicity == G::ZERO { aiur_fn_441(__args, record, io_buffer, false)? } else { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_441] = unsafe { *(result.output.as_ptr() as *const [G; OUT_441]) }; __ret } } else { aiur_fn_441(__args, record, io_buffer, __cu)? } }; let __v_3: G = __r_arr[0]; - let __r_arr: [G; OUT_445] = { let __args: [G; IN_445] = [__v_1]; let __cu = unconstrained; if let Some(result) = record.function_queries[445].get_mut(&__args[..]) { if !__cu && *result.multiplicity == G::ZERO { aiur_fn_445(__args, record, io_buffer, false)? } else { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_445] = unsafe { *(result.output.as_ptr() as *const [G; OUT_445]) }; __ret } } else { aiur_fn_445(__args, record, io_buffer, __cu)? } }; + let __r_arr: [G; OUT_441] = { let __args: [G; IN_441] = [__v_1]; let __cu = unconstrained; if let Some(result) = record.function_queries[441].get_mut(&__args[..]) { if !__cu && *result.multiplicity == G::ZERO { aiur_fn_441(__args, record, io_buffer, false)? } else { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_441] = unsafe { *(result.output.as_ptr() as *const [G; OUT_441]) }; __ret } } else { aiur_fn_441(__args, record, io_buffer, __cu)? } }; let __v_4: G = __r_arr[0]; let __v_5: G = (__v_3 * __v_4); match __v_5.as_canonical_u64() { 1u64 => { let __v_6: G = G::from_u64(1); let __v_7: G = G::from_u64(1); - let __ret: [G; OUT_447] = [__v_6, __v_7]; - if let Some(result) = record.function_queries[447].get_mut(&inp[..]) { debug_assert_eq!(result.output, &__ret[..]); if !unconstrained { *result.multiplicity += G::ONE; } } else { record.function_queries[447].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained)); }; + let __ret: [G; OUT_443] = [__v_6, __v_7]; + if let Some(result) = record.function_queries[443].get_mut(&inp[..]) { debug_assert_eq!(result.output, &__ret[..]); if !unconstrained { *result.multiplicity += G::ONE; } } else { record.function_queries[443].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained)); }; return Ok(__ret); }, _ => { - let __r_arr: [G; OUT_446] = { let __args: [G; IN_446] = [__v_0]; let __cu = unconstrained; if let Some(result) = record.function_queries[446].get_mut(&__args[..]) { if !__cu && *result.multiplicity == G::ZERO { aiur_fn_446(__args, record, io_buffer, false)? } else { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_446] = unsafe { *(result.output.as_ptr() as *const [G; OUT_446]) }; __ret } } else { aiur_fn_446(__args, record, io_buffer, __cu)? } }; + let __r_arr: [G; OUT_442] = { let __args: [G; IN_442] = [__v_0]; let __cu = unconstrained; if let Some(result) = record.function_queries[442].get_mut(&__args[..]) { if !__cu && *result.multiplicity == G::ZERO { aiur_fn_442(__args, record, io_buffer, false)? } else { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_442] = unsafe { *(result.output.as_ptr() as *const [G; OUT_442]) }; __ret } } else { aiur_fn_442(__args, record, io_buffer, __cu)? } }; let __v_6: G = __r_arr[0]; let __v_7: G = __r_arr[1]; let __v_8: G = __r_arr[2]; - let __r_arr: [G; OUT_446] = { let __args: [G; IN_446] = [__v_1]; let __cu = unconstrained; if let Some(result) = record.function_queries[446].get_mut(&__args[..]) { if !__cu && *result.multiplicity == G::ZERO { aiur_fn_446(__args, record, io_buffer, false)? } else { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_446] = unsafe { *(result.output.as_ptr() as *const [G; OUT_446]) }; __ret } } else { aiur_fn_446(__args, record, io_buffer, __cu)? } }; + let __r_arr: [G; OUT_442] = { let __args: [G; IN_442] = [__v_1]; let __cu = unconstrained; if let Some(result) = record.function_queries[442].get_mut(&__args[..]) { if !__cu && *result.multiplicity == G::ZERO { aiur_fn_442(__args, record, io_buffer, false)? } else { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_442] = unsafe { *(result.output.as_ptr() as *const [G; OUT_442]) }; __ret } } else { aiur_fn_442(__args, record, io_buffer, __cu)? } }; let __v_9: G = __r_arr[0]; let __v_10: G = __r_arr[1]; let __v_11: G = __r_arr[2]; @@ -40034,27 +39760,27 @@ fn aiur_fn_447( 0u64 => { let __v_13: G = G::from_u64(0); let __v_14: G = G::from_u64(0); - let __ret: [G; OUT_447] = [__v_13, __v_14]; - if let Some(result) = record.function_queries[447].get_mut(&inp[..]) { debug_assert_eq!(result.output, &__ret[..]); if !unconstrained { *result.multiplicity += G::ONE; } } else { record.function_queries[447].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained)); }; + let __ret: [G; OUT_443] = [__v_13, __v_14]; + if let Some(result) = record.function_queries[443].get_mut(&inp[..]) { debug_assert_eq!(result.output, &__ret[..]); if !unconstrained { *result.multiplicity += G::ONE; } } else { record.function_queries[443].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained)); }; return Ok(__ret); }, _ => { - let __r_arr: [G; OUT_338] = { let __args: [G; IN_338] = [__v_8, __v_11]; let __cu = unconstrained; if let Some(result) = record.function_queries[338].get_mut(&__args[..]) { if !__cu && *result.multiplicity == G::ZERO { aiur_fn_338(__args, record, io_buffer, false)? } else { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_338] = unsafe { *(result.output.as_ptr() as *const [G; OUT_338]) }; __ret } } else { aiur_fn_338(__args, record, io_buffer, __cu)? } }; + let __r_arr: [G; OUT_334] = { let __args: [G; IN_334] = [__v_8, __v_11]; let __cu = unconstrained; if let Some(result) = record.function_queries[334].get_mut(&__args[..]) { if !__cu && *result.multiplicity == G::ZERO { aiur_fn_334(__args, record, io_buffer, false)? } else { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_334] = unsafe { *(result.output.as_ptr() as *const [G; OUT_334]) }; __ret } } else { aiur_fn_334(__args, record, io_buffer, __cu)? } }; let __v_13: G = __r_arr[0]; match __v_13.as_canonical_u64() { 0u64 => { let __v_14: G = G::from_u64(0); let __v_15: G = G::from_u64(0); - let __ret: [G; OUT_447] = [__v_14, __v_15]; - if let Some(result) = record.function_queries[447].get_mut(&inp[..]) { debug_assert_eq!(result.output, &__ret[..]); if !unconstrained { *result.multiplicity += G::ONE; } } else { record.function_queries[447].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained)); }; + let __ret: [G; OUT_443] = [__v_14, __v_15]; + if let Some(result) = record.function_queries[443].get_mut(&inp[..]) { debug_assert_eq!(result.output, &__ret[..]); if !unconstrained { *result.multiplicity += G::ONE; } } else { record.function_queries[443].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained)); }; return Ok(__ret); }, _ => { let __v_14: G = G::from_u64(1); - let __r_arr: [G; OUT_439] = { let __args: [G; IN_439] = [__v_7, __v_10, __v_2]; let __cu = unconstrained; if let Some(result) = record.function_queries[439].get_mut(&__args[..]) { if !__cu && *result.multiplicity == G::ZERO { aiur_fn_439(__args, record, io_buffer, false)? } else { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_439] = unsafe { *(result.output.as_ptr() as *const [G; OUT_439]) }; __ret } } else { aiur_fn_439(__args, record, io_buffer, __cu)? } }; + let __r_arr: [G; OUT_435] = { let __args: [G; IN_435] = [__v_7, __v_10, __v_2]; let __cu = unconstrained; if let Some(result) = record.function_queries[435].get_mut(&__args[..]) { if !__cu && *result.multiplicity == G::ZERO { aiur_fn_435(__args, record, io_buffer, false)? } else { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_435] = unsafe { *(result.output.as_ptr() as *const [G; OUT_435]) }; __ret } } else { aiur_fn_435(__args, record, io_buffer, __cu)? } }; let __v_15: G = __r_arr[0]; - let __ret: [G; OUT_447] = [__v_14, __v_15]; - if let Some(result) = record.function_queries[447].get_mut(&inp[..]) { debug_assert_eq!(result.output, &__ret[..]); if !unconstrained { *result.multiplicity += G::ONE; } } else { record.function_queries[447].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained)); }; + let __ret: [G; OUT_443] = [__v_14, __v_15]; + if let Some(result) = record.function_queries[443].get_mut(&inp[..]) { debug_assert_eq!(result.output, &__ret[..]); if !unconstrained { *result.multiplicity += G::ONE; } } else { record.function_queries[443].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained)); }; return Ok(__ret); }, } @@ -40065,48 +39791,48 @@ fn aiur_fn_447( }) } -const INPUT_SIZE_448: usize = 3; -const IN_448: usize = 3; -const OUT_448: usize = 1; -fn aiur_fn_448( - inp: [G; IN_448], +const INPUT_SIZE_444: usize = 3; +const IN_444: usize = 3; +const OUT_444: usize = 1; +fn aiur_fn_444( + inp: [G; IN_444], record: &mut QueryRecord, io_buffer: &mut IOBuffer, unconstrained: bool, -) -> Result<[G; OUT_448], ExecError> { +) -> Result<[G; OUT_444], ExecError> { stacker::maybe_grow(64 * 1024, 4 * 1024 * 1024, || { let __v_0: G = inp[0]; let __v_1: G = inp[1]; let __v_2: G = inp[2]; - let __r_arr: [G; OUT_449] = { let __args: [G; IN_449] = [__v_0, __v_1, __v_2]; let __cu = unconstrained; if let Some(result) = record.function_queries[449].get_mut(&__args[..]) { if !__cu && *result.multiplicity == G::ZERO { aiur_fn_449(__args, record, io_buffer, false)? } else { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_449] = unsafe { *(result.output.as_ptr() as *const [G; OUT_449]) }; __ret } } else { aiur_fn_449(__args, record, io_buffer, __cu)? } }; + let __r_arr: [G; OUT_445] = { let __args: [G; IN_445] = [__v_0, __v_1, __v_2]; let __cu = unconstrained; if let Some(result) = record.function_queries[445].get_mut(&__args[..]) { if !__cu && *result.multiplicity == G::ZERO { aiur_fn_445(__args, record, io_buffer, false)? } else { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_445] = unsafe { *(result.output.as_ptr() as *const [G; OUT_445]) }; __ret } } else { aiur_fn_445(__args, record, io_buffer, __cu)? } }; let __v_3: G = __r_arr[0]; match __v_3.as_canonical_u64() { 1u64 => { let __v_4: G = G::from_u64(1); - let __ret: [G; OUT_448] = [__v_4]; - if let Some(result) = record.function_queries[448].get_mut(&inp[..]) { debug_assert_eq!(result.output, &__ret[..]); if !unconstrained { *result.multiplicity += G::ONE; } } else { record.function_queries[448].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained)); }; + let __ret: [G; OUT_444] = [__v_4]; + if let Some(result) = record.function_queries[444].get_mut(&inp[..]) { debug_assert_eq!(result.output, &__ret[..]); if !unconstrained { *result.multiplicity += G::ONE; } } else { record.function_queries[444].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained)); }; return Ok(__ret); }, _ => { - let __r_arr: [G; OUT_449] = { let __args: [G; IN_449] = [__v_1, __v_0, __v_2]; let __cu = unconstrained; if let Some(result) = record.function_queries[449].get_mut(&__args[..]) { if !__cu && *result.multiplicity == G::ZERO { aiur_fn_449(__args, record, io_buffer, false)? } else { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_449] = unsafe { *(result.output.as_ptr() as *const [G; OUT_449]) }; __ret } } else { aiur_fn_449(__args, record, io_buffer, __cu)? } }; + let __r_arr: [G; OUT_445] = { let __args: [G; IN_445] = [__v_1, __v_0, __v_2]; let __cu = unconstrained; if let Some(result) = record.function_queries[445].get_mut(&__args[..]) { if !__cu && *result.multiplicity == G::ZERO { aiur_fn_445(__args, record, io_buffer, false)? } else { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_445] = unsafe { *(result.output.as_ptr() as *const [G; OUT_445]) }; __ret } } else { aiur_fn_445(__args, record, io_buffer, __cu)? } }; let __v_4: G = __r_arr[0]; - let __ret: [G; OUT_448] = [__v_4]; - if let Some(result) = record.function_queries[448].get_mut(&inp[..]) { debug_assert_eq!(result.output, &__ret[..]); if !unconstrained { *result.multiplicity += G::ONE; } } else { record.function_queries[448].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained)); }; + let __ret: [G; OUT_444] = [__v_4]; + if let Some(result) = record.function_queries[444].get_mut(&inp[..]) { debug_assert_eq!(result.output, &__ret[..]); if !unconstrained { *result.multiplicity += G::ONE; } } else { record.function_queries[444].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained)); }; return Ok(__ret); }, } }) } -const INPUT_SIZE_449: usize = 3; -const IN_449: usize = 3; -const OUT_449: usize = 1; -fn aiur_fn_449( - inp: [G; IN_449], +const INPUT_SIZE_445: usize = 3; +const IN_445: usize = 3; +const OUT_445: usize = 1; +fn aiur_fn_445( + inp: [G; IN_445], record: &mut QueryRecord, io_buffer: &mut IOBuffer, unconstrained: bool, -) -> Result<[G; OUT_449], ExecError> { +) -> Result<[G; OUT_445], ExecError> { stacker::maybe_grow(64 * 1024, 4 * 1024 * 1024, || { let __v_0: G = inp[0]; let __v_1: G = inp[1]; @@ -40120,48 +39846,48 @@ fn aiur_fn_449( 7u64 => { match __v_4.as_canonical_u64() { 1u64 => { - let __r_arr: [G; OUT_228] = { let __args: [G; IN_228] = [__v_5]; let __cu = unconstrained; if let Some(result) = record.function_queries[228].get_mut(&__args[..]) { if !__cu && *result.multiplicity == G::ZERO { aiur_fn_228(__args, record, io_buffer, false)? } else { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_228] = unsafe { *(result.output.as_ptr() as *const [G; OUT_228]) }; __ret } } else { aiur_fn_228(__args, record, io_buffer, __cu)? } }; + let __r_arr: [G; OUT_224] = { let __args: [G; IN_224] = [__v_5]; let __cu = unconstrained; if let Some(result) = record.function_queries[224].get_mut(&__args[..]) { if !__cu && *result.multiplicity == G::ZERO { aiur_fn_224(__args, record, io_buffer, false)? } else { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_224] = unsafe { *(result.output.as_ptr() as *const [G; OUT_224]) }; __ret } } else { aiur_fn_224(__args, record, io_buffer, __cu)? } }; let __v_7: G = __r_arr[0]; - let __r_arr: [G; OUT_230] = { let __args: [G; IN_230] = [__v_7, __v_2]; let __cu = unconstrained; if let Some(result) = record.function_queries[230].get_mut(&__args[..]) { if !__cu && *result.multiplicity == G::ZERO { aiur_fn_230(__args, record, io_buffer, false)? } else { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_230] = unsafe { *(result.output.as_ptr() as *const [G; OUT_230]) }; __ret } } else { aiur_fn_230(__args, record, io_buffer, __cu)? } }; + let __r_arr: [G; OUT_226] = { let __args: [G; IN_226] = [__v_7, __v_2]; let __cu = unconstrained; if let Some(result) = record.function_queries[226].get_mut(&__args[..]) { if !__cu && *result.multiplicity == G::ZERO { aiur_fn_226(__args, record, io_buffer, false)? } else { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_226] = unsafe { *(result.output.as_ptr() as *const [G; OUT_226]) }; __ret } } else { aiur_fn_226(__args, record, io_buffer, __cu)? } }; let __v_8: G = __r_arr[0]; - let __r_arr: [G; OUT_439] = { let __args: [G; IN_439] = [__v_8, __v_1, __v_2]; let __cu = unconstrained; if let Some(result) = record.function_queries[439].get_mut(&__args[..]) { if !__cu && *result.multiplicity == G::ZERO { aiur_fn_439(__args, record, io_buffer, false)? } else { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_439] = unsafe { *(result.output.as_ptr() as *const [G; OUT_439]) }; __ret } } else { aiur_fn_439(__args, record, io_buffer, __cu)? } }; + let __r_arr: [G; OUT_435] = { let __args: [G; IN_435] = [__v_8, __v_1, __v_2]; let __cu = unconstrained; if let Some(result) = record.function_queries[435].get_mut(&__args[..]) { if !__cu && *result.multiplicity == G::ZERO { aiur_fn_435(__args, record, io_buffer, false)? } else { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_435] = unsafe { *(result.output.as_ptr() as *const [G; OUT_435]) }; __ret } } else { aiur_fn_435(__args, record, io_buffer, __cu)? } }; let __v_9: G = __r_arr[0]; - let __ret: [G; OUT_449] = [__v_9]; - if let Some(result) = record.function_queries[449].get_mut(&inp[..]) { debug_assert_eq!(result.output, &__ret[..]); if !unconstrained { *result.multiplicity += G::ONE; } } else { record.function_queries[449].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained)); }; + let __ret: [G; OUT_445] = [__v_9]; + if let Some(result) = record.function_queries[445].get_mut(&inp[..]) { debug_assert_eq!(result.output, &__ret[..]); if !unconstrained { *result.multiplicity += G::ONE; } } else { record.function_queries[445].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained)); }; return Ok(__ret); }, _ => { let __v_7: G = G::from_u64(0); - let __ret: [G; OUT_449] = [__v_7]; - if let Some(result) = record.function_queries[449].get_mut(&inp[..]) { debug_assert_eq!(result.output, &__ret[..]); if !unconstrained { *result.multiplicity += G::ONE; } } else { record.function_queries[449].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained)); }; + let __ret: [G; OUT_445] = [__v_7]; + if let Some(result) = record.function_queries[445].get_mut(&inp[..]) { debug_assert_eq!(result.output, &__ret[..]); if !unconstrained { *result.multiplicity += G::ONE; } } else { record.function_queries[445].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained)); }; return Ok(__ret); }, } }, _ => { let __v_7: G = G::from_u64(0); - let __ret: [G; OUT_449] = [__v_7]; - if let Some(result) = record.function_queries[449].get_mut(&inp[..]) { debug_assert_eq!(result.output, &__ret[..]); if !unconstrained { *result.multiplicity += G::ONE; } } else { record.function_queries[449].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained)); }; + let __ret: [G; OUT_445] = [__v_7]; + if let Some(result) = record.function_queries[445].get_mut(&inp[..]) { debug_assert_eq!(result.output, &__ret[..]); if !unconstrained { *result.multiplicity += G::ONE; } } else { record.function_queries[445].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained)); }; return Ok(__ret); }, } }) } -const INPUT_SIZE_450: usize = 3; -const IN_450: usize = 3; -const OUT_450: usize = 1; -fn aiur_fn_450( - inp: [G; IN_450], +const INPUT_SIZE_446: usize = 3; +const IN_446: usize = 3; +const OUT_446: usize = 1; +fn aiur_fn_446( + inp: [G; IN_446], record: &mut QueryRecord, io_buffer: &mut IOBuffer, unconstrained: bool, -) -> Result<[G; OUT_450], ExecError> { +) -> Result<[G; OUT_446], ExecError> { stacker::maybe_grow(64 * 1024, 4 * 1024 * 1024, || { let __v_0: G = inp[0]; let __v_1: G = inp[1]; let __v_2: G = inp[2]; - let __r_arr: [G; OUT_449] = { let __args: [G; IN_449] = [__v_0, __v_1, __v_2]; let __cu = unconstrained; if let Some(result) = record.function_queries[449].get_mut(&__args[..]) { if !__cu && *result.multiplicity == G::ZERO { aiur_fn_449(__args, record, io_buffer, false)? } else { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_449] = unsafe { *(result.output.as_ptr() as *const [G; OUT_449]) }; __ret } } else { aiur_fn_449(__args, record, io_buffer, __cu)? } }; + let __r_arr: [G; OUT_445] = { let __args: [G; IN_445] = [__v_0, __v_1, __v_2]; let __cu = unconstrained; if let Some(result) = record.function_queries[445].get_mut(&__args[..]) { if !__cu && *result.multiplicity == G::ZERO { aiur_fn_445(__args, record, io_buffer, false)? } else { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_445] = unsafe { *(result.output.as_ptr() as *const [G; OUT_445]) }; __ret } } else { aiur_fn_445(__args, record, io_buffer, __cu)? } }; let __v_3: G = __r_arr[0]; let __mc_out___mc_0: [G; 1] = '__mc_0: { match __v_3.as_canonical_u64() { 1u64 => { @@ -40169,7 +39895,7 @@ fn aiur_fn_450( break '__mc_0 [__v_4]; }, _ => { - let __r_arr: [G; OUT_449] = { let __args: [G; IN_449] = [__v_1, __v_0, __v_2]; let __cu = unconstrained; if let Some(result) = record.function_queries[449].get_mut(&__args[..]) { if !__cu && *result.multiplicity == G::ZERO { aiur_fn_449(__args, record, io_buffer, false)? } else { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_449] = unsafe { *(result.output.as_ptr() as *const [G; OUT_449]) }; __ret } } else { aiur_fn_449(__args, record, io_buffer, __cu)? } }; + let __r_arr: [G; OUT_445] = { let __args: [G; IN_445] = [__v_1, __v_0, __v_2]; let __cu = unconstrained; if let Some(result) = record.function_queries[445].get_mut(&__args[..]) { if !__cu && *result.multiplicity == G::ZERO { aiur_fn_445(__args, record, io_buffer, false)? } else { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_445] = unsafe { *(result.output.as_ptr() as *const [G; OUT_445]) }; __ret } } else { aiur_fn_445(__args, record, io_buffer, __cu)? } }; let __v_4: G = __r_arr[0]; break '__mc_0 [__v_4]; }, @@ -40179,71 +39905,71 @@ fn aiur_fn_450( match __v_4.as_canonical_u64() { 1u64 => { let __v_5: G = G::from_u64(1); - let __ret: [G; OUT_450] = [__v_5]; - if let Some(result) = record.function_queries[450].get_mut(&inp[..]) { debug_assert_eq!(result.output, &__ret[..]); if !unconstrained { *result.multiplicity += G::ONE; } } else { record.function_queries[450].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained)); }; + let __ret: [G; OUT_446] = [__v_5]; + if let Some(result) = record.function_queries[446].get_mut(&inp[..]) { debug_assert_eq!(result.output, &__ret[..]); if !unconstrained { *result.multiplicity += G::ONE; } } else { record.function_queries[446].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained)); }; return Ok(__ret); }, _ => { - let __r_arr: [G; OUT_451] = { let __args: [G; IN_451] = [__v_0, __v_1, __v_2]; let __cu = unconstrained; if let Some(result) = record.function_queries[451].get_mut(&__args[..]) { if !__cu && *result.multiplicity == G::ZERO { aiur_fn_451(__args, record, io_buffer, false)? } else { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_451] = unsafe { *(result.output.as_ptr() as *const [G; OUT_451]) }; __ret } } else { aiur_fn_451(__args, record, io_buffer, __cu)? } }; + let __r_arr: [G; OUT_447] = { let __args: [G; IN_447] = [__v_0, __v_1, __v_2]; let __cu = unconstrained; if let Some(result) = record.function_queries[447].get_mut(&__args[..]) { if !__cu && *result.multiplicity == G::ZERO { aiur_fn_447(__args, record, io_buffer, false)? } else { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_447] = unsafe { *(result.output.as_ptr() as *const [G; OUT_447]) }; __ret } } else { aiur_fn_447(__args, record, io_buffer, __cu)? } }; let __v_5: G = __r_arr[0]; - let __ret: [G; OUT_450] = [__v_5]; - if let Some(result) = record.function_queries[450].get_mut(&inp[..]) { debug_assert_eq!(result.output, &__ret[..]); if !unconstrained { *result.multiplicity += G::ONE; } } else { record.function_queries[450].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained)); }; + let __ret: [G; OUT_446] = [__v_5]; + if let Some(result) = record.function_queries[446].get_mut(&inp[..]) { debug_assert_eq!(result.output, &__ret[..]); if !unconstrained { *result.multiplicity += G::ONE; } } else { record.function_queries[446].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained)); }; return Ok(__ret); }, } }) } -const INPUT_SIZE_451: usize = 3; -const IN_451: usize = 3; -const OUT_451: usize = 1; -fn aiur_fn_451( - inp: [G; IN_451], +const INPUT_SIZE_447: usize = 3; +const IN_447: usize = 3; +const OUT_447: usize = 1; +fn aiur_fn_447( + inp: [G; IN_447], record: &mut QueryRecord, io_buffer: &mut IOBuffer, unconstrained: bool, -) -> Result<[G; OUT_451], ExecError> { +) -> Result<[G; OUT_447], ExecError> { stacker::maybe_grow(64 * 1024, 4 * 1024 * 1024, || { let __v_0: G = inp[0]; let __v_1: G = inp[1]; let __v_2: G = inp[2]; - let __r_arr: [G; OUT_420] = { let __args: [G; IN_420] = [__v_0, __v_2]; let __cu = unconstrained; if let Some(result) = record.function_queries[420].get_mut(&__args[..]) { if !__cu && *result.multiplicity == G::ZERO { aiur_fn_420(__args, record, io_buffer, false)? } else { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_420] = unsafe { *(result.output.as_ptr() as *const [G; OUT_420]) }; __ret } } else { aiur_fn_420(__args, record, io_buffer, __cu)? } }; + let __r_arr: [G; OUT_416] = { let __args: [G; IN_416] = [__v_0, __v_2]; let __cu = unconstrained; if let Some(result) = record.function_queries[416].get_mut(&__args[..]) { if !__cu && *result.multiplicity == G::ZERO { aiur_fn_416(__args, record, io_buffer, false)? } else { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_416] = unsafe { *(result.output.as_ptr() as *const [G; OUT_416]) }; __ret } } else { aiur_fn_416(__args, record, io_buffer, __cu)? } }; let __v_3: G = __r_arr[0]; - let __r_arr: [G; OUT_420] = { let __args: [G; IN_420] = [__v_1, __v_2]; let __cu = unconstrained; if let Some(result) = record.function_queries[420].get_mut(&__args[..]) { if !__cu && *result.multiplicity == G::ZERO { aiur_fn_420(__args, record, io_buffer, false)? } else { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_420] = unsafe { *(result.output.as_ptr() as *const [G; OUT_420]) }; __ret } } else { aiur_fn_420(__args, record, io_buffer, __cu)? } }; + let __r_arr: [G; OUT_416] = { let __args: [G; IN_416] = [__v_1, __v_2]; let __cu = unconstrained; if let Some(result) = record.function_queries[416].get_mut(&__args[..]) { if !__cu && *result.multiplicity == G::ZERO { aiur_fn_416(__args, record, io_buffer, false)? } else { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_416] = unsafe { *(result.output.as_ptr() as *const [G; OUT_416]) }; __ret } } else { aiur_fn_416(__args, record, io_buffer, __cu)? } }; let __v_4: G = __r_arr[0]; let __v_5: G = (__v_3 - __v_4); match __v_5.as_canonical_u64() { 0u64 => { let __v_6: G = G::from_u64(1); - let __ret: [G; OUT_451] = [__v_6]; - if let Some(result) = record.function_queries[451].get_mut(&inp[..]) { debug_assert_eq!(result.output, &__ret[..]); if !unconstrained { *result.multiplicity += G::ONE; } } else { record.function_queries[451].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained)); }; + let __ret: [G; OUT_447] = [__v_6]; + if let Some(result) = record.function_queries[447].get_mut(&inp[..]) { debug_assert_eq!(result.output, &__ret[..]); if !unconstrained { *result.multiplicity += G::ONE; } } else { record.function_queries[447].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained)); }; return Ok(__ret); }, _ => { - let __r_arr: [G; OUT_453] = { let __args: [G; IN_453] = [__v_3, __v_4, __v_2]; let __cu = unconstrained; if let Some(result) = record.function_queries[453].get_mut(&__args[..]) { if !__cu && *result.multiplicity == G::ZERO { aiur_fn_453(__args, record, io_buffer, false)? } else { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_453] = unsafe { *(result.output.as_ptr() as *const [G; OUT_453]) }; __ret } } else { aiur_fn_453(__args, record, io_buffer, __cu)? } }; + let __r_arr: [G; OUT_449] = { let __args: [G; IN_449] = [__v_3, __v_4, __v_2]; let __cu = unconstrained; if let Some(result) = record.function_queries[449].get_mut(&__args[..]) { if !__cu && *result.multiplicity == G::ZERO { aiur_fn_449(__args, record, io_buffer, false)? } else { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_449] = unsafe { *(result.output.as_ptr() as *const [G; OUT_449]) }; __ret } } else { aiur_fn_449(__args, record, io_buffer, __cu)? } }; let __v_6: G = __r_arr[0]; match __v_6.as_canonical_u64() { 1u64 => { let __v_7: G = G::from_u64(1); - let __ret: [G; OUT_451] = [__v_7]; - if let Some(result) = record.function_queries[451].get_mut(&inp[..]) { debug_assert_eq!(result.output, &__ret[..]); if !unconstrained { *result.multiplicity += G::ONE; } } else { record.function_queries[451].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained)); }; + let __ret: [G; OUT_447] = [__v_7]; + if let Some(result) = record.function_queries[447].get_mut(&inp[..]) { debug_assert_eq!(result.output, &__ret[..]); if !unconstrained { *result.multiplicity += G::ONE; } } else { record.function_queries[447].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained)); }; return Ok(__ret); }, _ => { - let __r_arr: [G; OUT_443] = { let __args: [G; IN_443] = [__v_3, __v_4, __v_2]; let __cu = unconstrained; if let Some(result) = record.function_queries[443].get_mut(&__args[..]) { if !__cu && *result.multiplicity == G::ZERO { aiur_fn_443(__args, record, io_buffer, false)? } else { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_443] = unsafe { *(result.output.as_ptr() as *const [G; OUT_443]) }; __ret } } else { aiur_fn_443(__args, record, io_buffer, __cu)? } }; + let __r_arr: [G; OUT_439] = { let __args: [G; IN_439] = [__v_3, __v_4, __v_2]; let __cu = unconstrained; if let Some(result) = record.function_queries[439].get_mut(&__args[..]) { if !__cu && *result.multiplicity == G::ZERO { aiur_fn_439(__args, record, io_buffer, false)? } else { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_439] = unsafe { *(result.output.as_ptr() as *const [G; OUT_439]) }; __ret } } else { aiur_fn_439(__args, record, io_buffer, __cu)? } }; let __v_7: G = __r_arr[0]; match __v_7.as_canonical_u64() { 1u64 => { let __v_8: G = G::from_u64(1); - let __ret: [G; OUT_451] = [__v_8]; - if let Some(result) = record.function_queries[451].get_mut(&inp[..]) { debug_assert_eq!(result.output, &__ret[..]); if !unconstrained { *result.multiplicity += G::ONE; } } else { record.function_queries[451].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained)); }; + let __ret: [G; OUT_447] = [__v_8]; + if let Some(result) = record.function_queries[447].get_mut(&inp[..]) { debug_assert_eq!(result.output, &__ret[..]); if !unconstrained { *result.multiplicity += G::ONE; } } else { record.function_queries[447].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained)); }; return Ok(__ret); }, _ => { - let __r_arr: [G; OUT_452] = { let __args: [G; IN_452] = [__v_0, __v_1, __v_3, __v_4, __v_2]; let __cu = unconstrained; if let Some(result) = record.function_queries[452].get_mut(&__args[..]) { if !__cu && *result.multiplicity == G::ZERO { aiur_fn_452(__args, record, io_buffer, false)? } else { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_452] = unsafe { *(result.output.as_ptr() as *const [G; OUT_452]) }; __ret } } else { aiur_fn_452(__args, record, io_buffer, __cu)? } }; + let __r_arr: [G; OUT_448] = { let __args: [G; IN_448] = [__v_0, __v_1, __v_3, __v_4, __v_2]; let __cu = unconstrained; if let Some(result) = record.function_queries[448].get_mut(&__args[..]) { if !__cu && *result.multiplicity == G::ZERO { aiur_fn_448(__args, record, io_buffer, false)? } else { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_448] = unsafe { *(result.output.as_ptr() as *const [G; OUT_448]) }; __ret } } else { aiur_fn_448(__args, record, io_buffer, __cu)? } }; let __v_8: G = __r_arr[0]; - let __ret: [G; OUT_451] = [__v_8]; - if let Some(result) = record.function_queries[451].get_mut(&inp[..]) { debug_assert_eq!(result.output, &__ret[..]); if !unconstrained { *result.multiplicity += G::ONE; } } else { record.function_queries[451].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained)); }; + let __ret: [G; OUT_447] = [__v_8]; + if let Some(result) = record.function_queries[447].get_mut(&inp[..]) { debug_assert_eq!(result.output, &__ret[..]); if !unconstrained { *result.multiplicity += G::ONE; } } else { record.function_queries[447].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained)); }; return Ok(__ret); }, } @@ -40254,58 +39980,58 @@ fn aiur_fn_451( }) } -const INPUT_SIZE_452: usize = 5; -const IN_452: usize = 5; -const OUT_452: usize = 1; -fn aiur_fn_452( - inp: [G; IN_452], +const INPUT_SIZE_448: usize = 5; +const IN_448: usize = 5; +const OUT_448: usize = 1; +fn aiur_fn_448( + inp: [G; IN_448], record: &mut QueryRecord, io_buffer: &mut IOBuffer, unconstrained: bool, -) -> Result<[G; OUT_452], ExecError> { +) -> Result<[G; OUT_448], ExecError> { stacker::maybe_grow(64 * 1024, 4 * 1024 * 1024, || { let __v_0: G = inp[0]; let __v_1: G = inp[1]; let __v_2: G = inp[2]; let __v_3: G = inp[3]; let __v_4: G = inp[4]; - let __r_arr: [G; OUT_424] = { let __args: [G; IN_424] = [__v_2, __v_4]; let __cu = unconstrained; if let Some(result) = record.function_queries[424].get_mut(&__args[..]) { if !__cu && *result.multiplicity == G::ZERO { aiur_fn_424(__args, record, io_buffer, false)? } else { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_424] = unsafe { *(result.output.as_ptr() as *const [G; OUT_424]) }; __ret } } else { aiur_fn_424(__args, record, io_buffer, __cu)? } }; + let __r_arr: [G; OUT_420] = { let __args: [G; IN_420] = [__v_2, __v_4]; let __cu = unconstrained; if let Some(result) = record.function_queries[420].get_mut(&__args[..]) { if !__cu && *result.multiplicity == G::ZERO { aiur_fn_420(__args, record, io_buffer, false)? } else { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_420] = unsafe { *(result.output.as_ptr() as *const [G; OUT_420]) }; __ret } } else { aiur_fn_420(__args, record, io_buffer, __cu)? } }; let __v_5: G = __r_arr[0]; - let __r_arr: [G; OUT_424] = { let __args: [G; IN_424] = [__v_3, __v_4]; let __cu = unconstrained; if let Some(result) = record.function_queries[424].get_mut(&__args[..]) { if !__cu && *result.multiplicity == G::ZERO { aiur_fn_424(__args, record, io_buffer, false)? } else { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_424] = unsafe { *(result.output.as_ptr() as *const [G; OUT_424]) }; __ret } } else { aiur_fn_424(__args, record, io_buffer, __cu)? } }; + let __r_arr: [G; OUT_420] = { let __args: [G; IN_420] = [__v_3, __v_4]; let __cu = unconstrained; if let Some(result) = record.function_queries[420].get_mut(&__args[..]) { if !__cu && *result.multiplicity == G::ZERO { aiur_fn_420(__args, record, io_buffer, false)? } else { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_420] = unsafe { *(result.output.as_ptr() as *const [G; OUT_420]) }; __ret } } else { aiur_fn_420(__args, record, io_buffer, __cu)? } }; let __v_6: G = __r_arr[0]; let __v_7: G = (__v_5 - __v_6); match __v_7.as_canonical_u64() { 0u64 => { let __v_8: G = G::from_u64(1); - let __ret: [G; OUT_452] = [__v_8]; - if let Some(result) = record.function_queries[452].get_mut(&inp[..]) { debug_assert_eq!(result.output, &__ret[..]); if !unconstrained { *result.multiplicity += G::ONE; } } else { record.function_queries[452].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained)); }; + let __ret: [G; OUT_448] = [__v_8]; + if let Some(result) = record.function_queries[448].get_mut(&inp[..]) { debug_assert_eq!(result.output, &__ret[..]); if !unconstrained { *result.multiplicity += G::ONE; } } else { record.function_queries[448].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained)); }; return Ok(__ret); }, _ => { - let __r_arr: [G; OUT_453] = { let __args: [G; IN_453] = [__v_5, __v_6, __v_4]; let __cu = unconstrained; if let Some(result) = record.function_queries[453].get_mut(&__args[..]) { if !__cu && *result.multiplicity == G::ZERO { aiur_fn_453(__args, record, io_buffer, false)? } else { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_453] = unsafe { *(result.output.as_ptr() as *const [G; OUT_453]) }; __ret } } else { aiur_fn_453(__args, record, io_buffer, __cu)? } }; + let __r_arr: [G; OUT_449] = { let __args: [G; IN_449] = [__v_5, __v_6, __v_4]; let __cu = unconstrained; if let Some(result) = record.function_queries[449].get_mut(&__args[..]) { if !__cu && *result.multiplicity == G::ZERO { aiur_fn_449(__args, record, io_buffer, false)? } else { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_449] = unsafe { *(result.output.as_ptr() as *const [G; OUT_449]) }; __ret } } else { aiur_fn_449(__args, record, io_buffer, __cu)? } }; let __v_8: G = __r_arr[0]; match __v_8.as_canonical_u64() { 1u64 => { let __v_9: G = G::from_u64(1); - let __ret: [G; OUT_452] = [__v_9]; - if let Some(result) = record.function_queries[452].get_mut(&inp[..]) { debug_assert_eq!(result.output, &__ret[..]); if !unconstrained { *result.multiplicity += G::ONE; } } else { record.function_queries[452].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained)); }; + let __ret: [G; OUT_448] = [__v_9]; + if let Some(result) = record.function_queries[448].get_mut(&inp[..]) { debug_assert_eq!(result.output, &__ret[..]); if !unconstrained { *result.multiplicity += G::ONE; } } else { record.function_queries[448].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained)); }; return Ok(__ret); }, _ => { - let __r_arr: [G; OUT_443] = { let __args: [G; IN_443] = [__v_5, __v_6, __v_4]; let __cu = unconstrained; if let Some(result) = record.function_queries[443].get_mut(&__args[..]) { if !__cu && *result.multiplicity == G::ZERO { aiur_fn_443(__args, record, io_buffer, false)? } else { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_443] = unsafe { *(result.output.as_ptr() as *const [G; OUT_443]) }; __ret } } else { aiur_fn_443(__args, record, io_buffer, __cu)? } }; + let __r_arr: [G; OUT_439] = { let __args: [G; IN_439] = [__v_5, __v_6, __v_4]; let __cu = unconstrained; if let Some(result) = record.function_queries[439].get_mut(&__args[..]) { if !__cu && *result.multiplicity == G::ZERO { aiur_fn_439(__args, record, io_buffer, false)? } else { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_439] = unsafe { *(result.output.as_ptr() as *const [G; OUT_439]) }; __ret } } else { aiur_fn_439(__args, record, io_buffer, __cu)? } }; let __v_9: G = __r_arr[0]; match __v_9.as_canonical_u64() { 1u64 => { let __v_10: G = G::from_u64(1); - let __ret: [G; OUT_452] = [__v_10]; - if let Some(result) = record.function_queries[452].get_mut(&inp[..]) { debug_assert_eq!(result.output, &__ret[..]); if !unconstrained { *result.multiplicity += G::ONE; } } else { record.function_queries[452].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained)); }; + let __ret: [G; OUT_448] = [__v_10]; + if let Some(result) = record.function_queries[448].get_mut(&inp[..]) { debug_assert_eq!(result.output, &__ret[..]); if !unconstrained { *result.multiplicity += G::ONE; } } else { record.function_queries[448].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained)); }; return Ok(__ret); }, _ => { - let __r_arr: [G; OUT_454] = { let __args: [G; IN_454] = [__v_0, __v_1, __v_5, __v_6, __v_4]; let __cu = unconstrained; if let Some(result) = record.function_queries[454].get_mut(&__args[..]) { if !__cu && *result.multiplicity == G::ZERO { aiur_fn_454(__args, record, io_buffer, false)? } else { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_454] = unsafe { *(result.output.as_ptr() as *const [G; OUT_454]) }; __ret } } else { aiur_fn_454(__args, record, io_buffer, __cu)? } }; + let __r_arr: [G; OUT_450] = { let __args: [G; IN_450] = [__v_0, __v_1, __v_5, __v_6, __v_4]; let __cu = unconstrained; if let Some(result) = record.function_queries[450].get_mut(&__args[..]) { if !__cu && *result.multiplicity == G::ZERO { aiur_fn_450(__args, record, io_buffer, false)? } else { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_450] = unsafe { *(result.output.as_ptr() as *const [G; OUT_450]) }; __ret } } else { aiur_fn_450(__args, record, io_buffer, __cu)? } }; let __v_10: G = __r_arr[0]; - let __ret: [G; OUT_452] = [__v_10]; - if let Some(result) = record.function_queries[452].get_mut(&inp[..]) { debug_assert_eq!(result.output, &__ret[..]); if !unconstrained { *result.multiplicity += G::ONE; } } else { record.function_queries[452].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained)); }; + let __ret: [G; OUT_448] = [__v_10]; + if let Some(result) = record.function_queries[448].get_mut(&inp[..]) { debug_assert_eq!(result.output, &__ret[..]); if !unconstrained { *result.multiplicity += G::ONE; } } else { record.function_queries[448].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained)); }; return Ok(__ret); }, } @@ -40316,15 +40042,15 @@ fn aiur_fn_452( }) } -const INPUT_SIZE_453: usize = 3; -const IN_453: usize = 3; -const OUT_453: usize = 1; -fn aiur_fn_453( - inp: [G; IN_453], +const INPUT_SIZE_449: usize = 3; +const IN_449: usize = 3; +const OUT_449: usize = 1; +fn aiur_fn_449( + inp: [G; IN_449], record: &mut QueryRecord, io_buffer: &mut IOBuffer, unconstrained: bool, -) -> Result<[G; OUT_453], ExecError> { +) -> Result<[G; OUT_449], ExecError> { stacker::maybe_grow(64 * 1024, 4 * 1024 * 1024, || { let __v_0: G = inp[0]; let __v_1: G = inp[1]; @@ -40343,16 +40069,16 @@ fn aiur_fn_453( let __v_10: G = __loaded[3]; match __v_7.as_canonical_u64() { 1u64 => { - let __r_arr: [G; OUT_324] = { let __args: [G; IN_324] = [__v_4, __v_8]; let __cu = unconstrained; if let Some(result) = record.function_queries[324].get_mut(&__args[..]) { if !__cu && *result.multiplicity == G::ZERO { aiur_fn_324(__args, record, io_buffer, false)? } else { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_324] = unsafe { *(result.output.as_ptr() as *const [G; OUT_324]) }; __ret } } else { aiur_fn_324(__args, record, io_buffer, __cu)? } }; + let __r_arr: [G; OUT_320] = { let __args: [G; IN_320] = [__v_4, __v_8]; let __cu = unconstrained; if let Some(result) = record.function_queries[320].get_mut(&__args[..]) { if !__cu && *result.multiplicity == G::ZERO { aiur_fn_320(__args, record, io_buffer, false)? } else { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_320] = unsafe { *(result.output.as_ptr() as *const [G; OUT_320]) }; __ret } } else { aiur_fn_320(__args, record, io_buffer, __cu)? } }; let __v_11: G = __r_arr[0]; - let __ret: [G; OUT_453] = [__v_11]; - if let Some(result) = record.function_queries[453].get_mut(&inp[..]) { debug_assert_eq!(result.output, &__ret[..]); if !unconstrained { *result.multiplicity += G::ONE; } } else { record.function_queries[453].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained)); }; + let __ret: [G; OUT_449] = [__v_11]; + if let Some(result) = record.function_queries[449].get_mut(&inp[..]) { debug_assert_eq!(result.output, &__ret[..]); if !unconstrained { *result.multiplicity += G::ONE; } } else { record.function_queries[449].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained)); }; return Ok(__ret); }, _ => { let __v_11: G = G::from_u64(0); - let __ret: [G; OUT_453] = [__v_11]; - if let Some(result) = record.function_queries[453].get_mut(&inp[..]) { debug_assert_eq!(result.output, &__ret[..]); if !unconstrained { *result.multiplicity += G::ONE; } } else { record.function_queries[453].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained)); }; + let __ret: [G; OUT_449] = [__v_11]; + if let Some(result) = record.function_queries[449].get_mut(&inp[..]) { debug_assert_eq!(result.output, &__ret[..]); if !unconstrained { *result.multiplicity += G::ONE; } } else { record.function_queries[449].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained)); }; return Ok(__ret); }, } @@ -40365,30 +40091,30 @@ fn aiur_fn_453( let __v_10: G = __loaded[3]; match __v_7.as_canonical_u64() { 4u64 => { - let __r_arr: [G; OUT_439] = { let __args: [G; IN_439] = [__v_4, __v_8, __v_2]; let __cu = unconstrained; if let Some(result) = record.function_queries[439].get_mut(&__args[..]) { if !__cu && *result.multiplicity == G::ZERO { aiur_fn_439(__args, record, io_buffer, false)? } else { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_439] = unsafe { *(result.output.as_ptr() as *const [G; OUT_439]) }; __ret } } else { aiur_fn_439(__args, record, io_buffer, __cu)? } }; + let __r_arr: [G; OUT_435] = { let __args: [G; IN_435] = [__v_4, __v_8, __v_2]; let __cu = unconstrained; if let Some(result) = record.function_queries[435].get_mut(&__args[..]) { if !__cu && *result.multiplicity == G::ZERO { aiur_fn_435(__args, record, io_buffer, false)? } else { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_435] = unsafe { *(result.output.as_ptr() as *const [G; OUT_435]) }; __ret } } else { aiur_fn_435(__args, record, io_buffer, __cu)? } }; let __v_11: G = __r_arr[0]; match __v_11.as_canonical_u64() { 1u64 => { let __v_12: G = G::from_u64(0); let __v_13: G = { let __values: [G; 3] = [__v_12, __v_4, __v_2]; let __mq = record.memory_queries.get_mut(&3).ok_or(ExecError::InvalidMemorySize(3))?; if let Some(result) = __mq.get_mut(&__values[..]) { if !unconstrained { *result.multiplicity += G::ONE; } result.output[0] } else { let __ptr = G::from_usize(__mq.len()); __mq.insert(&__values[..], &[__ptr], G::from_bool(!unconstrained)); __ptr } }; - let __r_arr: [G; OUT_439] = { let __args: [G; IN_439] = [__v_5, __v_9, __v_13]; let __cu = unconstrained; if let Some(result) = record.function_queries[439].get_mut(&__args[..]) { if !__cu && *result.multiplicity == G::ZERO { aiur_fn_439(__args, record, io_buffer, false)? } else { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_439] = unsafe { *(result.output.as_ptr() as *const [G; OUT_439]) }; __ret } } else { aiur_fn_439(__args, record, io_buffer, __cu)? } }; + let __r_arr: [G; OUT_435] = { let __args: [G; IN_435] = [__v_5, __v_9, __v_13]; let __cu = unconstrained; if let Some(result) = record.function_queries[435].get_mut(&__args[..]) { if !__cu && *result.multiplicity == G::ZERO { aiur_fn_435(__args, record, io_buffer, false)? } else { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_435] = unsafe { *(result.output.as_ptr() as *const [G; OUT_435]) }; __ret } } else { aiur_fn_435(__args, record, io_buffer, __cu)? } }; let __v_14: G = __r_arr[0]; - let __ret: [G; OUT_453] = [__v_14]; - if let Some(result) = record.function_queries[453].get_mut(&inp[..]) { debug_assert_eq!(result.output, &__ret[..]); if !unconstrained { *result.multiplicity += G::ONE; } } else { record.function_queries[453].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained)); }; + let __ret: [G; OUT_449] = [__v_14]; + if let Some(result) = record.function_queries[449].get_mut(&inp[..]) { debug_assert_eq!(result.output, &__ret[..]); if !unconstrained { *result.multiplicity += G::ONE; } } else { record.function_queries[449].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained)); }; return Ok(__ret); }, _ => { let __v_12: G = G::from_u64(0); - let __ret: [G; OUT_453] = [__v_12]; - if let Some(result) = record.function_queries[453].get_mut(&inp[..]) { debug_assert_eq!(result.output, &__ret[..]); if !unconstrained { *result.multiplicity += G::ONE; } } else { record.function_queries[453].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained)); }; + let __ret: [G; OUT_449] = [__v_12]; + if let Some(result) = record.function_queries[449].get_mut(&inp[..]) { debug_assert_eq!(result.output, &__ret[..]); if !unconstrained { *result.multiplicity += G::ONE; } } else { record.function_queries[449].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained)); }; return Ok(__ret); }, } }, _ => { let __v_11: G = G::from_u64(0); - let __ret: [G; OUT_453] = [__v_11]; - if let Some(result) = record.function_queries[453].get_mut(&inp[..]) { debug_assert_eq!(result.output, &__ret[..]); if !unconstrained { *result.multiplicity += G::ONE; } } else { record.function_queries[453].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained)); }; + let __ret: [G; OUT_449] = [__v_11]; + if let Some(result) = record.function_queries[449].get_mut(&inp[..]) { debug_assert_eq!(result.output, &__ret[..]); if !unconstrained { *result.multiplicity += G::ONE; } } else { record.function_queries[449].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained)); }; return Ok(__ret); }, } @@ -40401,53 +40127,53 @@ fn aiur_fn_453( let __v_10: G = __loaded[3]; match __v_7.as_canonical_u64() { 5u64 => { - let __r_arr: [G; OUT_439] = { let __args: [G; IN_439] = [__v_4, __v_8, __v_2]; let __cu = unconstrained; if let Some(result) = record.function_queries[439].get_mut(&__args[..]) { if !__cu && *result.multiplicity == G::ZERO { aiur_fn_439(__args, record, io_buffer, false)? } else { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_439] = unsafe { *(result.output.as_ptr() as *const [G; OUT_439]) }; __ret } } else { aiur_fn_439(__args, record, io_buffer, __cu)? } }; + let __r_arr: [G; OUT_435] = { let __args: [G; IN_435] = [__v_4, __v_8, __v_2]; let __cu = unconstrained; if let Some(result) = record.function_queries[435].get_mut(&__args[..]) { if !__cu && *result.multiplicity == G::ZERO { aiur_fn_435(__args, record, io_buffer, false)? } else { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_435] = unsafe { *(result.output.as_ptr() as *const [G; OUT_435]) }; __ret } } else { aiur_fn_435(__args, record, io_buffer, __cu)? } }; let __v_11: G = __r_arr[0]; match __v_11.as_canonical_u64() { 1u64 => { let __v_12: G = G::from_u64(0); let __v_13: G = { let __values: [G; 3] = [__v_12, __v_4, __v_2]; let __mq = record.memory_queries.get_mut(&3).ok_or(ExecError::InvalidMemorySize(3))?; if let Some(result) = __mq.get_mut(&__values[..]) { if !unconstrained { *result.multiplicity += G::ONE; } result.output[0] } else { let __ptr = G::from_usize(__mq.len()); __mq.insert(&__values[..], &[__ptr], G::from_bool(!unconstrained)); __ptr } }; - let __r_arr: [G; OUT_439] = { let __args: [G; IN_439] = [__v_5, __v_9, __v_13]; let __cu = unconstrained; if let Some(result) = record.function_queries[439].get_mut(&__args[..]) { if !__cu && *result.multiplicity == G::ZERO { aiur_fn_439(__args, record, io_buffer, false)? } else { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_439] = unsafe { *(result.output.as_ptr() as *const [G; OUT_439]) }; __ret } } else { aiur_fn_439(__args, record, io_buffer, __cu)? } }; + let __r_arr: [G; OUT_435] = { let __args: [G; IN_435] = [__v_5, __v_9, __v_13]; let __cu = unconstrained; if let Some(result) = record.function_queries[435].get_mut(&__args[..]) { if !__cu && *result.multiplicity == G::ZERO { aiur_fn_435(__args, record, io_buffer, false)? } else { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_435] = unsafe { *(result.output.as_ptr() as *const [G; OUT_435]) }; __ret } } else { aiur_fn_435(__args, record, io_buffer, __cu)? } }; let __v_14: G = __r_arr[0]; - let __ret: [G; OUT_453] = [__v_14]; - if let Some(result) = record.function_queries[453].get_mut(&inp[..]) { debug_assert_eq!(result.output, &__ret[..]); if !unconstrained { *result.multiplicity += G::ONE; } } else { record.function_queries[453].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained)); }; + let __ret: [G; OUT_449] = [__v_14]; + if let Some(result) = record.function_queries[449].get_mut(&inp[..]) { debug_assert_eq!(result.output, &__ret[..]); if !unconstrained { *result.multiplicity += G::ONE; } } else { record.function_queries[449].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained)); }; return Ok(__ret); }, _ => { let __v_12: G = G::from_u64(0); - let __ret: [G; OUT_453] = [__v_12]; - if let Some(result) = record.function_queries[453].get_mut(&inp[..]) { debug_assert_eq!(result.output, &__ret[..]); if !unconstrained { *result.multiplicity += G::ONE; } } else { record.function_queries[453].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained)); }; + let __ret: [G; OUT_449] = [__v_12]; + if let Some(result) = record.function_queries[449].get_mut(&inp[..]) { debug_assert_eq!(result.output, &__ret[..]); if !unconstrained { *result.multiplicity += G::ONE; } } else { record.function_queries[449].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained)); }; return Ok(__ret); }, } }, _ => { let __v_11: G = G::from_u64(0); - let __ret: [G; OUT_453] = [__v_11]; - if let Some(result) = record.function_queries[453].get_mut(&inp[..]) { debug_assert_eq!(result.output, &__ret[..]); if !unconstrained { *result.multiplicity += G::ONE; } } else { record.function_queries[453].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained)); }; + let __ret: [G; OUT_449] = [__v_11]; + if let Some(result) = record.function_queries[449].get_mut(&inp[..]) { debug_assert_eq!(result.output, &__ret[..]); if !unconstrained { *result.multiplicity += G::ONE; } } else { record.function_queries[449].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained)); }; return Ok(__ret); }, } }, _ => { let __v_7: G = G::from_u64(0); - let __ret: [G; OUT_453] = [__v_7]; - if let Some(result) = record.function_queries[453].get_mut(&inp[..]) { debug_assert_eq!(result.output, &__ret[..]); if !unconstrained { *result.multiplicity += G::ONE; } } else { record.function_queries[453].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained)); }; + let __ret: [G; OUT_449] = [__v_7]; + if let Some(result) = record.function_queries[449].get_mut(&inp[..]) { debug_assert_eq!(result.output, &__ret[..]); if !unconstrained { *result.multiplicity += G::ONE; } } else { record.function_queries[449].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained)); }; return Ok(__ret); }, } }) } -const INPUT_SIZE_454: usize = 5; -const IN_454: usize = 5; -const OUT_454: usize = 1; -fn aiur_fn_454( - inp: [G; IN_454], +const INPUT_SIZE_450: usize = 5; +const IN_450: usize = 5; +const OUT_450: usize = 1; +fn aiur_fn_450( + inp: [G; IN_450], record: &mut QueryRecord, io_buffer: &mut IOBuffer, unconstrained: bool, -) -> Result<[G; OUT_454], ExecError> { +) -> Result<[G; OUT_450], ExecError> { stacker::maybe_grow(64 * 1024, 4 * 1024 * 1024, || { let __v_0: G = inp[0]; let __v_1: G = inp[1]; @@ -40458,78 +40184,78 @@ fn aiur_fn_454( match __v_5.as_canonical_u64() { 0u64 => { let __v_6: G = G::from_u64(1); - let __ret: [G; OUT_454] = [__v_6]; - if let Some(result) = record.function_queries[454].get_mut(&inp[..]) { debug_assert_eq!(result.output, &__ret[..]); if !unconstrained { *result.multiplicity += G::ONE; } } else { record.function_queries[454].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained)); }; + let __ret: [G; OUT_450] = [__v_6]; + if let Some(result) = record.function_queries[450].get_mut(&inp[..]) { debug_assert_eq!(result.output, &__ret[..]); if !unconstrained { *result.multiplicity += G::ONE; } } else { record.function_queries[450].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained)); }; return Ok(__ret); }, _ => { - let __r_arr: [G; OUT_468] = { let __args: [G; IN_468] = [__v_2, __v_3, __v_4]; let __cu = unconstrained; if let Some(result) = record.function_queries[468].get_mut(&__args[..]) { if !__cu && *result.multiplicity == G::ZERO { aiur_fn_468(__args, record, io_buffer, false)? } else { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_468] = unsafe { *(result.output.as_ptr() as *const [G; OUT_468]) }; __ret } } else { aiur_fn_468(__args, record, io_buffer, __cu)? } }; + let __r_arr: [G; OUT_464] = { let __args: [G; IN_464] = [__v_2, __v_3, __v_4]; let __cu = unconstrained; if let Some(result) = record.function_queries[464].get_mut(&__args[..]) { if !__cu && *result.multiplicity == G::ZERO { aiur_fn_464(__args, record, io_buffer, false)? } else { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_464] = unsafe { *(result.output.as_ptr() as *const [G; OUT_464]) }; __ret } } else { aiur_fn_464(__args, record, io_buffer, __cu)? } }; let __v_6: G = __r_arr[0]; match __v_6.as_canonical_u64() { 1u64 => { let __v_7: G = G::from_u64(1); - let __ret: [G; OUT_454] = [__v_7]; - if let Some(result) = record.function_queries[454].get_mut(&inp[..]) { debug_assert_eq!(result.output, &__ret[..]); if !unconstrained { *result.multiplicity += G::ONE; } } else { record.function_queries[454].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained)); }; + let __ret: [G; OUT_450] = [__v_7]; + if let Some(result) = record.function_queries[450].get_mut(&inp[..]) { debug_assert_eq!(result.output, &__ret[..]); if !unconstrained { *result.multiplicity += G::ONE; } } else { record.function_queries[450].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained)); }; return Ok(__ret); }, _ => { - let __r_arr: [G; OUT_466] = { let __args: [G; IN_466] = [__v_2, __v_3, __v_4]; let __cu = unconstrained; if let Some(result) = record.function_queries[466].get_mut(&__args[..]) { if !__cu && *result.multiplicity == G::ZERO { aiur_fn_466(__args, record, io_buffer, false)? } else { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_466] = unsafe { *(result.output.as_ptr() as *const [G; OUT_466]) }; __ret } } else { aiur_fn_466(__args, record, io_buffer, __cu)? } }; + let __r_arr: [G; OUT_462] = { let __args: [G; IN_462] = [__v_2, __v_3, __v_4]; let __cu = unconstrained; if let Some(result) = record.function_queries[462].get_mut(&__args[..]) { if !__cu && *result.multiplicity == G::ZERO { aiur_fn_462(__args, record, io_buffer, false)? } else { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_462] = unsafe { *(result.output.as_ptr() as *const [G; OUT_462]) }; __ret } } else { aiur_fn_462(__args, record, io_buffer, __cu)? } }; let __v_7: G = __r_arr[0]; match __v_7.as_canonical_u64() { 1u64 => { let __v_8: G = G::from_u64(1); - let __ret: [G; OUT_454] = [__v_8]; - if let Some(result) = record.function_queries[454].get_mut(&inp[..]) { debug_assert_eq!(result.output, &__ret[..]); if !unconstrained { *result.multiplicity += G::ONE; } } else { record.function_queries[454].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained)); }; + let __ret: [G; OUT_450] = [__v_8]; + if let Some(result) = record.function_queries[450].get_mut(&inp[..]) { debug_assert_eq!(result.output, &__ret[..]); if !unconstrained { *result.multiplicity += G::ONE; } } else { record.function_queries[450].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained)); }; return Ok(__ret); }, _ => { - let __r_arr: [G; OUT_462] = { let __args: [G; IN_462] = [__v_2, __v_3, __v_4]; let __cu = unconstrained; if let Some(result) = record.function_queries[462].get_mut(&__args[..]) { if !__cu && *result.multiplicity == G::ZERO { aiur_fn_462(__args, record, io_buffer, false)? } else { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_462] = unsafe { *(result.output.as_ptr() as *const [G; OUT_462]) }; __ret } } else { aiur_fn_462(__args, record, io_buffer, __cu)? } }; + let __r_arr: [G; OUT_458] = { let __args: [G; IN_458] = [__v_2, __v_3, __v_4]; let __cu = unconstrained; if let Some(result) = record.function_queries[458].get_mut(&__args[..]) { if !__cu && *result.multiplicity == G::ZERO { aiur_fn_458(__args, record, io_buffer, false)? } else { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_458] = unsafe { *(result.output.as_ptr() as *const [G; OUT_458]) }; __ret } } else { aiur_fn_458(__args, record, io_buffer, __cu)? } }; let __v_8: G = __r_arr[0]; match __v_8.as_canonical_u64() { 1u64 => { let __v_9: G = G::from_u64(1); - let __ret: [G; OUT_454] = [__v_9]; - if let Some(result) = record.function_queries[454].get_mut(&inp[..]) { debug_assert_eq!(result.output, &__ret[..]); if !unconstrained { *result.multiplicity += G::ONE; } } else { record.function_queries[454].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained)); }; + let __ret: [G; OUT_450] = [__v_9]; + if let Some(result) = record.function_queries[450].get_mut(&inp[..]) { debug_assert_eq!(result.output, &__ret[..]); if !unconstrained { *result.multiplicity += G::ONE; } } else { record.function_queries[450].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained)); }; return Ok(__ret); }, _ => { - let __r_arr: [G; OUT_462] = { let __args: [G; IN_462] = [__v_3, __v_2, __v_4]; let __cu = unconstrained; if let Some(result) = record.function_queries[462].get_mut(&__args[..]) { if !__cu && *result.multiplicity == G::ZERO { aiur_fn_462(__args, record, io_buffer, false)? } else { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_462] = unsafe { *(result.output.as_ptr() as *const [G; OUT_462]) }; __ret } } else { aiur_fn_462(__args, record, io_buffer, __cu)? } }; + let __r_arr: [G; OUT_458] = { let __args: [G; IN_458] = [__v_3, __v_2, __v_4]; let __cu = unconstrained; if let Some(result) = record.function_queries[458].get_mut(&__args[..]) { if !__cu && *result.multiplicity == G::ZERO { aiur_fn_458(__args, record, io_buffer, false)? } else { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_458] = unsafe { *(result.output.as_ptr() as *const [G; OUT_458]) }; __ret } } else { aiur_fn_458(__args, record, io_buffer, __cu)? } }; let __v_9: G = __r_arr[0]; match __v_9.as_canonical_u64() { 1u64 => { let __v_10: G = G::from_u64(1); - let __ret: [G; OUT_454] = [__v_10]; - if let Some(result) = record.function_queries[454].get_mut(&inp[..]) { debug_assert_eq!(result.output, &__ret[..]); if !unconstrained { *result.multiplicity += G::ONE; } } else { record.function_queries[454].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained)); }; + let __ret: [G; OUT_450] = [__v_10]; + if let Some(result) = record.function_queries[450].get_mut(&inp[..]) { debug_assert_eq!(result.output, &__ret[..]); if !unconstrained { *result.multiplicity += G::ONE; } } else { record.function_queries[450].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained)); }; return Ok(__ret); }, _ => { - let __r_arr: [G; OUT_447] = { let __args: [G; IN_447] = [__v_2, __v_3, __v_4]; let __cu = unconstrained; if let Some(result) = record.function_queries[447].get_mut(&__args[..]) { if !__cu && *result.multiplicity == G::ZERO { aiur_fn_447(__args, record, io_buffer, false)? } else { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_447] = unsafe { *(result.output.as_ptr() as *const [G; OUT_447]) }; __ret } } else { aiur_fn_447(__args, record, io_buffer, __cu)? } }; + let __r_arr: [G; OUT_443] = { let __args: [G; IN_443] = [__v_2, __v_3, __v_4]; let __cu = unconstrained; if let Some(result) = record.function_queries[443].get_mut(&__args[..]) { if !__cu && *result.multiplicity == G::ZERO { aiur_fn_443(__args, record, io_buffer, false)? } else { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_443] = unsafe { *(result.output.as_ptr() as *const [G; OUT_443]) }; __ret } } else { aiur_fn_443(__args, record, io_buffer, __cu)? } }; let __v_10: G = __r_arr[0]; let __v_11: G = __r_arr[1]; match __v_10.as_canonical_u64() { 1u64 => { - let __ret: [G; OUT_454] = [__v_11]; - if let Some(result) = record.function_queries[454].get_mut(&inp[..]) { debug_assert_eq!(result.output, &__ret[..]); if !unconstrained { *result.multiplicity += G::ONE; } } else { record.function_queries[454].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained)); }; + let __ret: [G; OUT_450] = [__v_11]; + if let Some(result) = record.function_queries[450].get_mut(&inp[..]) { debug_assert_eq!(result.output, &__ret[..]); if !unconstrained { *result.multiplicity += G::ONE; } } else { record.function_queries[450].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained)); }; return Ok(__ret); }, _ => { let __v_12: G = G::from_u64(16); - let __r_arr: [G; OUT_473] = { let __args: [G; IN_473] = [__v_2, __v_3, __v_12, __v_4]; let __cu = unconstrained; if let Some(result) = record.function_queries[473].get_mut(&__args[..]) { if !__cu && *result.multiplicity == G::ZERO { aiur_fn_473(__args, record, io_buffer, false)? } else { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_473] = unsafe { *(result.output.as_ptr() as *const [G; OUT_473]) }; __ret } } else { aiur_fn_473(__args, record, io_buffer, __cu)? } }; + let __r_arr: [G; OUT_469] = { let __args: [G; IN_469] = [__v_2, __v_3, __v_12, __v_4]; let __cu = unconstrained; if let Some(result) = record.function_queries[469].get_mut(&__args[..]) { if !__cu && *result.multiplicity == G::ZERO { aiur_fn_469(__args, record, io_buffer, false)? } else { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_469] = unsafe { *(result.output.as_ptr() as *const [G; OUT_469]) }; __ret } } else { aiur_fn_469(__args, record, io_buffer, __cu)? } }; let __v_13: G = __r_arr[0]; let __v_14: G = __r_arr[1]; let __v_15: G = __r_arr[2]; match __v_13.as_canonical_u64() { 1u64 => { let __v_16: G = G::from_u64(1); - let __ret: [G; OUT_454] = [__v_16]; - if let Some(result) = record.function_queries[454].get_mut(&inp[..]) { debug_assert_eq!(result.output, &__ret[..]); if !unconstrained { *result.multiplicity += G::ONE; } } else { record.function_queries[454].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained)); }; + let __ret: [G; OUT_450] = [__v_16]; + if let Some(result) = record.function_queries[450].get_mut(&inp[..]) { debug_assert_eq!(result.output, &__ret[..]); if !unconstrained { *result.multiplicity += G::ONE; } } else { record.function_queries[450].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained)); }; return Ok(__ret); }, _ => { - let __r_arr: [G; OUT_455] = { let __args: [G; IN_455] = [__v_0, __v_1, __v_14, __v_15, __v_4]; let __cu = unconstrained; if let Some(result) = record.function_queries[455].get_mut(&__args[..]) { if !__cu && *result.multiplicity == G::ZERO { aiur_fn_455(__args, record, io_buffer, false)? } else { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_455] = unsafe { *(result.output.as_ptr() as *const [G; OUT_455]) }; __ret } } else { aiur_fn_455(__args, record, io_buffer, __cu)? } }; + let __r_arr: [G; OUT_451] = { let __args: [G; IN_451] = [__v_0, __v_1, __v_14, __v_15, __v_4]; let __cu = unconstrained; if let Some(result) = record.function_queries[451].get_mut(&__args[..]) { if !__cu && *result.multiplicity == G::ZERO { aiur_fn_451(__args, record, io_buffer, false)? } else { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_451] = unsafe { *(result.output.as_ptr() as *const [G; OUT_451]) }; __ret } } else { aiur_fn_451(__args, record, io_buffer, __cu)? } }; let __v_16: G = __r_arr[0]; - let __ret: [G; OUT_454] = [__v_16]; - if let Some(result) = record.function_queries[454].get_mut(&inp[..]) { debug_assert_eq!(result.output, &__ret[..]); if !unconstrained { *result.multiplicity += G::ONE; } } else { record.function_queries[454].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained)); }; + let __ret: [G; OUT_450] = [__v_16]; + if let Some(result) = record.function_queries[450].get_mut(&inp[..]) { debug_assert_eq!(result.output, &__ret[..]); if !unconstrained { *result.multiplicity += G::ONE; } } else { record.function_queries[450].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained)); }; return Ok(__ret); }, } @@ -40548,15 +40274,15 @@ fn aiur_fn_454( }) } -const INPUT_SIZE_455: usize = 5; -const IN_455: usize = 5; -const OUT_455: usize = 1; -fn aiur_fn_455( - inp: [G; IN_455], +const INPUT_SIZE_451: usize = 5; +const IN_451: usize = 5; +const OUT_451: usize = 1; +fn aiur_fn_451( + inp: [G; IN_451], record: &mut QueryRecord, io_buffer: &mut IOBuffer, unconstrained: bool, -) -> Result<[G; OUT_455], ExecError> { +) -> Result<[G; OUT_451], ExecError> { stacker::maybe_grow(64 * 1024, 4 * 1024 * 1024, || { let __v_0: G = inp[0]; let __v_1: G = inp[1]; @@ -40564,31 +40290,31 @@ fn aiur_fn_455( let __v_3: G = inp[3]; let __v_4: G = inp[4]; let __v_5: G = G::from_u64(8); - let __r_arr: [G; OUT_459] = { let __args: [G; IN_459] = [__v_2, __v_3, __v_5, __v_4]; let __cu = unconstrained; if let Some(result) = record.function_queries[459].get_mut(&__args[..]) { if !__cu && *result.multiplicity == G::ZERO { aiur_fn_459(__args, record, io_buffer, false)? } else { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_459] = unsafe { *(result.output.as_ptr() as *const [G; OUT_459]) }; __ret } } else { aiur_fn_459(__args, record, io_buffer, __cu)? } }; + let __r_arr: [G; OUT_455] = { let __args: [G; IN_455] = [__v_2, __v_3, __v_5, __v_4]; let __cu = unconstrained; if let Some(result) = record.function_queries[455].get_mut(&__args[..]) { if !__cu && *result.multiplicity == G::ZERO { aiur_fn_455(__args, record, io_buffer, false)? } else { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_455] = unsafe { *(result.output.as_ptr() as *const [G; OUT_455]) }; __ret } } else { aiur_fn_455(__args, record, io_buffer, __cu)? } }; let __v_6: G = __r_arr[0]; let __v_7: G = __r_arr[1]; match __v_6.as_canonical_u64() { 1u64 => { let __v_8: G = G::from_u64(1); - let __ret: [G; OUT_455] = [__v_8]; - if let Some(result) = record.function_queries[455].get_mut(&inp[..]) { debug_assert_eq!(result.output, &__ret[..]); if !unconstrained { *result.multiplicity += G::ONE; } } else { record.function_queries[455].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained)); }; + let __ret: [G; OUT_451] = [__v_8]; + if let Some(result) = record.function_queries[451].get_mut(&inp[..]) { debug_assert_eq!(result.output, &__ret[..]); if !unconstrained { *result.multiplicity += G::ONE; } } else { record.function_queries[451].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained)); }; return Ok(__ret); }, _ => { - let __r_arr: [G; OUT_457] = { let __args: [G; IN_457] = [__v_2, __v_3, __v_4]; let __cu = unconstrained; if let Some(result) = record.function_queries[457].get_mut(&__args[..]) { if !__cu && *result.multiplicity == G::ZERO { aiur_fn_457(__args, record, io_buffer, false)? } else { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_457] = unsafe { *(result.output.as_ptr() as *const [G; OUT_457]) }; __ret } } else { aiur_fn_457(__args, record, io_buffer, __cu)? } }; + let __r_arr: [G; OUT_453] = { let __args: [G; IN_453] = [__v_2, __v_3, __v_4]; let __cu = unconstrained; if let Some(result) = record.function_queries[453].get_mut(&__args[..]) { if !__cu && *result.multiplicity == G::ZERO { aiur_fn_453(__args, record, io_buffer, false)? } else { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_453] = unsafe { *(result.output.as_ptr() as *const [G; OUT_453]) }; __ret } } else { aiur_fn_453(__args, record, io_buffer, __cu)? } }; let __v_8: G = __r_arr[0]; match __v_8.as_canonical_u64() { 1u64 => { let __v_9: G = G::from_u64(1); - let __ret: [G; OUT_455] = [__v_9]; - if let Some(result) = record.function_queries[455].get_mut(&inp[..]) { debug_assert_eq!(result.output, &__ret[..]); if !unconstrained { *result.multiplicity += G::ONE; } } else { record.function_queries[455].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained)); }; + let __ret: [G; OUT_451] = [__v_9]; + if let Some(result) = record.function_queries[451].get_mut(&inp[..]) { debug_assert_eq!(result.output, &__ret[..]); if !unconstrained { *result.multiplicity += G::ONE; } } else { record.function_queries[451].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained)); }; return Ok(__ret); }, _ => { - let __r_arr: [G; OUT_461] = { let __args: [G; IN_461] = [__v_0, __v_1, __v_4]; let __cu = unconstrained; if let Some(result) = record.function_queries[461].get_mut(&__args[..]) { if !__cu && *result.multiplicity == G::ZERO { aiur_fn_461(__args, record, io_buffer, false)? } else { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_461] = unsafe { *(result.output.as_ptr() as *const [G; OUT_461]) }; __ret } } else { aiur_fn_461(__args, record, io_buffer, __cu)? } }; + let __r_arr: [G; OUT_457] = { let __args: [G; IN_457] = [__v_0, __v_1, __v_4]; let __cu = unconstrained; if let Some(result) = record.function_queries[457].get_mut(&__args[..]) { if !__cu && *result.multiplicity == G::ZERO { aiur_fn_457(__args, record, io_buffer, false)? } else { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_457] = unsafe { *(result.output.as_ptr() as *const [G; OUT_457]) }; __ret } } else { aiur_fn_457(__args, record, io_buffer, __cu)? } }; let __v_9: G = __r_arr[0]; - let __ret: [G; OUT_455] = [__v_9]; - if let Some(result) = record.function_queries[455].get_mut(&inp[..]) { debug_assert_eq!(result.output, &__ret[..]); if !unconstrained { *result.multiplicity += G::ONE; } } else { record.function_queries[455].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained)); }; + let __ret: [G; OUT_451] = [__v_9]; + if let Some(result) = record.function_queries[451].get_mut(&inp[..]) { debug_assert_eq!(result.output, &__ret[..]); if !unconstrained { *result.multiplicity += G::ONE; } } else { record.function_queries[451].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained)); }; return Ok(__ret); }, } @@ -40597,15 +40323,15 @@ fn aiur_fn_455( }) } -const INPUT_SIZE_456: usize = 3; -const IN_456: usize = 3; -const OUT_456: usize = 1; -fn aiur_fn_456( - inp: [G; IN_456], +const INPUT_SIZE_452: usize = 3; +const IN_452: usize = 3; +const OUT_452: usize = 1; +fn aiur_fn_452( + inp: [G; IN_452], record: &mut QueryRecord, io_buffer: &mut IOBuffer, unconstrained: bool, -) -> Result<[G; OUT_456], ExecError> { +) -> Result<[G; OUT_452], ExecError> { stacker::maybe_grow(64 * 1024, 4 * 1024 * 1024, || { let __v_0: G = inp[0]; let __v_1: G = inp[1]; @@ -40616,19 +40342,19 @@ fn aiur_fn_456( let __r_arr: [G; OUT_111] = { let __args: [G; IN_111] = [__v_1]; let __cu = unconstrained; if let Some(result) = record.function_queries[111].get_mut(&__args[..]) { if !__cu && *result.multiplicity == G::ZERO { aiur_fn_111(__args, record, io_buffer, false)? } else { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_111] = unsafe { *(result.output.as_ptr() as *const [G; OUT_111]) }; __ret } } else { aiur_fn_111(__args, record, io_buffer, __cu)? } }; let __v_5: G = __r_arr[0]; let __v_6: G = __r_arr[1]; - let __r_arr: [G; OUT_764] = { let __args: [G; IN_764] = [__v_4]; let __cu = unconstrained; if let Some(result) = record.function_queries[764].get_mut(&__args[..]) { if !__cu && *result.multiplicity == G::ZERO { aiur_fn_764(__args, record, io_buffer, false)? } else { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_764] = unsafe { *(result.output.as_ptr() as *const [G; OUT_764]) }; __ret } } else { aiur_fn_764(__args, record, io_buffer, __cu)? } }; + let __r_arr: [G; OUT_760] = { let __args: [G; IN_760] = [__v_4]; let __cu = unconstrained; if let Some(result) = record.function_queries[760].get_mut(&__args[..]) { if !__cu && *result.multiplicity == G::ZERO { aiur_fn_760(__args, record, io_buffer, false)? } else { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_760] = unsafe { *(result.output.as_ptr() as *const [G; OUT_760]) }; __ret } } else { aiur_fn_760(__args, record, io_buffer, __cu)? } }; let __v_7: G = __r_arr[0]; match __v_7.as_canonical_u64() { 0u64 => { let __v_8: G = G::from_u64(0); - let __ret: [G; OUT_456] = [__v_8]; - if let Some(result) = record.function_queries[456].get_mut(&inp[..]) { debug_assert_eq!(result.output, &__ret[..]); if !unconstrained { *result.multiplicity += G::ONE; } } else { record.function_queries[456].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained)); }; + let __ret: [G; OUT_452] = [__v_8]; + if let Some(result) = record.function_queries[452].get_mut(&inp[..]) { debug_assert_eq!(result.output, &__ret[..]); if !unconstrained { *result.multiplicity += G::ONE; } } else { record.function_queries[452].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained)); }; return Ok(__ret); }, _ => { - let __r_arr: [G; OUT_764] = { let __args: [G; IN_764] = [__v_4]; let __cu = unconstrained; if let Some(result) = record.function_queries[764].get_mut(&__args[..]) { if !__cu && *result.multiplicity == G::ZERO { aiur_fn_764(__args, record, io_buffer, false)? } else { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_764] = unsafe { *(result.output.as_ptr() as *const [G; OUT_764]) }; __ret } } else { aiur_fn_764(__args, record, io_buffer, __cu)? } }; + let __r_arr: [G; OUT_760] = { let __args: [G; IN_760] = [__v_4]; let __cu = unconstrained; if let Some(result) = record.function_queries[760].get_mut(&__args[..]) { if !__cu && *result.multiplicity == G::ZERO { aiur_fn_760(__args, record, io_buffer, false)? } else { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_760] = unsafe { *(result.output.as_ptr() as *const [G; OUT_760]) }; __ret } } else { aiur_fn_760(__args, record, io_buffer, __cu)? } }; let __v_8: G = __r_arr[0]; - let __r_arr: [G; OUT_764] = { let __args: [G; IN_764] = [__v_6]; let __cu = unconstrained; if let Some(result) = record.function_queries[764].get_mut(&__args[..]) { if !__cu && *result.multiplicity == G::ZERO { aiur_fn_764(__args, record, io_buffer, false)? } else { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_764] = unsafe { *(result.output.as_ptr() as *const [G; OUT_764]) }; __ret } } else { aiur_fn_764(__args, record, io_buffer, __cu)? } }; + let __r_arr: [G; OUT_760] = { let __args: [G; IN_760] = [__v_6]; let __cu = unconstrained; if let Some(result) = record.function_queries[760].get_mut(&__args[..]) { if !__cu && *result.multiplicity == G::ZERO { aiur_fn_760(__args, record, io_buffer, false)? } else { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_760] = unsafe { *(result.output.as_ptr() as *const [G; OUT_760]) }; __ret } } else { aiur_fn_760(__args, record, io_buffer, __cu)? } }; let __v_9: G = __r_arr[0]; let __v_10: G = (__v_8 - __v_9); match __v_10.as_canonical_u64() { @@ -40657,40 +40383,40 @@ fn aiur_fn_456( let __v_25: G = (__v_19 * __v_24); match __v_25.as_canonical_u64() { 1u64 => { - let __r_arr: [G; OUT_444] = { let __args: [G; IN_444] = [__v_4, __v_6, __v_2]; let __cu = unconstrained; if let Some(result) = record.function_queries[444].get_mut(&__args[..]) { if !__cu && *result.multiplicity == G::ZERO { aiur_fn_444(__args, record, io_buffer, false)? } else { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_444] = unsafe { *(result.output.as_ptr() as *const [G; OUT_444]) }; __ret } } else { aiur_fn_444(__args, record, io_buffer, __cu)? } }; + let __r_arr: [G; OUT_440] = { let __args: [G; IN_440] = [__v_4, __v_6, __v_2]; let __cu = unconstrained; if let Some(result) = record.function_queries[440].get_mut(&__args[..]) { if !__cu && *result.multiplicity == G::ZERO { aiur_fn_440(__args, record, io_buffer, false)? } else { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_440] = unsafe { *(result.output.as_ptr() as *const [G; OUT_440]) }; __ret } } else { aiur_fn_440(__args, record, io_buffer, __cu)? } }; let __v_26: G = __r_arr[0]; - let __ret: [G; OUT_456] = [__v_26]; - if let Some(result) = record.function_queries[456].get_mut(&inp[..]) { debug_assert_eq!(result.output, &__ret[..]); if !unconstrained { *result.multiplicity += G::ONE; } } else { record.function_queries[456].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained)); }; + let __ret: [G; OUT_452] = [__v_26]; + if let Some(result) = record.function_queries[452].get_mut(&inp[..]) { debug_assert_eq!(result.output, &__ret[..]); if !unconstrained { *result.multiplicity += G::ONE; } } else { record.function_queries[452].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained)); }; return Ok(__ret); }, _ => { let __v_26: G = G::from_u64(0); - let __ret: [G; OUT_456] = [__v_26]; - if let Some(result) = record.function_queries[456].get_mut(&inp[..]) { debug_assert_eq!(result.output, &__ret[..]); if !unconstrained { *result.multiplicity += G::ONE; } } else { record.function_queries[456].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained)); }; + let __ret: [G; OUT_452] = [__v_26]; + if let Some(result) = record.function_queries[452].get_mut(&inp[..]) { debug_assert_eq!(result.output, &__ret[..]); if !unconstrained { *result.multiplicity += G::ONE; } } else { record.function_queries[452].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained)); }; return Ok(__ret); }, } }, _ => { let __v_19: G = G::from_u64(0); - let __ret: [G; OUT_456] = [__v_19]; - if let Some(result) = record.function_queries[456].get_mut(&inp[..]) { debug_assert_eq!(result.output, &__ret[..]); if !unconstrained { *result.multiplicity += G::ONE; } } else { record.function_queries[456].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained)); }; + let __ret: [G; OUT_452] = [__v_19]; + if let Some(result) = record.function_queries[452].get_mut(&inp[..]) { debug_assert_eq!(result.output, &__ret[..]); if !unconstrained { *result.multiplicity += G::ONE; } } else { record.function_queries[452].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained)); }; return Ok(__ret); }, } }, _ => { let __v_15: G = G::from_u64(0); - let __ret: [G; OUT_456] = [__v_15]; - if let Some(result) = record.function_queries[456].get_mut(&inp[..]) { debug_assert_eq!(result.output, &__ret[..]); if !unconstrained { *result.multiplicity += G::ONE; } } else { record.function_queries[456].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained)); }; + let __ret: [G; OUT_452] = [__v_15]; + if let Some(result) = record.function_queries[452].get_mut(&inp[..]) { debug_assert_eq!(result.output, &__ret[..]); if !unconstrained { *result.multiplicity += G::ONE; } } else { record.function_queries[452].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained)); }; return Ok(__ret); }, } }, _ => { let __v_11: G = G::from_u64(0); - let __ret: [G; OUT_456] = [__v_11]; - if let Some(result) = record.function_queries[456].get_mut(&inp[..]) { debug_assert_eq!(result.output, &__ret[..]); if !unconstrained { *result.multiplicity += G::ONE; } } else { record.function_queries[456].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained)); }; + let __ret: [G; OUT_452] = [__v_11]; + if let Some(result) = record.function_queries[452].get_mut(&inp[..]) { debug_assert_eq!(result.output, &__ret[..]); if !unconstrained { *result.multiplicity += G::ONE; } } else { record.function_queries[452].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained)); }; return Ok(__ret); }, } @@ -40699,45 +40425,45 @@ fn aiur_fn_456( }) } -const INPUT_SIZE_457: usize = 3; -const IN_457: usize = 3; -const OUT_457: usize = 1; -fn aiur_fn_457( - inp: [G; IN_457], +const INPUT_SIZE_453: usize = 3; +const IN_453: usize = 3; +const OUT_453: usize = 1; +fn aiur_fn_453( + inp: [G; IN_453], record: &mut QueryRecord, io_buffer: &mut IOBuffer, unconstrained: bool, -) -> Result<[G; OUT_457], ExecError> { +) -> Result<[G; OUT_453], ExecError> { stacker::maybe_grow(64 * 1024, 4 * 1024 * 1024, || { let __v_0: G = inp[0]; let __v_1: G = inp[1]; let __v_2: G = inp[2]; let __v_3: G = G::from_u64(8); - let __r_arr: [G; OUT_459] = { let __args: [G; IN_459] = [__v_0, __v_1, __v_3, __v_2]; let __cu = unconstrained; if let Some(result) = record.function_queries[459].get_mut(&__args[..]) { if !__cu && *result.multiplicity == G::ZERO { aiur_fn_459(__args, record, io_buffer, false)? } else { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_459] = unsafe { *(result.output.as_ptr() as *const [G; OUT_459]) }; __ret } } else { aiur_fn_459(__args, record, io_buffer, __cu)? } }; + let __r_arr: [G; OUT_455] = { let __args: [G; IN_455] = [__v_0, __v_1, __v_3, __v_2]; let __cu = unconstrained; if let Some(result) = record.function_queries[455].get_mut(&__args[..]) { if !__cu && *result.multiplicity == G::ZERO { aiur_fn_455(__args, record, io_buffer, false)? } else { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_455] = unsafe { *(result.output.as_ptr() as *const [G; OUT_455]) }; __ret } } else { aiur_fn_455(__args, record, io_buffer, __cu)? } }; let __v_4: G = __r_arr[0]; let __v_5: G = __r_arr[1]; match __v_4.as_canonical_u64() { 1u64 => { let __v_6: G = G::from_u64(1); - let __ret: [G; OUT_457] = [__v_6]; - if let Some(result) = record.function_queries[457].get_mut(&inp[..]) { debug_assert_eq!(result.output, &__ret[..]); if !unconstrained { *result.multiplicity += G::ONE; } } else { record.function_queries[457].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained)); }; + let __ret: [G; OUT_453] = [__v_6]; + if let Some(result) = record.function_queries[453].get_mut(&inp[..]) { debug_assert_eq!(result.output, &__ret[..]); if !unconstrained { *result.multiplicity += G::ONE; } } else { record.function_queries[453].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained)); }; return Ok(__ret); }, _ => { - let __r_arr: [G; OUT_456] = { let __args: [G; IN_456] = [__v_0, __v_1, __v_2]; let __cu = unconstrained; if let Some(result) = record.function_queries[456].get_mut(&__args[..]) { if !__cu && *result.multiplicity == G::ZERO { aiur_fn_456(__args, record, io_buffer, false)? } else { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_456] = unsafe { *(result.output.as_ptr() as *const [G; OUT_456]) }; __ret } } else { aiur_fn_456(__args, record, io_buffer, __cu)? } }; + let __r_arr: [G; OUT_452] = { let __args: [G; IN_452] = [__v_0, __v_1, __v_2]; let __cu = unconstrained; if let Some(result) = record.function_queries[452].get_mut(&__args[..]) { if !__cu && *result.multiplicity == G::ZERO { aiur_fn_452(__args, record, io_buffer, false)? } else { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_452] = unsafe { *(result.output.as_ptr() as *const [G; OUT_452]) }; __ret } } else { aiur_fn_452(__args, record, io_buffer, __cu)? } }; let __v_6: G = __r_arr[0]; match __v_6.as_canonical_u64() { 1u64 => { let __v_7: G = G::from_u64(1); - let __ret: [G; OUT_457] = [__v_7]; - if let Some(result) = record.function_queries[457].get_mut(&inp[..]) { debug_assert_eq!(result.output, &__ret[..]); if !unconstrained { *result.multiplicity += G::ONE; } } else { record.function_queries[457].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained)); }; + let __ret: [G; OUT_453] = [__v_7]; + if let Some(result) = record.function_queries[453].get_mut(&inp[..]) { debug_assert_eq!(result.output, &__ret[..]); if !unconstrained { *result.multiplicity += G::ONE; } } else { record.function_queries[453].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained)); }; return Ok(__ret); }, _ => { - let __r_arr: [G; OUT_458] = { let __args: [G; IN_458] = [__v_0, __v_1, __v_2]; let __cu = unconstrained; if let Some(result) = record.function_queries[458].get_mut(&__args[..]) { if !__cu && *result.multiplicity == G::ZERO { aiur_fn_458(__args, record, io_buffer, false)? } else { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_458] = unsafe { *(result.output.as_ptr() as *const [G; OUT_458]) }; __ret } } else { aiur_fn_458(__args, record, io_buffer, __cu)? } }; + let __r_arr: [G; OUT_454] = { let __args: [G; IN_454] = [__v_0, __v_1, __v_2]; let __cu = unconstrained; if let Some(result) = record.function_queries[454].get_mut(&__args[..]) { if !__cu && *result.multiplicity == G::ZERO { aiur_fn_454(__args, record, io_buffer, false)? } else { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_454] = unsafe { *(result.output.as_ptr() as *const [G; OUT_454]) }; __ret } } else { aiur_fn_454(__args, record, io_buffer, __cu)? } }; let __v_7: G = __r_arr[0]; - let __ret: [G; OUT_457] = [__v_7]; - if let Some(result) = record.function_queries[457].get_mut(&inp[..]) { debug_assert_eq!(result.output, &__ret[..]); if !unconstrained { *result.multiplicity += G::ONE; } } else { record.function_queries[457].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained)); }; + let __ret: [G; OUT_453] = [__v_7]; + if let Some(result) = record.function_queries[453].get_mut(&inp[..]) { debug_assert_eq!(result.output, &__ret[..]); if !unconstrained { *result.multiplicity += G::ONE; } } else { record.function_queries[453].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained)); }; return Ok(__ret); }, } @@ -40746,15 +40472,15 @@ fn aiur_fn_457( }) } -const INPUT_SIZE_458: usize = 3; -const IN_458: usize = 3; -const OUT_458: usize = 1; -fn aiur_fn_458( - inp: [G; IN_458], +const INPUT_SIZE_454: usize = 3; +const IN_454: usize = 3; +const OUT_454: usize = 1; +fn aiur_fn_454( + inp: [G; IN_454], record: &mut QueryRecord, io_buffer: &mut IOBuffer, unconstrained: bool, -) -> Result<[G; OUT_458], ExecError> { +) -> Result<[G; OUT_454], ExecError> { stacker::maybe_grow(64 * 1024, 4 * 1024 * 1024, || { let __v_0: G = inp[0]; let __v_1: G = inp[1]; @@ -40773,51 +40499,51 @@ fn aiur_fn_458( let __v_10: G = __loaded[3]; match __v_7.as_canonical_u64() { 3u64 => { - let __r_arr: [G; OUT_457] = { let __args: [G; IN_457] = [__v_4, __v_8, __v_2]; let __cu = unconstrained; if let Some(result) = record.function_queries[457].get_mut(&__args[..]) { if !__cu && *result.multiplicity == G::ZERO { aiur_fn_457(__args, record, io_buffer, false)? } else { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_457] = unsafe { *(result.output.as_ptr() as *const [G; OUT_457]) }; __ret } } else { aiur_fn_457(__args, record, io_buffer, __cu)? } }; + let __r_arr: [G; OUT_453] = { let __args: [G; IN_453] = [__v_4, __v_8, __v_2]; let __cu = unconstrained; if let Some(result) = record.function_queries[453].get_mut(&__args[..]) { if !__cu && *result.multiplicity == G::ZERO { aiur_fn_453(__args, record, io_buffer, false)? } else { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_453] = unsafe { *(result.output.as_ptr() as *const [G; OUT_453]) }; __ret } } else { aiur_fn_453(__args, record, io_buffer, __cu)? } }; let __v_11: G = __r_arr[0]; match __v_11.as_canonical_u64() { 1u64 => { - let __r_arr: [G; OUT_457] = { let __args: [G; IN_457] = [__v_5, __v_9, __v_2]; let __cu = unconstrained; if let Some(result) = record.function_queries[457].get_mut(&__args[..]) { if !__cu && *result.multiplicity == G::ZERO { aiur_fn_457(__args, record, io_buffer, false)? } else { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_457] = unsafe { *(result.output.as_ptr() as *const [G; OUT_457]) }; __ret } } else { aiur_fn_457(__args, record, io_buffer, __cu)? } }; + let __r_arr: [G; OUT_453] = { let __args: [G; IN_453] = [__v_5, __v_9, __v_2]; let __cu = unconstrained; if let Some(result) = record.function_queries[453].get_mut(&__args[..]) { if !__cu && *result.multiplicity == G::ZERO { aiur_fn_453(__args, record, io_buffer, false)? } else { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_453] = unsafe { *(result.output.as_ptr() as *const [G; OUT_453]) }; __ret } } else { aiur_fn_453(__args, record, io_buffer, __cu)? } }; let __v_12: G = __r_arr[0]; - let __ret: [G; OUT_458] = [__v_12]; - if let Some(result) = record.function_queries[458].get_mut(&inp[..]) { debug_assert_eq!(result.output, &__ret[..]); if !unconstrained { *result.multiplicity += G::ONE; } } else { record.function_queries[458].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained)); }; + let __ret: [G; OUT_454] = [__v_12]; + if let Some(result) = record.function_queries[454].get_mut(&inp[..]) { debug_assert_eq!(result.output, &__ret[..]); if !unconstrained { *result.multiplicity += G::ONE; } } else { record.function_queries[454].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained)); }; return Ok(__ret); }, _ => { let __v_12: G = G::from_u64(0); - let __ret: [G; OUT_458] = [__v_12]; - if let Some(result) = record.function_queries[458].get_mut(&inp[..]) { debug_assert_eq!(result.output, &__ret[..]); if !unconstrained { *result.multiplicity += G::ONE; } } else { record.function_queries[458].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained)); }; + let __ret: [G; OUT_454] = [__v_12]; + if let Some(result) = record.function_queries[454].get_mut(&inp[..]) { debug_assert_eq!(result.output, &__ret[..]); if !unconstrained { *result.multiplicity += G::ONE; } } else { record.function_queries[454].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained)); }; return Ok(__ret); }, } }, _ => { let __v_11: G = G::from_u64(0); - let __ret: [G; OUT_458] = [__v_11]; - if let Some(result) = record.function_queries[458].get_mut(&inp[..]) { debug_assert_eq!(result.output, &__ret[..]); if !unconstrained { *result.multiplicity += G::ONE; } } else { record.function_queries[458].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained)); }; + let __ret: [G; OUT_454] = [__v_11]; + if let Some(result) = record.function_queries[454].get_mut(&inp[..]) { debug_assert_eq!(result.output, &__ret[..]); if !unconstrained { *result.multiplicity += G::ONE; } } else { record.function_queries[454].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained)); }; return Ok(__ret); }, } }, _ => { let __v_7: G = G::from_u64(0); - let __ret: [G; OUT_458] = [__v_7]; - if let Some(result) = record.function_queries[458].get_mut(&inp[..]) { debug_assert_eq!(result.output, &__ret[..]); if !unconstrained { *result.multiplicity += G::ONE; } } else { record.function_queries[458].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained)); }; + let __ret: [G; OUT_454] = [__v_7]; + if let Some(result) = record.function_queries[454].get_mut(&inp[..]) { debug_assert_eq!(result.output, &__ret[..]); if !unconstrained { *result.multiplicity += G::ONE; } } else { record.function_queries[454].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained)); }; return Ok(__ret); }, } }) } -const INPUT_SIZE_459: usize = 4; -const IN_459: usize = 4; -const OUT_459: usize = 2; -fn aiur_fn_459( - inp: [G; IN_459], +const INPUT_SIZE_455: usize = 4; +const IN_455: usize = 4; +const OUT_455: usize = 2; +fn aiur_fn_455( + inp: [G; IN_455], record: &mut QueryRecord, io_buffer: &mut IOBuffer, unconstrained: bool, -) -> Result<[G; OUT_459], ExecError> { +) -> Result<[G; OUT_455], ExecError> { stacker::maybe_grow(64 * 1024, 4 * 1024 * 1024, || { let __v_0: G = inp[0]; let __v_1: G = inp[1]; @@ -40827,8 +40553,8 @@ fn aiur_fn_459( match __v_4.as_canonical_u64() { 0u64 => { let __v_5: G = G::from_u64(1); - let __ret: [G; OUT_459] = [__v_5, __v_2]; - if let Some(result) = record.function_queries[459].get_mut(&inp[..]) { debug_assert_eq!(result.output, &__ret[..]); if !unconstrained { *result.multiplicity += G::ONE; } } else { record.function_queries[459].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained)); }; + let __ret: [G; OUT_455] = [__v_5, __v_2]; + if let Some(result) = record.function_queries[455].get_mut(&inp[..]) { debug_assert_eq!(result.output, &__ret[..]); if !unconstrained { *result.multiplicity += G::ONE; } } else { record.function_queries[455].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained)); }; return Ok(__ret); }, _ => { @@ -40850,24 +40576,24 @@ fn aiur_fn_459( match __v_13.as_canonical_u64() { 0u64 => { let __v_14: G = G::from_u64(1); - let __ret: [G; OUT_459] = [__v_14, __v_2]; - if let Some(result) = record.function_queries[459].get_mut(&inp[..]) { debug_assert_eq!(result.output, &__ret[..]); if !unconstrained { *result.multiplicity += G::ONE; } } else { record.function_queries[459].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained)); }; + let __ret: [G; OUT_455] = [__v_14, __v_2]; + if let Some(result) = record.function_queries[455].get_mut(&inp[..]) { debug_assert_eq!(result.output, &__ret[..]); if !unconstrained { *result.multiplicity += G::ONE; } } else { record.function_queries[455].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained)); }; return Ok(__ret); }, _ => { let __v_14: G = G::from_u64(0); - let __ret: [G; OUT_459] = [__v_14, __v_2]; - if let Some(result) = record.function_queries[459].get_mut(&inp[..]) { debug_assert_eq!(result.output, &__ret[..]); if !unconstrained { *result.multiplicity += G::ONE; } } else { record.function_queries[459].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained)); }; + let __ret: [G; OUT_455] = [__v_14, __v_2]; + if let Some(result) = record.function_queries[455].get_mut(&inp[..]) { debug_assert_eq!(result.output, &__ret[..]); if !unconstrained { *result.multiplicity += G::ONE; } } else { record.function_queries[455].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained)); }; return Ok(__ret); }, } }, _ => { - let __r_arr: [G; OUT_460] = { let __args: [G; IN_460] = [__v_0, __v_1, __v_2, __v_3]; let __cu = unconstrained; if let Some(result) = record.function_queries[460].get_mut(&__args[..]) { if !__cu && *result.multiplicity == G::ZERO { aiur_fn_460(__args, record, io_buffer, false)? } else { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_460] = unsafe { *(result.output.as_ptr() as *const [G; OUT_460]) }; __ret } } else { aiur_fn_460(__args, record, io_buffer, __cu)? } }; + let __r_arr: [G; OUT_456] = { let __args: [G; IN_456] = [__v_0, __v_1, __v_2, __v_3]; let __cu = unconstrained; if let Some(result) = record.function_queries[456].get_mut(&__args[..]) { if !__cu && *result.multiplicity == G::ZERO { aiur_fn_456(__args, record, io_buffer, false)? } else { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_456] = unsafe { *(result.output.as_ptr() as *const [G; OUT_456]) }; __ret } } else { aiur_fn_456(__args, record, io_buffer, __cu)? } }; let __v_13: G = __r_arr[0]; let __v_14: G = __r_arr[1]; - let __ret: [G; OUT_459] = [__v_13, __v_14]; - if let Some(result) = record.function_queries[459].get_mut(&inp[..]) { debug_assert_eq!(result.output, &__ret[..]); if !unconstrained { *result.multiplicity += G::ONE; } } else { record.function_queries[459].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained)); }; + let __ret: [G; OUT_455] = [__v_13, __v_14]; + if let Some(result) = record.function_queries[455].get_mut(&inp[..]) { debug_assert_eq!(result.output, &__ret[..]); if !unconstrained { *result.multiplicity += G::ONE; } } else { record.function_queries[455].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained)); }; return Ok(__ret); }, } @@ -40880,18 +40606,18 @@ fn aiur_fn_459( let __v_12: G = __loaded[3]; match __v_9.as_canonical_u64() { 1u64 => { - let __r_arr: [G; OUT_324] = { let __args: [G; IN_324] = [__v_6, __v_10]; let __cu = unconstrained; if let Some(result) = record.function_queries[324].get_mut(&__args[..]) { if !__cu && *result.multiplicity == G::ZERO { aiur_fn_324(__args, record, io_buffer, false)? } else { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_324] = unsafe { *(result.output.as_ptr() as *const [G; OUT_324]) }; __ret } } else { aiur_fn_324(__args, record, io_buffer, __cu)? } }; + let __r_arr: [G; OUT_320] = { let __args: [G; IN_320] = [__v_6, __v_10]; let __cu = unconstrained; if let Some(result) = record.function_queries[320].get_mut(&__args[..]) { if !__cu && *result.multiplicity == G::ZERO { aiur_fn_320(__args, record, io_buffer, false)? } else { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_320] = unsafe { *(result.output.as_ptr() as *const [G; OUT_320]) }; __ret } } else { aiur_fn_320(__args, record, io_buffer, __cu)? } }; let __v_13: G = __r_arr[0]; - let __ret: [G; OUT_459] = [__v_13, __v_2]; - if let Some(result) = record.function_queries[459].get_mut(&inp[..]) { debug_assert_eq!(result.output, &__ret[..]); if !unconstrained { *result.multiplicity += G::ONE; } } else { record.function_queries[459].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained)); }; + let __ret: [G; OUT_455] = [__v_13, __v_2]; + if let Some(result) = record.function_queries[455].get_mut(&inp[..]) { debug_assert_eq!(result.output, &__ret[..]); if !unconstrained { *result.multiplicity += G::ONE; } } else { record.function_queries[455].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained)); }; return Ok(__ret); }, _ => { - let __r_arr: [G; OUT_460] = { let __args: [G; IN_460] = [__v_0, __v_1, __v_2, __v_3]; let __cu = unconstrained; if let Some(result) = record.function_queries[460].get_mut(&__args[..]) { if !__cu && *result.multiplicity == G::ZERO { aiur_fn_460(__args, record, io_buffer, false)? } else { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_460] = unsafe { *(result.output.as_ptr() as *const [G; OUT_460]) }; __ret } } else { aiur_fn_460(__args, record, io_buffer, __cu)? } }; + let __r_arr: [G; OUT_456] = { let __args: [G; IN_456] = [__v_0, __v_1, __v_2, __v_3]; let __cu = unconstrained; if let Some(result) = record.function_queries[456].get_mut(&__args[..]) { if !__cu && *result.multiplicity == G::ZERO { aiur_fn_456(__args, record, io_buffer, false)? } else { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_456] = unsafe { *(result.output.as_ptr() as *const [G; OUT_456]) }; __ret } } else { aiur_fn_456(__args, record, io_buffer, __cu)? } }; let __v_13: G = __r_arr[0]; let __v_14: G = __r_arr[1]; - let __ret: [G; OUT_459] = [__v_13, __v_14]; - if let Some(result) = record.function_queries[459].get_mut(&inp[..]) { debug_assert_eq!(result.output, &__ret[..]); if !unconstrained { *result.multiplicity += G::ONE; } } else { record.function_queries[459].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained)); }; + let __ret: [G; OUT_455] = [__v_13, __v_14]; + if let Some(result) = record.function_queries[455].get_mut(&inp[..]) { debug_assert_eq!(result.output, &__ret[..]); if !unconstrained { *result.multiplicity += G::ONE; } } else { record.function_queries[455].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained)); }; return Ok(__ret); }, } @@ -40908,28 +40634,28 @@ fn aiur_fn_459( let __v_13: G = __r_arr[0]; match __v_13.as_canonical_u64() { 1u64 => { - let __r_arr: [G; OUT_438] = { let __args: [G; IN_438] = [__v_7, __v_11]; let __cu = unconstrained; if let Some(result) = record.function_queries[438].get_mut(&__args[..]) { if !__cu && *result.multiplicity == G::ZERO { aiur_fn_438(__args, record, io_buffer, false)? } else { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_438] = unsafe { *(result.output.as_ptr() as *const [G; OUT_438]) }; __ret } } else { aiur_fn_438(__args, record, io_buffer, __cu)? } }; + let __r_arr: [G; OUT_434] = { let __args: [G; IN_434] = [__v_7, __v_11]; let __cu = unconstrained; if let Some(result) = record.function_queries[434].get_mut(&__args[..]) { if !__cu && *result.multiplicity == G::ZERO { aiur_fn_434(__args, record, io_buffer, false)? } else { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_434] = unsafe { *(result.output.as_ptr() as *const [G; OUT_434]) }; __ret } } else { aiur_fn_434(__args, record, io_buffer, __cu)? } }; let __v_14: G = __r_arr[0]; - let __ret: [G; OUT_459] = [__v_14, __v_2]; - if let Some(result) = record.function_queries[459].get_mut(&inp[..]) { debug_assert_eq!(result.output, &__ret[..]); if !unconstrained { *result.multiplicity += G::ONE; } } else { record.function_queries[459].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained)); }; + let __ret: [G; OUT_455] = [__v_14, __v_2]; + if let Some(result) = record.function_queries[455].get_mut(&inp[..]) { debug_assert_eq!(result.output, &__ret[..]); if !unconstrained { *result.multiplicity += G::ONE; } } else { record.function_queries[455].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained)); }; return Ok(__ret); }, _ => { - let __r_arr: [G; OUT_460] = { let __args: [G; IN_460] = [__v_0, __v_1, __v_2, __v_3]; let __cu = unconstrained; if let Some(result) = record.function_queries[460].get_mut(&__args[..]) { if !__cu && *result.multiplicity == G::ZERO { aiur_fn_460(__args, record, io_buffer, false)? } else { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_460] = unsafe { *(result.output.as_ptr() as *const [G; OUT_460]) }; __ret } } else { aiur_fn_460(__args, record, io_buffer, __cu)? } }; + let __r_arr: [G; OUT_456] = { let __args: [G; IN_456] = [__v_0, __v_1, __v_2, __v_3]; let __cu = unconstrained; if let Some(result) = record.function_queries[456].get_mut(&__args[..]) { if !__cu && *result.multiplicity == G::ZERO { aiur_fn_456(__args, record, io_buffer, false)? } else { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_456] = unsafe { *(result.output.as_ptr() as *const [G; OUT_456]) }; __ret } } else { aiur_fn_456(__args, record, io_buffer, __cu)? } }; let __v_14: G = __r_arr[0]; let __v_15: G = __r_arr[1]; - let __ret: [G; OUT_459] = [__v_14, __v_15]; - if let Some(result) = record.function_queries[459].get_mut(&inp[..]) { debug_assert_eq!(result.output, &__ret[..]); if !unconstrained { *result.multiplicity += G::ONE; } } else { record.function_queries[459].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained)); }; + let __ret: [G; OUT_455] = [__v_14, __v_15]; + if let Some(result) = record.function_queries[455].get_mut(&inp[..]) { debug_assert_eq!(result.output, &__ret[..]); if !unconstrained { *result.multiplicity += G::ONE; } } else { record.function_queries[455].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained)); }; return Ok(__ret); }, } }, _ => { - let __r_arr: [G; OUT_460] = { let __args: [G; IN_460] = [__v_0, __v_1, __v_2, __v_3]; let __cu = unconstrained; if let Some(result) = record.function_queries[460].get_mut(&__args[..]) { if !__cu && *result.multiplicity == G::ZERO { aiur_fn_460(__args, record, io_buffer, false)? } else { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_460] = unsafe { *(result.output.as_ptr() as *const [G; OUT_460]) }; __ret } } else { aiur_fn_460(__args, record, io_buffer, __cu)? } }; + let __r_arr: [G; OUT_456] = { let __args: [G; IN_456] = [__v_0, __v_1, __v_2, __v_3]; let __cu = unconstrained; if let Some(result) = record.function_queries[456].get_mut(&__args[..]) { if !__cu && *result.multiplicity == G::ZERO { aiur_fn_456(__args, record, io_buffer, false)? } else { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_456] = unsafe { *(result.output.as_ptr() as *const [G; OUT_456]) }; __ret } } else { aiur_fn_456(__args, record, io_buffer, __cu)? } }; let __v_13: G = __r_arr[0]; let __v_14: G = __r_arr[1]; - let __ret: [G; OUT_459] = [__v_13, __v_14]; - if let Some(result) = record.function_queries[459].get_mut(&inp[..]) { debug_assert_eq!(result.output, &__ret[..]); if !unconstrained { *result.multiplicity += G::ONE; } } else { record.function_queries[459].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained)); }; + let __ret: [G; OUT_455] = [__v_13, __v_14]; + if let Some(result) = record.function_queries[455].get_mut(&inp[..]) { debug_assert_eq!(result.output, &__ret[..]); if !unconstrained { *result.multiplicity += G::ONE; } } else { record.function_queries[455].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained)); }; return Ok(__ret); }, } @@ -40942,32 +40668,32 @@ fn aiur_fn_459( let __v_12: G = __loaded[3]; match __v_9.as_canonical_u64() { 3u64 => { - let __r_arr: [G; OUT_459] = { let __args: [G; IN_459] = [__v_6, __v_10, __v_2, __v_3]; let __cu = unconstrained; if let Some(result) = record.function_queries[459].get_mut(&__args[..]) { if !__cu && *result.multiplicity == G::ZERO { aiur_fn_459(__args, record, io_buffer, false)? } else { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_459] = unsafe { *(result.output.as_ptr() as *const [G; OUT_459]) }; __ret } } else { aiur_fn_459(__args, record, io_buffer, __cu)? } }; + let __r_arr: [G; OUT_455] = { let __args: [G; IN_455] = [__v_6, __v_10, __v_2, __v_3]; let __cu = unconstrained; if let Some(result) = record.function_queries[455].get_mut(&__args[..]) { if !__cu && *result.multiplicity == G::ZERO { aiur_fn_455(__args, record, io_buffer, false)? } else { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_455] = unsafe { *(result.output.as_ptr() as *const [G; OUT_455]) }; __ret } } else { aiur_fn_455(__args, record, io_buffer, __cu)? } }; let __v_13: G = __r_arr[0]; let __v_14: G = __r_arr[1]; match __v_13.as_canonical_u64() { 1u64 => { - let __r_arr: [G; OUT_459] = { let __args: [G; IN_459] = [__v_7, __v_11, __v_14, __v_3]; let __cu = unconstrained; if let Some(result) = record.function_queries[459].get_mut(&__args[..]) { if !__cu && *result.multiplicity == G::ZERO { aiur_fn_459(__args, record, io_buffer, false)? } else { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_459] = unsafe { *(result.output.as_ptr() as *const [G; OUT_459]) }; __ret } } else { aiur_fn_459(__args, record, io_buffer, __cu)? } }; + let __r_arr: [G; OUT_455] = { let __args: [G; IN_455] = [__v_7, __v_11, __v_14, __v_3]; let __cu = unconstrained; if let Some(result) = record.function_queries[455].get_mut(&__args[..]) { if !__cu && *result.multiplicity == G::ZERO { aiur_fn_455(__args, record, io_buffer, false)? } else { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_455] = unsafe { *(result.output.as_ptr() as *const [G; OUT_455]) }; __ret } } else { aiur_fn_455(__args, record, io_buffer, __cu)? } }; let __v_15: G = __r_arr[0]; let __v_16: G = __r_arr[1]; - let __ret: [G; OUT_459] = [__v_15, __v_16]; - if let Some(result) = record.function_queries[459].get_mut(&inp[..]) { debug_assert_eq!(result.output, &__ret[..]); if !unconstrained { *result.multiplicity += G::ONE; } } else { record.function_queries[459].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained)); }; + let __ret: [G; OUT_455] = [__v_15, __v_16]; + if let Some(result) = record.function_queries[455].get_mut(&inp[..]) { debug_assert_eq!(result.output, &__ret[..]); if !unconstrained { *result.multiplicity += G::ONE; } } else { record.function_queries[455].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained)); }; return Ok(__ret); }, _ => { let __v_15: G = G::from_u64(0); - let __ret: [G; OUT_459] = [__v_15, __v_14]; - if let Some(result) = record.function_queries[459].get_mut(&inp[..]) { debug_assert_eq!(result.output, &__ret[..]); if !unconstrained { *result.multiplicity += G::ONE; } } else { record.function_queries[459].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained)); }; + let __ret: [G; OUT_455] = [__v_15, __v_14]; + if let Some(result) = record.function_queries[455].get_mut(&inp[..]) { debug_assert_eq!(result.output, &__ret[..]); if !unconstrained { *result.multiplicity += G::ONE; } } else { record.function_queries[455].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained)); }; return Ok(__ret); }, } }, _ => { - let __r_arr: [G; OUT_460] = { let __args: [G; IN_460] = [__v_0, __v_1, __v_2, __v_3]; let __cu = unconstrained; if let Some(result) = record.function_queries[460].get_mut(&__args[..]) { if !__cu && *result.multiplicity == G::ZERO { aiur_fn_460(__args, record, io_buffer, false)? } else { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_460] = unsafe { *(result.output.as_ptr() as *const [G; OUT_460]) }; __ret } } else { aiur_fn_460(__args, record, io_buffer, __cu)? } }; + let __r_arr: [G; OUT_456] = { let __args: [G; IN_456] = [__v_0, __v_1, __v_2, __v_3]; let __cu = unconstrained; if let Some(result) = record.function_queries[456].get_mut(&__args[..]) { if !__cu && *result.multiplicity == G::ZERO { aiur_fn_456(__args, record, io_buffer, false)? } else { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_456] = unsafe { *(result.output.as_ptr() as *const [G; OUT_456]) }; __ret } } else { aiur_fn_456(__args, record, io_buffer, __cu)? } }; let __v_13: G = __r_arr[0]; let __v_14: G = __r_arr[1]; - let __ret: [G; OUT_459] = [__v_13, __v_14]; - if let Some(result) = record.function_queries[459].get_mut(&inp[..]) { debug_assert_eq!(result.output, &__ret[..]); if !unconstrained { *result.multiplicity += G::ONE; } } else { record.function_queries[459].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained)); }; + let __ret: [G; OUT_455] = [__v_13, __v_14]; + if let Some(result) = record.function_queries[455].get_mut(&inp[..]) { debug_assert_eq!(result.output, &__ret[..]); if !unconstrained { *result.multiplicity += G::ONE; } } else { record.function_queries[455].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained)); }; return Ok(__ret); }, } @@ -40980,34 +40706,34 @@ fn aiur_fn_459( let __v_12: G = __loaded[3]; match __v_9.as_canonical_u64() { 4u64 => { - let __r_arr: [G; OUT_459] = { let __args: [G; IN_459] = [__v_6, __v_10, __v_2, __v_3]; let __cu = unconstrained; if let Some(result) = record.function_queries[459].get_mut(&__args[..]) { if !__cu && *result.multiplicity == G::ZERO { aiur_fn_459(__args, record, io_buffer, false)? } else { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_459] = unsafe { *(result.output.as_ptr() as *const [G; OUT_459]) }; __ret } } else { aiur_fn_459(__args, record, io_buffer, __cu)? } }; + let __r_arr: [G; OUT_455] = { let __args: [G; IN_455] = [__v_6, __v_10, __v_2, __v_3]; let __cu = unconstrained; if let Some(result) = record.function_queries[455].get_mut(&__args[..]) { if !__cu && *result.multiplicity == G::ZERO { aiur_fn_455(__args, record, io_buffer, false)? } else { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_455] = unsafe { *(result.output.as_ptr() as *const [G; OUT_455]) }; __ret } } else { aiur_fn_455(__args, record, io_buffer, __cu)? } }; let __v_13: G = __r_arr[0]; let __v_14: G = __r_arr[1]; match __v_13.as_canonical_u64() { 1u64 => { let __v_15: G = G::from_u64(0); let __v_16: G = { let __values: [G; 3] = [__v_15, __v_6, __v_3]; let __mq = record.memory_queries.get_mut(&3).ok_or(ExecError::InvalidMemorySize(3))?; if let Some(result) = __mq.get_mut(&__values[..]) { if !unconstrained { *result.multiplicity += G::ONE; } result.output[0] } else { let __ptr = G::from_usize(__mq.len()); __mq.insert(&__values[..], &[__ptr], G::from_bool(!unconstrained)); __ptr } }; - let __r_arr: [G; OUT_459] = { let __args: [G; IN_459] = [__v_7, __v_11, __v_14, __v_16]; let __cu = unconstrained; if let Some(result) = record.function_queries[459].get_mut(&__args[..]) { if !__cu && *result.multiplicity == G::ZERO { aiur_fn_459(__args, record, io_buffer, false)? } else { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_459] = unsafe { *(result.output.as_ptr() as *const [G; OUT_459]) }; __ret } } else { aiur_fn_459(__args, record, io_buffer, __cu)? } }; + let __r_arr: [G; OUT_455] = { let __args: [G; IN_455] = [__v_7, __v_11, __v_14, __v_16]; let __cu = unconstrained; if let Some(result) = record.function_queries[455].get_mut(&__args[..]) { if !__cu && *result.multiplicity == G::ZERO { aiur_fn_455(__args, record, io_buffer, false)? } else { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_455] = unsafe { *(result.output.as_ptr() as *const [G; OUT_455]) }; __ret } } else { aiur_fn_455(__args, record, io_buffer, __cu)? } }; let __v_17: G = __r_arr[0]; let __v_18: G = __r_arr[1]; - let __ret: [G; OUT_459] = [__v_17, __v_18]; - if let Some(result) = record.function_queries[459].get_mut(&inp[..]) { debug_assert_eq!(result.output, &__ret[..]); if !unconstrained { *result.multiplicity += G::ONE; } } else { record.function_queries[459].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained)); }; + let __ret: [G; OUT_455] = [__v_17, __v_18]; + if let Some(result) = record.function_queries[455].get_mut(&inp[..]) { debug_assert_eq!(result.output, &__ret[..]); if !unconstrained { *result.multiplicity += G::ONE; } } else { record.function_queries[455].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained)); }; return Ok(__ret); }, _ => { let __v_15: G = G::from_u64(0); - let __ret: [G; OUT_459] = [__v_15, __v_14]; - if let Some(result) = record.function_queries[459].get_mut(&inp[..]) { debug_assert_eq!(result.output, &__ret[..]); if !unconstrained { *result.multiplicity += G::ONE; } } else { record.function_queries[459].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained)); }; + let __ret: [G; OUT_455] = [__v_15, __v_14]; + if let Some(result) = record.function_queries[455].get_mut(&inp[..]) { debug_assert_eq!(result.output, &__ret[..]); if !unconstrained { *result.multiplicity += G::ONE; } } else { record.function_queries[455].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained)); }; return Ok(__ret); }, } }, _ => { - let __r_arr: [G; OUT_460] = { let __args: [G; IN_460] = [__v_0, __v_1, __v_2, __v_3]; let __cu = unconstrained; if let Some(result) = record.function_queries[460].get_mut(&__args[..]) { if !__cu && *result.multiplicity == G::ZERO { aiur_fn_460(__args, record, io_buffer, false)? } else { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_460] = unsafe { *(result.output.as_ptr() as *const [G; OUT_460]) }; __ret } } else { aiur_fn_460(__args, record, io_buffer, __cu)? } }; + let __r_arr: [G; OUT_456] = { let __args: [G; IN_456] = [__v_0, __v_1, __v_2, __v_3]; let __cu = unconstrained; if let Some(result) = record.function_queries[456].get_mut(&__args[..]) { if !__cu && *result.multiplicity == G::ZERO { aiur_fn_456(__args, record, io_buffer, false)? } else { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_456] = unsafe { *(result.output.as_ptr() as *const [G; OUT_456]) }; __ret } } else { aiur_fn_456(__args, record, io_buffer, __cu)? } }; let __v_13: G = __r_arr[0]; let __v_14: G = __r_arr[1]; - let __ret: [G; OUT_459] = [__v_13, __v_14]; - if let Some(result) = record.function_queries[459].get_mut(&inp[..]) { debug_assert_eq!(result.output, &__ret[..]); if !unconstrained { *result.multiplicity += G::ONE; } } else { record.function_queries[459].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained)); }; + let __ret: [G; OUT_455] = [__v_13, __v_14]; + if let Some(result) = record.function_queries[455].get_mut(&inp[..]) { debug_assert_eq!(result.output, &__ret[..]); if !unconstrained { *result.multiplicity += G::ONE; } } else { record.function_queries[455].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained)); }; return Ok(__ret); }, } @@ -41020,34 +40746,34 @@ fn aiur_fn_459( let __v_12: G = __loaded[3]; match __v_9.as_canonical_u64() { 5u64 => { - let __r_arr: [G; OUT_459] = { let __args: [G; IN_459] = [__v_6, __v_10, __v_2, __v_3]; let __cu = unconstrained; if let Some(result) = record.function_queries[459].get_mut(&__args[..]) { if !__cu && *result.multiplicity == G::ZERO { aiur_fn_459(__args, record, io_buffer, false)? } else { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_459] = unsafe { *(result.output.as_ptr() as *const [G; OUT_459]) }; __ret } } else { aiur_fn_459(__args, record, io_buffer, __cu)? } }; + let __r_arr: [G; OUT_455] = { let __args: [G; IN_455] = [__v_6, __v_10, __v_2, __v_3]; let __cu = unconstrained; if let Some(result) = record.function_queries[455].get_mut(&__args[..]) { if !__cu && *result.multiplicity == G::ZERO { aiur_fn_455(__args, record, io_buffer, false)? } else { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_455] = unsafe { *(result.output.as_ptr() as *const [G; OUT_455]) }; __ret } } else { aiur_fn_455(__args, record, io_buffer, __cu)? } }; let __v_13: G = __r_arr[0]; let __v_14: G = __r_arr[1]; match __v_13.as_canonical_u64() { 1u64 => { let __v_15: G = G::from_u64(0); let __v_16: G = { let __values: [G; 3] = [__v_15, __v_6, __v_3]; let __mq = record.memory_queries.get_mut(&3).ok_or(ExecError::InvalidMemorySize(3))?; if let Some(result) = __mq.get_mut(&__values[..]) { if !unconstrained { *result.multiplicity += G::ONE; } result.output[0] } else { let __ptr = G::from_usize(__mq.len()); __mq.insert(&__values[..], &[__ptr], G::from_bool(!unconstrained)); __ptr } }; - let __r_arr: [G; OUT_459] = { let __args: [G; IN_459] = [__v_7, __v_11, __v_14, __v_16]; let __cu = unconstrained; if let Some(result) = record.function_queries[459].get_mut(&__args[..]) { if !__cu && *result.multiplicity == G::ZERO { aiur_fn_459(__args, record, io_buffer, false)? } else { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_459] = unsafe { *(result.output.as_ptr() as *const [G; OUT_459]) }; __ret } } else { aiur_fn_459(__args, record, io_buffer, __cu)? } }; + let __r_arr: [G; OUT_455] = { let __args: [G; IN_455] = [__v_7, __v_11, __v_14, __v_16]; let __cu = unconstrained; if let Some(result) = record.function_queries[455].get_mut(&__args[..]) { if !__cu && *result.multiplicity == G::ZERO { aiur_fn_455(__args, record, io_buffer, false)? } else { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_455] = unsafe { *(result.output.as_ptr() as *const [G; OUT_455]) }; __ret } } else { aiur_fn_455(__args, record, io_buffer, __cu)? } }; let __v_17: G = __r_arr[0]; let __v_18: G = __r_arr[1]; - let __ret: [G; OUT_459] = [__v_17, __v_18]; - if let Some(result) = record.function_queries[459].get_mut(&inp[..]) { debug_assert_eq!(result.output, &__ret[..]); if !unconstrained { *result.multiplicity += G::ONE; } } else { record.function_queries[459].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained)); }; + let __ret: [G; OUT_455] = [__v_17, __v_18]; + if let Some(result) = record.function_queries[455].get_mut(&inp[..]) { debug_assert_eq!(result.output, &__ret[..]); if !unconstrained { *result.multiplicity += G::ONE; } } else { record.function_queries[455].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained)); }; return Ok(__ret); }, _ => { let __v_15: G = G::from_u64(0); - let __ret: [G; OUT_459] = [__v_15, __v_14]; - if let Some(result) = record.function_queries[459].get_mut(&inp[..]) { debug_assert_eq!(result.output, &__ret[..]); if !unconstrained { *result.multiplicity += G::ONE; } } else { record.function_queries[459].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained)); }; + let __ret: [G; OUT_455] = [__v_15, __v_14]; + if let Some(result) = record.function_queries[455].get_mut(&inp[..]) { debug_assert_eq!(result.output, &__ret[..]); if !unconstrained { *result.multiplicity += G::ONE; } } else { record.function_queries[455].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained)); }; return Ok(__ret); }, } }, _ => { - let __r_arr: [G; OUT_460] = { let __args: [G; IN_460] = [__v_0, __v_1, __v_2, __v_3]; let __cu = unconstrained; if let Some(result) = record.function_queries[460].get_mut(&__args[..]) { if !__cu && *result.multiplicity == G::ZERO { aiur_fn_460(__args, record, io_buffer, false)? } else { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_460] = unsafe { *(result.output.as_ptr() as *const [G; OUT_460]) }; __ret } } else { aiur_fn_460(__args, record, io_buffer, __cu)? } }; + let __r_arr: [G; OUT_456] = { let __args: [G; IN_456] = [__v_0, __v_1, __v_2, __v_3]; let __cu = unconstrained; if let Some(result) = record.function_queries[456].get_mut(&__args[..]) { if !__cu && *result.multiplicity == G::ZERO { aiur_fn_456(__args, record, io_buffer, false)? } else { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_456] = unsafe { *(result.output.as_ptr() as *const [G; OUT_456]) }; __ret } } else { aiur_fn_456(__args, record, io_buffer, __cu)? } }; let __v_13: G = __r_arr[0]; let __v_14: G = __r_arr[1]; - let __ret: [G; OUT_459] = [__v_13, __v_14]; - if let Some(result) = record.function_queries[459].get_mut(&inp[..]) { debug_assert_eq!(result.output, &__ret[..]); if !unconstrained { *result.multiplicity += G::ONE; } } else { record.function_queries[459].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained)); }; + let __ret: [G; OUT_455] = [__v_13, __v_14]; + if let Some(result) = record.function_queries[455].get_mut(&inp[..]) { debug_assert_eq!(result.output, &__ret[..]); if !unconstrained { *result.multiplicity += G::ONE; } } else { record.function_queries[455].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained)); }; return Ok(__ret); }, } @@ -41060,18 +40786,18 @@ fn aiur_fn_459( let __v_12: G = __loaded[3]; match __v_9.as_canonical_u64() { 7u64 => { - let __r_arr: [G; OUT_340] = { let __args: [G; IN_340] = [__v_6, __v_7, __v_10, __v_11]; let __cu = unconstrained; if let Some(result) = record.function_queries[340].get_mut(&__args[..]) { if !__cu && *result.multiplicity == G::ZERO { aiur_fn_340(__args, record, io_buffer, false)? } else { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_340] = unsafe { *(result.output.as_ptr() as *const [G; OUT_340]) }; __ret } } else { aiur_fn_340(__args, record, io_buffer, __cu)? } }; + let __r_arr: [G; OUT_336] = { let __args: [G; IN_336] = [__v_6, __v_7, __v_10, __v_11]; let __cu = unconstrained; if let Some(result) = record.function_queries[336].get_mut(&__args[..]) { if !__cu && *result.multiplicity == G::ZERO { aiur_fn_336(__args, record, io_buffer, false)? } else { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_336] = unsafe { *(result.output.as_ptr() as *const [G; OUT_336]) }; __ret } } else { aiur_fn_336(__args, record, io_buffer, __cu)? } }; let __v_13: G = __r_arr[0]; - let __ret: [G; OUT_459] = [__v_13, __v_2]; - if let Some(result) = record.function_queries[459].get_mut(&inp[..]) { debug_assert_eq!(result.output, &__ret[..]); if !unconstrained { *result.multiplicity += G::ONE; } } else { record.function_queries[459].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained)); }; + let __ret: [G; OUT_455] = [__v_13, __v_2]; + if let Some(result) = record.function_queries[455].get_mut(&inp[..]) { debug_assert_eq!(result.output, &__ret[..]); if !unconstrained { *result.multiplicity += G::ONE; } } else { record.function_queries[455].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained)); }; return Ok(__ret); }, _ => { - let __r_arr: [G; OUT_460] = { let __args: [G; IN_460] = [__v_0, __v_1, __v_2, __v_3]; let __cu = unconstrained; if let Some(result) = record.function_queries[460].get_mut(&__args[..]) { if !__cu && *result.multiplicity == G::ZERO { aiur_fn_460(__args, record, io_buffer, false)? } else { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_460] = unsafe { *(result.output.as_ptr() as *const [G; OUT_460]) }; __ret } } else { aiur_fn_460(__args, record, io_buffer, __cu)? } }; + let __r_arr: [G; OUT_456] = { let __args: [G; IN_456] = [__v_0, __v_1, __v_2, __v_3]; let __cu = unconstrained; if let Some(result) = record.function_queries[456].get_mut(&__args[..]) { if !__cu && *result.multiplicity == G::ZERO { aiur_fn_456(__args, record, io_buffer, false)? } else { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_456] = unsafe { *(result.output.as_ptr() as *const [G; OUT_456]) }; __ret } } else { aiur_fn_456(__args, record, io_buffer, __cu)? } }; let __v_13: G = __r_arr[0]; let __v_14: G = __r_arr[1]; - let __ret: [G; OUT_459] = [__v_13, __v_14]; - if let Some(result) = record.function_queries[459].get_mut(&inp[..]) { debug_assert_eq!(result.output, &__ret[..]); if !unconstrained { *result.multiplicity += G::ONE; } } else { record.function_queries[459].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained)); }; + let __ret: [G; OUT_455] = [__v_13, __v_14]; + if let Some(result) = record.function_queries[455].get_mut(&inp[..]) { debug_assert_eq!(result.output, &__ret[..]); if !unconstrained { *result.multiplicity += G::ONE; } } else { record.function_queries[455].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained)); }; return Ok(__ret); }, } @@ -41091,47 +40817,47 @@ fn aiur_fn_459( let __v_14: G = (__v_7 - __v_11); match __v_14.as_canonical_u64() { 0u64 => { - let __r_arr: [G; OUT_459] = { let __args: [G; IN_459] = [__v_8, __v_12, __v_2, __v_3]; let __cu = unconstrained; if let Some(result) = record.function_queries[459].get_mut(&__args[..]) { if !__cu && *result.multiplicity == G::ZERO { aiur_fn_459(__args, record, io_buffer, false)? } else { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_459] = unsafe { *(result.output.as_ptr() as *const [G; OUT_459]) }; __ret } } else { aiur_fn_459(__args, record, io_buffer, __cu)? } }; + let __r_arr: [G; OUT_455] = { let __args: [G; IN_455] = [__v_8, __v_12, __v_2, __v_3]; let __cu = unconstrained; if let Some(result) = record.function_queries[455].get_mut(&__args[..]) { if !__cu && *result.multiplicity == G::ZERO { aiur_fn_455(__args, record, io_buffer, false)? } else { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_455] = unsafe { *(result.output.as_ptr() as *const [G; OUT_455]) }; __ret } } else { aiur_fn_455(__args, record, io_buffer, __cu)? } }; let __v_15: G = __r_arr[0]; let __v_16: G = __r_arr[1]; - let __ret: [G; OUT_459] = [__v_15, __v_16]; - if let Some(result) = record.function_queries[459].get_mut(&inp[..]) { debug_assert_eq!(result.output, &__ret[..]); if !unconstrained { *result.multiplicity += G::ONE; } } else { record.function_queries[459].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained)); }; + let __ret: [G; OUT_455] = [__v_15, __v_16]; + if let Some(result) = record.function_queries[455].get_mut(&inp[..]) { debug_assert_eq!(result.output, &__ret[..]); if !unconstrained { *result.multiplicity += G::ONE; } } else { record.function_queries[455].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained)); }; return Ok(__ret); }, _ => { let __v_15: G = G::from_u64(0); - let __ret: [G; OUT_459] = [__v_15, __v_2]; - if let Some(result) = record.function_queries[459].get_mut(&inp[..]) { debug_assert_eq!(result.output, &__ret[..]); if !unconstrained { *result.multiplicity += G::ONE; } } else { record.function_queries[459].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained)); }; + let __ret: [G; OUT_455] = [__v_15, __v_2]; + if let Some(result) = record.function_queries[455].get_mut(&inp[..]) { debug_assert_eq!(result.output, &__ret[..]); if !unconstrained { *result.multiplicity += G::ONE; } } else { record.function_queries[455].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained)); }; return Ok(__ret); }, } }, _ => { - let __r_arr: [G; OUT_460] = { let __args: [G; IN_460] = [__v_0, __v_1, __v_2, __v_3]; let __cu = unconstrained; if let Some(result) = record.function_queries[460].get_mut(&__args[..]) { if !__cu && *result.multiplicity == G::ZERO { aiur_fn_460(__args, record, io_buffer, false)? } else { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_460] = unsafe { *(result.output.as_ptr() as *const [G; OUT_460]) }; __ret } } else { aiur_fn_460(__args, record, io_buffer, __cu)? } }; + let __r_arr: [G; OUT_456] = { let __args: [G; IN_456] = [__v_0, __v_1, __v_2, __v_3]; let __cu = unconstrained; if let Some(result) = record.function_queries[456].get_mut(&__args[..]) { if !__cu && *result.multiplicity == G::ZERO { aiur_fn_456(__args, record, io_buffer, false)? } else { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_456] = unsafe { *(result.output.as_ptr() as *const [G; OUT_456]) }; __ret } } else { aiur_fn_456(__args, record, io_buffer, __cu)? } }; let __v_14: G = __r_arr[0]; let __v_15: G = __r_arr[1]; - let __ret: [G; OUT_459] = [__v_14, __v_15]; - if let Some(result) = record.function_queries[459].get_mut(&inp[..]) { debug_assert_eq!(result.output, &__ret[..]); if !unconstrained { *result.multiplicity += G::ONE; } } else { record.function_queries[459].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained)); }; + let __ret: [G; OUT_455] = [__v_14, __v_15]; + if let Some(result) = record.function_queries[455].get_mut(&inp[..]) { debug_assert_eq!(result.output, &__ret[..]); if !unconstrained { *result.multiplicity += G::ONE; } } else { record.function_queries[455].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained)); }; return Ok(__ret); }, } }, _ => { - let __r_arr: [G; OUT_460] = { let __args: [G; IN_460] = [__v_0, __v_1, __v_2, __v_3]; let __cu = unconstrained; if let Some(result) = record.function_queries[460].get_mut(&__args[..]) { if !__cu && *result.multiplicity == G::ZERO { aiur_fn_460(__args, record, io_buffer, false)? } else { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_460] = unsafe { *(result.output.as_ptr() as *const [G; OUT_460]) }; __ret } } else { aiur_fn_460(__args, record, io_buffer, __cu)? } }; + let __r_arr: [G; OUT_456] = { let __args: [G; IN_456] = [__v_0, __v_1, __v_2, __v_3]; let __cu = unconstrained; if let Some(result) = record.function_queries[456].get_mut(&__args[..]) { if !__cu && *result.multiplicity == G::ZERO { aiur_fn_456(__args, record, io_buffer, false)? } else { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_456] = unsafe { *(result.output.as_ptr() as *const [G; OUT_456]) }; __ret } } else { aiur_fn_456(__args, record, io_buffer, __cu)? } }; let __v_13: G = __r_arr[0]; let __v_14: G = __r_arr[1]; - let __ret: [G; OUT_459] = [__v_13, __v_14]; - if let Some(result) = record.function_queries[459].get_mut(&inp[..]) { debug_assert_eq!(result.output, &__ret[..]); if !unconstrained { *result.multiplicity += G::ONE; } } else { record.function_queries[459].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained)); }; + let __ret: [G; OUT_455] = [__v_13, __v_14]; + if let Some(result) = record.function_queries[455].get_mut(&inp[..]) { debug_assert_eq!(result.output, &__ret[..]); if !unconstrained { *result.multiplicity += G::ONE; } } else { record.function_queries[455].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained)); }; return Ok(__ret); }, } }, _ => { - let __r_arr: [G; OUT_460] = { let __args: [G; IN_460] = [__v_0, __v_1, __v_2, __v_3]; let __cu = unconstrained; if let Some(result) = record.function_queries[460].get_mut(&__args[..]) { if !__cu && *result.multiplicity == G::ZERO { aiur_fn_460(__args, record, io_buffer, false)? } else { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_460] = unsafe { *(result.output.as_ptr() as *const [G; OUT_460]) }; __ret } } else { aiur_fn_460(__args, record, io_buffer, __cu)? } }; + let __r_arr: [G; OUT_456] = { let __args: [G; IN_456] = [__v_0, __v_1, __v_2, __v_3]; let __cu = unconstrained; if let Some(result) = record.function_queries[456].get_mut(&__args[..]) { if !__cu && *result.multiplicity == G::ZERO { aiur_fn_456(__args, record, io_buffer, false)? } else { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_456] = unsafe { *(result.output.as_ptr() as *const [G; OUT_456]) }; __ret } } else { aiur_fn_456(__args, record, io_buffer, __cu)? } }; let __v_9: G = __r_arr[0]; let __v_10: G = __r_arr[1]; - let __ret: [G; OUT_459] = [__v_9, __v_10]; - if let Some(result) = record.function_queries[459].get_mut(&inp[..]) { debug_assert_eq!(result.output, &__ret[..]); if !unconstrained { *result.multiplicity += G::ONE; } } else { record.function_queries[459].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained)); }; + let __ret: [G; OUT_455] = [__v_9, __v_10]; + if let Some(result) = record.function_queries[455].get_mut(&inp[..]) { debug_assert_eq!(result.output, &__ret[..]); if !unconstrained { *result.multiplicity += G::ONE; } } else { record.function_queries[455].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained)); }; return Ok(__ret); }, } @@ -41140,15 +40866,15 @@ fn aiur_fn_459( }) } -const INPUT_SIZE_460: usize = 4; -const IN_460: usize = 4; -const OUT_460: usize = 2; -fn aiur_fn_460( - inp: [G; IN_460], +const INPUT_SIZE_456: usize = 4; +const IN_456: usize = 4; +const OUT_456: usize = 2; +fn aiur_fn_456( + inp: [G; IN_456], record: &mut QueryRecord, io_buffer: &mut IOBuffer, unconstrained: bool, -) -> Result<[G; OUT_460], ExecError> { +) -> Result<[G; OUT_456], ExecError> { stacker::maybe_grow(64 * 1024, 4 * 1024 * 1024, || { let __v_0: G = inp[0]; let __v_1: G = inp[1]; @@ -41158,54 +40884,54 @@ fn aiur_fn_460( 0u64 => { let __v_4: G = G::from_u64(0); let __v_5: G = G::from_u64(0); - let __ret: [G; OUT_460] = [__v_4, __v_5]; - if let Some(result) = record.function_queries[460].get_mut(&inp[..]) { debug_assert_eq!(result.output, &__ret[..]); if !unconstrained { *result.multiplicity += G::ONE; } } else { record.function_queries[460].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained)); }; + let __ret: [G; OUT_456] = [__v_4, __v_5]; + if let Some(result) = record.function_queries[456].get_mut(&inp[..]) { debug_assert_eq!(result.output, &__ret[..]); if !unconstrained { *result.multiplicity += G::ONE; } } else { record.function_queries[456].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained)); }; return Ok(__ret); }, _ => { let __v_4: G = G::from_u64(1); let __v_5: G = (__v_2 - __v_4); - let __r_arr: [G; OUT_424] = { let __args: [G; IN_424] = [__v_0, __v_3]; let __cu = unconstrained; if let Some(result) = record.function_queries[424].get_mut(&__args[..]) { if !__cu && *result.multiplicity == G::ZERO { aiur_fn_424(__args, record, io_buffer, false)? } else { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_424] = unsafe { *(result.output.as_ptr() as *const [G; OUT_424]) }; __ret } } else { aiur_fn_424(__args, record, io_buffer, __cu)? } }; + let __r_arr: [G; OUT_420] = { let __args: [G; IN_420] = [__v_0, __v_3]; let __cu = unconstrained; if let Some(result) = record.function_queries[420].get_mut(&__args[..]) { if !__cu && *result.multiplicity == G::ZERO { aiur_fn_420(__args, record, io_buffer, false)? } else { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_420] = unsafe { *(result.output.as_ptr() as *const [G; OUT_420]) }; __ret } } else { aiur_fn_420(__args, record, io_buffer, __cu)? } }; let __v_6: G = __r_arr[0]; - let __r_arr: [G; OUT_424] = { let __args: [G; IN_424] = [__v_1, __v_3]; let __cu = unconstrained; if let Some(result) = record.function_queries[424].get_mut(&__args[..]) { if !__cu && *result.multiplicity == G::ZERO { aiur_fn_424(__args, record, io_buffer, false)? } else { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_424] = unsafe { *(result.output.as_ptr() as *const [G; OUT_424]) }; __ret } } else { aiur_fn_424(__args, record, io_buffer, __cu)? } }; + let __r_arr: [G; OUT_420] = { let __args: [G; IN_420] = [__v_1, __v_3]; let __cu = unconstrained; if let Some(result) = record.function_queries[420].get_mut(&__args[..]) { if !__cu && *result.multiplicity == G::ZERO { aiur_fn_420(__args, record, io_buffer, false)? } else { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_420] = unsafe { *(result.output.as_ptr() as *const [G; OUT_420]) }; __ret } } else { aiur_fn_420(__args, record, io_buffer, __cu)? } }; let __v_7: G = __r_arr[0]; let __v_8: G = (__v_6 - __v_7); match __v_8.as_canonical_u64() { 0u64 => { let __v_9: G = G::from_u64(1); - let __ret: [G; OUT_460] = [__v_9, __v_5]; - if let Some(result) = record.function_queries[460].get_mut(&inp[..]) { debug_assert_eq!(result.output, &__ret[..]); if !unconstrained { *result.multiplicity += G::ONE; } } else { record.function_queries[460].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained)); }; + let __ret: [G; OUT_456] = [__v_9, __v_5]; + if let Some(result) = record.function_queries[456].get_mut(&inp[..]) { debug_assert_eq!(result.output, &__ret[..]); if !unconstrained { *result.multiplicity += G::ONE; } } else { record.function_queries[456].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained)); }; return Ok(__ret); }, _ => { - let __r_arr: [G; OUT_447] = { let __args: [G; IN_447] = [__v_6, __v_7, __v_3]; let __cu = unconstrained; if let Some(result) = record.function_queries[447].get_mut(&__args[..]) { if !__cu && *result.multiplicity == G::ZERO { aiur_fn_447(__args, record, io_buffer, false)? } else { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_447] = unsafe { *(result.output.as_ptr() as *const [G; OUT_447]) }; __ret } } else { aiur_fn_447(__args, record, io_buffer, __cu)? } }; + let __r_arr: [G; OUT_443] = { let __args: [G; IN_443] = [__v_6, __v_7, __v_3]; let __cu = unconstrained; if let Some(result) = record.function_queries[443].get_mut(&__args[..]) { if !__cu && *result.multiplicity == G::ZERO { aiur_fn_443(__args, record, io_buffer, false)? } else { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_443] = unsafe { *(result.output.as_ptr() as *const [G; OUT_443]) }; __ret } } else { aiur_fn_443(__args, record, io_buffer, __cu)? } }; let __v_9: G = __r_arr[0]; let __v_10: G = __r_arr[1]; match __v_9.as_canonical_u64() { 1u64 => { - let __ret: [G; OUT_460] = [__v_10, __v_5]; - if let Some(result) = record.function_queries[460].get_mut(&inp[..]) { debug_assert_eq!(result.output, &__ret[..]); if !unconstrained { *result.multiplicity += G::ONE; } } else { record.function_queries[460].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained)); }; + let __ret: [G; OUT_456] = [__v_10, __v_5]; + if let Some(result) = record.function_queries[456].get_mut(&inp[..]) { debug_assert_eq!(result.output, &__ret[..]); if !unconstrained { *result.multiplicity += G::ONE; } } else { record.function_queries[456].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained)); }; return Ok(__ret); }, _ => { let __v_11: G = G::from_u64(8); - let __r_arr: [G; OUT_473] = { let __args: [G; IN_473] = [__v_6, __v_7, __v_11, __v_3]; let __cu = unconstrained; if let Some(result) = record.function_queries[473].get_mut(&__args[..]) { if !__cu && *result.multiplicity == G::ZERO { aiur_fn_473(__args, record, io_buffer, false)? } else { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_473] = unsafe { *(result.output.as_ptr() as *const [G; OUT_473]) }; __ret } } else { aiur_fn_473(__args, record, io_buffer, __cu)? } }; + let __r_arr: [G; OUT_469] = { let __args: [G; IN_469] = [__v_6, __v_7, __v_11, __v_3]; let __cu = unconstrained; if let Some(result) = record.function_queries[469].get_mut(&__args[..]) { if !__cu && *result.multiplicity == G::ZERO { aiur_fn_469(__args, record, io_buffer, false)? } else { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_469] = unsafe { *(result.output.as_ptr() as *const [G; OUT_469]) }; __ret } } else { aiur_fn_469(__args, record, io_buffer, __cu)? } }; let __v_12: G = __r_arr[0]; let __v_13: G = __r_arr[1]; let __v_14: G = __r_arr[2]; match __v_12.as_canonical_u64() { 1u64 => { let __v_15: G = G::from_u64(1); - let __ret: [G; OUT_460] = [__v_15, __v_5]; - if let Some(result) = record.function_queries[460].get_mut(&inp[..]) { debug_assert_eq!(result.output, &__ret[..]); if !unconstrained { *result.multiplicity += G::ONE; } } else { record.function_queries[460].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained)); }; + let __ret: [G; OUT_456] = [__v_15, __v_5]; + if let Some(result) = record.function_queries[456].get_mut(&inp[..]) { debug_assert_eq!(result.output, &__ret[..]); if !unconstrained { *result.multiplicity += G::ONE; } } else { record.function_queries[456].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained)); }; return Ok(__ret); }, _ => { - let __r_arr: [G; OUT_459] = { let __args: [G; IN_459] = [__v_13, __v_14, __v_5, __v_3]; let __cu = unconstrained; if let Some(result) = record.function_queries[459].get_mut(&__args[..]) { if !__cu && *result.multiplicity == G::ZERO { aiur_fn_459(__args, record, io_buffer, false)? } else { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_459] = unsafe { *(result.output.as_ptr() as *const [G; OUT_459]) }; __ret } } else { aiur_fn_459(__args, record, io_buffer, __cu)? } }; + let __r_arr: [G; OUT_455] = { let __args: [G; IN_455] = [__v_13, __v_14, __v_5, __v_3]; let __cu = unconstrained; if let Some(result) = record.function_queries[455].get_mut(&__args[..]) { if !__cu && *result.multiplicity == G::ZERO { aiur_fn_455(__args, record, io_buffer, false)? } else { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_455] = unsafe { *(result.output.as_ptr() as *const [G; OUT_455]) }; __ret } } else { aiur_fn_455(__args, record, io_buffer, __cu)? } }; let __v_15: G = __r_arr[0]; let __v_16: G = __r_arr[1]; - let __ret: [G; OUT_460] = [__v_15, __v_16]; - if let Some(result) = record.function_queries[460].get_mut(&inp[..]) { debug_assert_eq!(result.output, &__ret[..]); if !unconstrained { *result.multiplicity += G::ONE; } } else { record.function_queries[460].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained)); }; + let __ret: [G; OUT_456] = [__v_15, __v_16]; + if let Some(result) = record.function_queries[456].get_mut(&inp[..]) { debug_assert_eq!(result.output, &__ret[..]); if !unconstrained { *result.multiplicity += G::ONE; } } else { record.function_queries[456].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained)); }; return Ok(__ret); }, } @@ -41218,96 +40944,96 @@ fn aiur_fn_460( }) } -const INPUT_SIZE_461: usize = 3; -const IN_461: usize = 3; -const OUT_461: usize = 1; -fn aiur_fn_461( - inp: [G; IN_461], +const INPUT_SIZE_457: usize = 3; +const IN_457: usize = 3; +const OUT_457: usize = 1; +fn aiur_fn_457( + inp: [G; IN_457], record: &mut QueryRecord, io_buffer: &mut IOBuffer, unconstrained: bool, -) -> Result<[G; OUT_461], ExecError> { +) -> Result<[G; OUT_457], ExecError> { stacker::maybe_grow(64 * 1024, 4 * 1024 * 1024, || { let __v_0: G = inp[0]; let __v_1: G = inp[1]; let __v_2: G = inp[2]; - let __r_arr: [G; OUT_418] = { let __args: [G; IN_418] = [__v_0, __v_2]; let __cu = unconstrained; if let Some(result) = record.function_queries[418].get_mut(&__args[..]) { if !__cu && *result.multiplicity == G::ZERO { aiur_fn_418(__args, record, io_buffer, false)? } else { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_418] = unsafe { *(result.output.as_ptr() as *const [G; OUT_418]) }; __ret } } else { aiur_fn_418(__args, record, io_buffer, __cu)? } }; + let __r_arr: [G; OUT_414] = { let __args: [G; IN_414] = [__v_0, __v_2]; let __cu = unconstrained; if let Some(result) = record.function_queries[414].get_mut(&__args[..]) { if !__cu && *result.multiplicity == G::ZERO { aiur_fn_414(__args, record, io_buffer, false)? } else { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_414] = unsafe { *(result.output.as_ptr() as *const [G; OUT_414]) }; __ret } } else { aiur_fn_414(__args, record, io_buffer, __cu)? } }; let __v_3: G = __r_arr[0]; - let __r_arr: [G; OUT_418] = { let __args: [G; IN_418] = [__v_1, __v_2]; let __cu = unconstrained; if let Some(result) = record.function_queries[418].get_mut(&__args[..]) { if !__cu && *result.multiplicity == G::ZERO { aiur_fn_418(__args, record, io_buffer, false)? } else { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_418] = unsafe { *(result.output.as_ptr() as *const [G; OUT_418]) }; __ret } } else { aiur_fn_418(__args, record, io_buffer, __cu)? } }; + let __r_arr: [G; OUT_414] = { let __args: [G; IN_414] = [__v_1, __v_2]; let __cu = unconstrained; if let Some(result) = record.function_queries[414].get_mut(&__args[..]) { if !__cu && *result.multiplicity == G::ZERO { aiur_fn_414(__args, record, io_buffer, false)? } else { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_414] = unsafe { *(result.output.as_ptr() as *const [G; OUT_414]) }; __ret } } else { aiur_fn_414(__args, record, io_buffer, __cu)? } }; let __v_4: G = __r_arr[0]; let __v_5: G = (__v_3 - __v_4); match __v_5.as_canonical_u64() { 0u64 => { let __v_6: G = G::from_u64(1); - let __ret: [G; OUT_461] = [__v_6]; - if let Some(result) = record.function_queries[461].get_mut(&inp[..]) { debug_assert_eq!(result.output, &__ret[..]); if !unconstrained { *result.multiplicity += G::ONE; } } else { record.function_queries[461].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained)); }; + let __ret: [G; OUT_457] = [__v_6]; + if let Some(result) = record.function_queries[457].get_mut(&inp[..]) { debug_assert_eq!(result.output, &__ret[..]); if !unconstrained { *result.multiplicity += G::ONE; } } else { record.function_queries[457].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained)); }; return Ok(__ret); }, _ => { - let __r_arr: [G; OUT_468] = { let __args: [G; IN_468] = [__v_3, __v_4, __v_2]; let __cu = unconstrained; if let Some(result) = record.function_queries[468].get_mut(&__args[..]) { if !__cu && *result.multiplicity == G::ZERO { aiur_fn_468(__args, record, io_buffer, false)? } else { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_468] = unsafe { *(result.output.as_ptr() as *const [G; OUT_468]) }; __ret } } else { aiur_fn_468(__args, record, io_buffer, __cu)? } }; + let __r_arr: [G; OUT_464] = { let __args: [G; IN_464] = [__v_3, __v_4, __v_2]; let __cu = unconstrained; if let Some(result) = record.function_queries[464].get_mut(&__args[..]) { if !__cu && *result.multiplicity == G::ZERO { aiur_fn_464(__args, record, io_buffer, false)? } else { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_464] = unsafe { *(result.output.as_ptr() as *const [G; OUT_464]) }; __ret } } else { aiur_fn_464(__args, record, io_buffer, __cu)? } }; let __v_6: G = __r_arr[0]; match __v_6.as_canonical_u64() { 1u64 => { let __v_7: G = G::from_u64(1); - let __ret: [G; OUT_461] = [__v_7]; - if let Some(result) = record.function_queries[461].get_mut(&inp[..]) { debug_assert_eq!(result.output, &__ret[..]); if !unconstrained { *result.multiplicity += G::ONE; } } else { record.function_queries[461].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained)); }; + let __ret: [G; OUT_457] = [__v_7]; + if let Some(result) = record.function_queries[457].get_mut(&inp[..]) { debug_assert_eq!(result.output, &__ret[..]); if !unconstrained { *result.multiplicity += G::ONE; } } else { record.function_queries[457].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained)); }; return Ok(__ret); }, _ => { - let __r_arr: [G; OUT_466] = { let __args: [G; IN_466] = [__v_3, __v_4, __v_2]; let __cu = unconstrained; if let Some(result) = record.function_queries[466].get_mut(&__args[..]) { if !__cu && *result.multiplicity == G::ZERO { aiur_fn_466(__args, record, io_buffer, false)? } else { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_466] = unsafe { *(result.output.as_ptr() as *const [G; OUT_466]) }; __ret } } else { aiur_fn_466(__args, record, io_buffer, __cu)? } }; + let __r_arr: [G; OUT_462] = { let __args: [G; IN_462] = [__v_3, __v_4, __v_2]; let __cu = unconstrained; if let Some(result) = record.function_queries[462].get_mut(&__args[..]) { if !__cu && *result.multiplicity == G::ZERO { aiur_fn_462(__args, record, io_buffer, false)? } else { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_462] = unsafe { *(result.output.as_ptr() as *const [G; OUT_462]) }; __ret } } else { aiur_fn_462(__args, record, io_buffer, __cu)? } }; let __v_7: G = __r_arr[0]; match __v_7.as_canonical_u64() { 1u64 => { let __v_8: G = G::from_u64(1); - let __ret: [G; OUT_461] = [__v_8]; - if let Some(result) = record.function_queries[461].get_mut(&inp[..]) { debug_assert_eq!(result.output, &__ret[..]); if !unconstrained { *result.multiplicity += G::ONE; } } else { record.function_queries[461].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained)); }; + let __ret: [G; OUT_457] = [__v_8]; + if let Some(result) = record.function_queries[457].get_mut(&inp[..]) { debug_assert_eq!(result.output, &__ret[..]); if !unconstrained { *result.multiplicity += G::ONE; } } else { record.function_queries[457].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained)); }; return Ok(__ret); }, _ => { - let __r_arr: [G; OUT_462] = { let __args: [G; IN_462] = [__v_3, __v_4, __v_2]; let __cu = unconstrained; if let Some(result) = record.function_queries[462].get_mut(&__args[..]) { if !__cu && *result.multiplicity == G::ZERO { aiur_fn_462(__args, record, io_buffer, false)? } else { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_462] = unsafe { *(result.output.as_ptr() as *const [G; OUT_462]) }; __ret } } else { aiur_fn_462(__args, record, io_buffer, __cu)? } }; + let __r_arr: [G; OUT_458] = { let __args: [G; IN_458] = [__v_3, __v_4, __v_2]; let __cu = unconstrained; if let Some(result) = record.function_queries[458].get_mut(&__args[..]) { if !__cu && *result.multiplicity == G::ZERO { aiur_fn_458(__args, record, io_buffer, false)? } else { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_458] = unsafe { *(result.output.as_ptr() as *const [G; OUT_458]) }; __ret } } else { aiur_fn_458(__args, record, io_buffer, __cu)? } }; let __v_8: G = __r_arr[0]; match __v_8.as_canonical_u64() { 1u64 => { let __v_9: G = G::from_u64(1); - let __ret: [G; OUT_461] = [__v_9]; - if let Some(result) = record.function_queries[461].get_mut(&inp[..]) { debug_assert_eq!(result.output, &__ret[..]); if !unconstrained { *result.multiplicity += G::ONE; } } else { record.function_queries[461].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained)); }; + let __ret: [G; OUT_457] = [__v_9]; + if let Some(result) = record.function_queries[457].get_mut(&inp[..]) { debug_assert_eq!(result.output, &__ret[..]); if !unconstrained { *result.multiplicity += G::ONE; } } else { record.function_queries[457].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained)); }; return Ok(__ret); }, _ => { - let __r_arr: [G; OUT_462] = { let __args: [G; IN_462] = [__v_4, __v_3, __v_2]; let __cu = unconstrained; if let Some(result) = record.function_queries[462].get_mut(&__args[..]) { if !__cu && *result.multiplicity == G::ZERO { aiur_fn_462(__args, record, io_buffer, false)? } else { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_462] = unsafe { *(result.output.as_ptr() as *const [G; OUT_462]) }; __ret } } else { aiur_fn_462(__args, record, io_buffer, __cu)? } }; + let __r_arr: [G; OUT_458] = { let __args: [G; IN_458] = [__v_4, __v_3, __v_2]; let __cu = unconstrained; if let Some(result) = record.function_queries[458].get_mut(&__args[..]) { if !__cu && *result.multiplicity == G::ZERO { aiur_fn_458(__args, record, io_buffer, false)? } else { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_458] = unsafe { *(result.output.as_ptr() as *const [G; OUT_458]) }; __ret } } else { aiur_fn_458(__args, record, io_buffer, __cu)? } }; let __v_9: G = __r_arr[0]; match __v_9.as_canonical_u64() { 1u64 => { let __v_10: G = G::from_u64(1); - let __ret: [G; OUT_461] = [__v_10]; - if let Some(result) = record.function_queries[461].get_mut(&inp[..]) { debug_assert_eq!(result.output, &__ret[..]); if !unconstrained { *result.multiplicity += G::ONE; } } else { record.function_queries[461].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained)); }; + let __ret: [G; OUT_457] = [__v_10]; + if let Some(result) = record.function_queries[457].get_mut(&inp[..]) { debug_assert_eq!(result.output, &__ret[..]); if !unconstrained { *result.multiplicity += G::ONE; } } else { record.function_queries[457].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained)); }; return Ok(__ret); }, _ => { - let __r_arr: [G; OUT_447] = { let __args: [G; IN_447] = [__v_3, __v_4, __v_2]; let __cu = unconstrained; if let Some(result) = record.function_queries[447].get_mut(&__args[..]) { if !__cu && *result.multiplicity == G::ZERO { aiur_fn_447(__args, record, io_buffer, false)? } else { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_447] = unsafe { *(result.output.as_ptr() as *const [G; OUT_447]) }; __ret } } else { aiur_fn_447(__args, record, io_buffer, __cu)? } }; + let __r_arr: [G; OUT_443] = { let __args: [G; IN_443] = [__v_3, __v_4, __v_2]; let __cu = unconstrained; if let Some(result) = record.function_queries[443].get_mut(&__args[..]) { if !__cu && *result.multiplicity == G::ZERO { aiur_fn_443(__args, record, io_buffer, false)? } else { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_443] = unsafe { *(result.output.as_ptr() as *const [G; OUT_443]) }; __ret } } else { aiur_fn_443(__args, record, io_buffer, __cu)? } }; let __v_10: G = __r_arr[0]; let __v_11: G = __r_arr[1]; match __v_10.as_canonical_u64() { 1u64 => { - let __ret: [G; OUT_461] = [__v_11]; - if let Some(result) = record.function_queries[461].get_mut(&inp[..]) { debug_assert_eq!(result.output, &__ret[..]); if !unconstrained { *result.multiplicity += G::ONE; } } else { record.function_queries[461].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained)); }; + let __ret: [G; OUT_457] = [__v_11]; + if let Some(result) = record.function_queries[457].get_mut(&inp[..]) { debug_assert_eq!(result.output, &__ret[..]); if !unconstrained { *result.multiplicity += G::ONE; } } else { record.function_queries[457].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained)); }; return Ok(__ret); }, _ => { - let __r_arr: [G; OUT_465] = { let __args: [G; IN_465] = [__v_3, __v_4, __v_2]; let __cu = unconstrained; if let Some(result) = record.function_queries[465].get_mut(&__args[..]) { if !__cu && *result.multiplicity == G::ZERO { aiur_fn_465(__args, record, io_buffer, false)? } else { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_465] = unsafe { *(result.output.as_ptr() as *const [G; OUT_465]) }; __ret } } else { aiur_fn_465(__args, record, io_buffer, __cu)? } }; + let __r_arr: [G; OUT_461] = { let __args: [G; IN_461] = [__v_3, __v_4, __v_2]; let __cu = unconstrained; if let Some(result) = record.function_queries[461].get_mut(&__args[..]) { if !__cu && *result.multiplicity == G::ZERO { aiur_fn_461(__args, record, io_buffer, false)? } else { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_461] = unsafe { *(result.output.as_ptr() as *const [G; OUT_461]) }; __ret } } else { aiur_fn_461(__args, record, io_buffer, __cu)? } }; let __v_12: G = __r_arr[0]; match __v_12.as_canonical_u64() { 1u64 => { let __v_13: G = G::from_u64(1); - let __ret: [G; OUT_461] = [__v_13]; - if let Some(result) = record.function_queries[461].get_mut(&inp[..]) { debug_assert_eq!(result.output, &__ret[..]); if !unconstrained { *result.multiplicity += G::ONE; } } else { record.function_queries[461].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained)); }; + let __ret: [G; OUT_457] = [__v_13]; + if let Some(result) = record.function_queries[457].get_mut(&inp[..]) { debug_assert_eq!(result.output, &__ret[..]); if !unconstrained { *result.multiplicity += G::ONE; } } else { record.function_queries[457].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained)); }; return Ok(__ret); }, _ => { - let __r_arr: [G; OUT_471] = { let __args: [G; IN_471] = [__v_3, __v_4, __v_2]; let __cu = unconstrained; if let Some(result) = record.function_queries[471].get_mut(&__args[..]) { if !__cu && *result.multiplicity == G::ZERO { aiur_fn_471(__args, record, io_buffer, false)? } else { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_471] = unsafe { *(result.output.as_ptr() as *const [G; OUT_471]) }; __ret } } else { aiur_fn_471(__args, record, io_buffer, __cu)? } }; + let __r_arr: [G; OUT_467] = { let __args: [G; IN_467] = [__v_3, __v_4, __v_2]; let __cu = unconstrained; if let Some(result) = record.function_queries[467].get_mut(&__args[..]) { if !__cu && *result.multiplicity == G::ZERO { aiur_fn_467(__args, record, io_buffer, false)? } else { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_467] = unsafe { *(result.output.as_ptr() as *const [G; OUT_467]) }; __ret } } else { aiur_fn_467(__args, record, io_buffer, __cu)? } }; let __v_13: G = __r_arr[0]; - let __ret: [G; OUT_461] = [__v_13]; - if let Some(result) = record.function_queries[461].get_mut(&inp[..]) { debug_assert_eq!(result.output, &__ret[..]); if !unconstrained { *result.multiplicity += G::ONE; } } else { record.function_queries[461].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained)); }; + let __ret: [G; OUT_457] = [__v_13]; + if let Some(result) = record.function_queries[457].get_mut(&inp[..]) { debug_assert_eq!(result.output, &__ret[..]); if !unconstrained { *result.multiplicity += G::ONE; } } else { record.function_queries[457].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained)); }; return Ok(__ret); }, } @@ -41326,15 +41052,15 @@ fn aiur_fn_461( }) } -const INPUT_SIZE_462: usize = 3; -const IN_462: usize = 3; -const OUT_462: usize = 1; -fn aiur_fn_462( - inp: [G; IN_462], +const INPUT_SIZE_458: usize = 3; +const IN_458: usize = 3; +const OUT_458: usize = 1; +fn aiur_fn_458( + inp: [G; IN_458], record: &mut QueryRecord, io_buffer: &mut IOBuffer, unconstrained: bool, -) -> Result<[G; OUT_462], ExecError> { +) -> Result<[G; OUT_458], ExecError> { stacker::maybe_grow(64 * 1024, 4 * 1024 * 1024, || { let __v_0: G = inp[0]; let __v_1: G = inp[1]; @@ -41349,7 +41075,7 @@ fn aiur_fn_462( let __v_8: G = __loaded[3]; match __v_5.as_canonical_u64() { 2u64 => { - let __r_arr: [G; OUT_287] = { let __args: [G; IN_287] = [__v_6]; let __cu = unconstrained; if let Some(result) = record.function_queries[287].get_mut(&__args[..]) { if !__cu && *result.multiplicity == G::ZERO { aiur_fn_287(__args, record, io_buffer, false)? } else { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_287] = unsafe { *(result.output.as_ptr() as *const [G; OUT_287]) }; __ret } } else { aiur_fn_287(__args, record, io_buffer, __cu)? } }; + let __r_arr: [G; OUT_283] = { let __args: [G; IN_283] = [__v_6]; let __cu = unconstrained; if let Some(result) = record.function_queries[283].get_mut(&__args[..]) { if !__cu && *result.multiplicity == G::ZERO { aiur_fn_283(__args, record, io_buffer, false)? } else { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_283] = unsafe { *(result.output.as_ptr() as *const [G; OUT_283]) }; __ret } } else { aiur_fn_283(__args, record, io_buffer, __cu)? } }; let __v_9: G = __r_arr[0]; let __loaded: [G; 12] = { let __mq = record.memory_queries.get_mut(&12).ok_or(ExecError::InvalidMemorySize(12))?; let __ptr_u64 = __v_9.as_canonical_u64(); let __ptr_usize = usize::try_from(__ptr_u64).ok().ok_or(ExecError::PointerTooLarge(__ptr_u64))?; let (__args, __mult) = __mq.get_index_mut(__ptr_usize).ok_or(ExecError::UnboundPointer { ptr: __ptr_u64, size: 12 })?; if !unconstrained { *__mult += G::ONE; } let __arr: [G; 12] = __args[..12].try_into().unwrap(); __arr }; let __v_10: G = __loaded[0]; @@ -41366,13 +41092,13 @@ fn aiur_fn_462( let __v_21: G = __loaded[11]; match __v_10.as_canonical_u64() { 6u64 => { - let __r_arr: [G; OUT_764] = { let __args: [G; IN_764] = [__v_4]; let __cu = unconstrained; if let Some(result) = record.function_queries[764].get_mut(&__args[..]) { if !__cu && *result.multiplicity == G::ZERO { aiur_fn_764(__args, record, io_buffer, false)? } else { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_764] = unsafe { *(result.output.as_ptr() as *const [G; OUT_764]) }; __ret } } else { aiur_fn_764(__args, record, io_buffer, __cu)? } }; + let __r_arr: [G; OUT_760] = { let __args: [G; IN_760] = [__v_4]; let __cu = unconstrained; if let Some(result) = record.function_queries[760].get_mut(&__args[..]) { if !__cu && *result.multiplicity == G::ZERO { aiur_fn_760(__args, record, io_buffer, false)? } else { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_760] = unsafe { *(result.output.as_ptr() as *const [G; OUT_760]) }; __ret } } else { aiur_fn_760(__args, record, io_buffer, __cu)? } }; let __v_22: G = __r_arr[0]; let __v_23: G = (__v_16 + __v_17); let __v_24: G = (__v_22 - __v_23); match __v_24.as_canonical_u64() { 0u64 => { - let __r_arr: [G; OUT_289] = { let __args: [G; IN_289] = [__v_13, __v_14]; let __cu = unconstrained; if let Some(result) = record.function_queries[289].get_mut(&__args[..]) { if !__cu && *result.multiplicity == G::ZERO { aiur_fn_289(__args, record, io_buffer, false)? } else { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_289] = unsafe { *(result.output.as_ptr() as *const [G; OUT_289]) }; __ret } } else { aiur_fn_289(__args, record, io_buffer, __cu)? } }; + let __r_arr: [G; OUT_285] = { let __args: [G; IN_285] = [__v_13, __v_14]; let __cu = unconstrained; if let Some(result) = record.function_queries[285].get_mut(&__args[..]) { if !__cu && *result.multiplicity == G::ZERO { aiur_fn_285(__args, record, io_buffer, false)? } else { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_285] = unsafe { *(result.output.as_ptr() as *const [G; OUT_285]) }; __ret } } else { aiur_fn_285(__args, record, io_buffer, __cu)? } }; let __v_25: G = __r_arr[0]; let __loaded: [G; 12] = { let __mq = record.memory_queries.get_mut(&12).ok_or(ExecError::InvalidMemorySize(12))?; let __ptr_u64 = __v_25.as_canonical_u64(); let __ptr_usize = usize::try_from(__ptr_u64).ok().ok_or(ExecError::PointerTooLarge(__ptr_u64))?; let (__args, __mult) = __mq.get_index_mut(__ptr_usize).ok_or(ExecError::UnboundPointer { ptr: __ptr_u64, size: 12 })?; if !unconstrained { *__mult += G::ONE; } let __arr: [G; 12] = __args[..12].try_into().unwrap(); __arr }; let __v_26: G = __loaded[0]; @@ -41397,42 +41123,42 @@ fn aiur_fn_462( match __v_42.as_canonical_u64() { 0u64 => { let __v_43: G = G::from_u64(0); - let __ret: [G; OUT_462] = [__v_43]; - if let Some(result) = record.function_queries[462].get_mut(&inp[..]) { debug_assert_eq!(result.output, &__ret[..]); if !unconstrained { *result.multiplicity += G::ONE; } } else { record.function_queries[462].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained)); }; + let __ret: [G; OUT_458] = [__v_43]; + if let Some(result) = record.function_queries[458].get_mut(&inp[..]) { debug_assert_eq!(result.output, &__ret[..]); if !unconstrained { *result.multiplicity += G::ONE; } } else { record.function_queries[458].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained)); }; return Ok(__ret); }, _ => { - let __r_arr: [G; OUT_464] = { let __args: [G; IN_464] = [__v_13, __v_14]; let __cu = unconstrained; if let Some(result) = record.function_queries[464].get_mut(&__args[..]) { if !__cu && *result.multiplicity == G::ZERO { aiur_fn_464(__args, record, io_buffer, false)? } else { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_464] = unsafe { *(result.output.as_ptr() as *const [G; OUT_464]) }; __ret } } else { aiur_fn_464(__args, record, io_buffer, __cu)? } }; + let __r_arr: [G; OUT_460] = { let __args: [G; IN_460] = [__v_13, __v_14]; let __cu = unconstrained; if let Some(result) = record.function_queries[460].get_mut(&__args[..]) { if !__cu && *result.multiplicity == G::ZERO { aiur_fn_460(__args, record, io_buffer, false)? } else { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_460] = unsafe { *(result.output.as_ptr() as *const [G; OUT_460]) }; __ret } } else { aiur_fn_460(__args, record, io_buffer, __cu)? } }; let __v_43: G = __r_arr[0]; - let __r_arr: [G; OUT_411] = { let __args: [G; IN_411] = [__v_43]; let __cu = unconstrained; if let Some(result) = record.function_queries[411].get_mut(&__args[..]) { if !__cu && *result.multiplicity == G::ZERO { aiur_fn_411(__args, record, io_buffer, false)? } else { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_411] = unsafe { *(result.output.as_ptr() as *const [G; OUT_411]) }; __ret } } else { aiur_fn_411(__args, record, io_buffer, __cu)? } }; + let __r_arr: [G; OUT_407] = { let __args: [G; IN_407] = [__v_43]; let __cu = unconstrained; if let Some(result) = record.function_queries[407].get_mut(&__args[..]) { if !__cu && *result.multiplicity == G::ZERO { aiur_fn_407(__args, record, io_buffer, false)? } else { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_407] = unsafe { *(result.output.as_ptr() as *const [G; OUT_407]) }; __ret } } else { aiur_fn_407(__args, record, io_buffer, __cu)? } }; let __v_44: G = __r_arr[0]; match __v_44.as_canonical_u64() { 1u64 => { let __v_45: G = G::from_u64(0); - let __ret: [G; OUT_462] = [__v_45]; - if let Some(result) = record.function_queries[462].get_mut(&inp[..]) { debug_assert_eq!(result.output, &__ret[..]); if !unconstrained { *result.multiplicity += G::ONE; } } else { record.function_queries[462].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained)); }; + let __ret: [G; OUT_458] = [__v_45]; + if let Some(result) = record.function_queries[458].get_mut(&inp[..]) { debug_assert_eq!(result.output, &__ret[..]); if !unconstrained { *result.multiplicity += G::ONE; } } else { record.function_queries[458].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained)); }; return Ok(__ret); }, _ => { - let __r_arr: [G; OUT_433] = { let __args: [G; IN_433] = [__v_0, __v_2]; let __cu = unconstrained; if let Some(result) = record.function_queries[433].get_mut(&__args[..]) { if !__cu && *result.multiplicity == G::ZERO { aiur_fn_433(__args, record, io_buffer, false)? } else { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_433] = unsafe { *(result.output.as_ptr() as *const [G; OUT_433]) }; __ret } } else { aiur_fn_433(__args, record, io_buffer, __cu)? } }; + let __r_arr: [G; OUT_429] = { let __args: [G; IN_429] = [__v_0, __v_2]; let __cu = unconstrained; if let Some(result) = record.function_queries[429].get_mut(&__args[..]) { if !__cu && *result.multiplicity == G::ZERO { aiur_fn_429(__args, record, io_buffer, false)? } else { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_429] = unsafe { *(result.output.as_ptr() as *const [G; OUT_429]) }; __ret } } else { aiur_fn_429(__args, record, io_buffer, __cu)? } }; let __v_45: G = __r_arr[0]; - let __r_arr: [G; OUT_433] = { let __args: [G; IN_433] = [__v_1, __v_2]; let __cu = unconstrained; if let Some(result) = record.function_queries[433].get_mut(&__args[..]) { if !__cu && *result.multiplicity == G::ZERO { aiur_fn_433(__args, record, io_buffer, false)? } else { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_433] = unsafe { *(result.output.as_ptr() as *const [G; OUT_433]) }; __ret } } else { aiur_fn_433(__args, record, io_buffer, __cu)? } }; + let __r_arr: [G; OUT_429] = { let __args: [G; IN_429] = [__v_1, __v_2]; let __cu = unconstrained; if let Some(result) = record.function_queries[429].get_mut(&__args[..]) { if !__cu && *result.multiplicity == G::ZERO { aiur_fn_429(__args, record, io_buffer, false)? } else { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_429] = unsafe { *(result.output.as_ptr() as *const [G; OUT_429]) }; __ret } } else { aiur_fn_429(__args, record, io_buffer, __cu)? } }; let __v_46: G = __r_arr[0]; - let __r_arr: [G; OUT_439] = { let __args: [G; IN_439] = [__v_45, __v_46, __v_2]; let __cu = unconstrained; if let Some(result) = record.function_queries[439].get_mut(&__args[..]) { if !__cu && *result.multiplicity == G::ZERO { aiur_fn_439(__args, record, io_buffer, false)? } else { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_439] = unsafe { *(result.output.as_ptr() as *const [G; OUT_439]) }; __ret } } else { aiur_fn_439(__args, record, io_buffer, __cu)? } }; + let __r_arr: [G; OUT_435] = { let __args: [G; IN_435] = [__v_45, __v_46, __v_2]; let __cu = unconstrained; if let Some(result) = record.function_queries[435].get_mut(&__args[..]) { if !__cu && *result.multiplicity == G::ZERO { aiur_fn_435(__args, record, io_buffer, false)? } else { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_435] = unsafe { *(result.output.as_ptr() as *const [G; OUT_435]) }; __ret } } else { aiur_fn_435(__args, record, io_buffer, __cu)? } }; let __v_47: G = __r_arr[0]; match __v_47.as_canonical_u64() { 0u64 => { let __v_48: G = G::from_u64(0); - let __ret: [G; OUT_462] = [__v_48]; - if let Some(result) = record.function_queries[462].get_mut(&inp[..]) { debug_assert_eq!(result.output, &__ret[..]); if !unconstrained { *result.multiplicity += G::ONE; } } else { record.function_queries[462].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained)); }; + let __ret: [G; OUT_458] = [__v_48]; + if let Some(result) = record.function_queries[458].get_mut(&inp[..]) { debug_assert_eq!(result.output, &__ret[..]); if !unconstrained { *result.multiplicity += G::ONE; } } else { record.function_queries[458].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained)); }; return Ok(__ret); }, _ => { let __v_48: G = G::from_u64(0); - let __r_arr: [G; OUT_463] = { let __args: [G; IN_463] = [__v_43, __v_16, __v_17, __v_0, __v_4, __v_48, __v_2]; let __cu = unconstrained; if let Some(result) = record.function_queries[463].get_mut(&__args[..]) { if !__cu && *result.multiplicity == G::ZERO { aiur_fn_463(__args, record, io_buffer, false)? } else { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_463] = unsafe { *(result.output.as_ptr() as *const [G; OUT_463]) }; __ret } } else { aiur_fn_463(__args, record, io_buffer, __cu)? } }; + let __r_arr: [G; OUT_459] = { let __args: [G; IN_459] = [__v_43, __v_16, __v_17, __v_0, __v_4, __v_48, __v_2]; let __cu = unconstrained; if let Some(result) = record.function_queries[459].get_mut(&__args[..]) { if !__cu && *result.multiplicity == G::ZERO { aiur_fn_459(__args, record, io_buffer, false)? } else { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_459] = unsafe { *(result.output.as_ptr() as *const [G; OUT_459]) }; __ret } } else { aiur_fn_459(__args, record, io_buffer, __cu)? } }; let __v_49: G = __r_arr[0]; - let __ret: [G; OUT_462] = [__v_49]; - if let Some(result) = record.function_queries[462].get_mut(&inp[..]) { debug_assert_eq!(result.output, &__ret[..]); if !unconstrained { *result.multiplicity += G::ONE; } } else { record.function_queries[462].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained)); }; + let __ret: [G; OUT_458] = [__v_49]; + if let Some(result) = record.function_queries[458].get_mut(&inp[..]) { debug_assert_eq!(result.output, &__ret[..]); if !unconstrained { *result.multiplicity += G::ONE; } } else { record.function_queries[458].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained)); }; return Ok(__ret); }, } @@ -41443,47 +41169,47 @@ fn aiur_fn_462( }, _ => { let __v_38: G = G::from_u64(0); - let __ret: [G; OUT_462] = [__v_38]; - if let Some(result) = record.function_queries[462].get_mut(&inp[..]) { debug_assert_eq!(result.output, &__ret[..]); if !unconstrained { *result.multiplicity += G::ONE; } } else { record.function_queries[462].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained)); }; + let __ret: [G; OUT_458] = [__v_38]; + if let Some(result) = record.function_queries[458].get_mut(&inp[..]) { debug_assert_eq!(result.output, &__ret[..]); if !unconstrained { *result.multiplicity += G::ONE; } } else { record.function_queries[458].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained)); }; return Ok(__ret); }, } }, _ => { let __v_25: G = G::from_u64(0); - let __ret: [G; OUT_462] = [__v_25]; - if let Some(result) = record.function_queries[462].get_mut(&inp[..]) { debug_assert_eq!(result.output, &__ret[..]); if !unconstrained { *result.multiplicity += G::ONE; } } else { record.function_queries[462].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained)); }; + let __ret: [G; OUT_458] = [__v_25]; + if let Some(result) = record.function_queries[458].get_mut(&inp[..]) { debug_assert_eq!(result.output, &__ret[..]); if !unconstrained { *result.multiplicity += G::ONE; } } else { record.function_queries[458].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained)); }; return Ok(__ret); }, } }, _ => { let __v_22: G = G::from_u64(0); - let __ret: [G; OUT_462] = [__v_22]; - if let Some(result) = record.function_queries[462].get_mut(&inp[..]) { debug_assert_eq!(result.output, &__ret[..]); if !unconstrained { *result.multiplicity += G::ONE; } } else { record.function_queries[462].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained)); }; + let __ret: [G; OUT_458] = [__v_22]; + if let Some(result) = record.function_queries[458].get_mut(&inp[..]) { debug_assert_eq!(result.output, &__ret[..]); if !unconstrained { *result.multiplicity += G::ONE; } } else { record.function_queries[458].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained)); }; return Ok(__ret); }, } }, _ => { let __v_9: G = G::from_u64(0); - let __ret: [G; OUT_462] = [__v_9]; - if let Some(result) = record.function_queries[462].get_mut(&inp[..]) { debug_assert_eq!(result.output, &__ret[..]); if !unconstrained { *result.multiplicity += G::ONE; } } else { record.function_queries[462].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained)); }; + let __ret: [G; OUT_458] = [__v_9]; + if let Some(result) = record.function_queries[458].get_mut(&inp[..]) { debug_assert_eq!(result.output, &__ret[..]); if !unconstrained { *result.multiplicity += G::ONE; } } else { record.function_queries[458].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained)); }; return Ok(__ret); }, } }) } -const INPUT_SIZE_463: usize = 7; -const IN_463: usize = 7; -const OUT_463: usize = 1; -fn aiur_fn_463( - inp: [G; IN_463], +const INPUT_SIZE_459: usize = 7; +const IN_459: usize = 7; +const OUT_459: usize = 1; +fn aiur_fn_459( + inp: [G; IN_459], record: &mut QueryRecord, io_buffer: &mut IOBuffer, unconstrained: bool, -) -> Result<[G; OUT_463], ExecError> { +) -> Result<[G; OUT_459], ExecError> { stacker::maybe_grow(64 * 1024, 4 * 1024 * 1024, || { let __v_0: G = inp[0]; let __v_1: G = inp[1]; @@ -41496,32 +41222,32 @@ fn aiur_fn_463( match __v_7.as_canonical_u64() { 0u64 => { let __v_8: G = G::from_u64(1); - let __ret: [G; OUT_463] = [__v_8]; - if let Some(result) = record.function_queries[463].get_mut(&inp[..]) { debug_assert_eq!(result.output, &__ret[..]); if !unconstrained { *result.multiplicity += G::ONE; } } else { record.function_queries[463].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained)); }; + let __ret: [G; OUT_459] = [__v_8]; + if let Some(result) = record.function_queries[459].get_mut(&inp[..]) { debug_assert_eq!(result.output, &__ret[..]); if !unconstrained { *result.multiplicity += G::ONE; } } else { record.function_queries[459].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained)); }; return Ok(__ret); }, _ => { let __v_8: G = G::from_u64(8); let __v_9: G = { let __values: [G; 4] = [__v_8, __v_0, __v_5, __v_3]; let __mq = record.memory_queries.get_mut(&4).ok_or(ExecError::InvalidMemorySize(4))?; if let Some(result) = __mq.get_mut(&__values[..]) { if !unconstrained { *result.multiplicity += G::ONE; } result.output[0] } else { let __ptr = G::from_usize(__mq.len()); __mq.insert(&__values[..], &[__ptr], G::from_bool(!unconstrained)); __ptr } }; let __v_10: G = (__v_1 + __v_5); - let __r_arr: [G; OUT_766] = { let __args: [G; IN_766] = [__v_4, __v_10]; let __cu = unconstrained; if let Some(result) = record.function_queries[766].get_mut(&__args[..]) { if !__cu && *result.multiplicity == G::ZERO { aiur_fn_766(__args, record, io_buffer, false)? } else { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_766] = unsafe { *(result.output.as_ptr() as *const [G; OUT_766]) }; __ret } } else { aiur_fn_766(__args, record, io_buffer, __cu)? } }; + let __r_arr: [G; OUT_762] = { let __args: [G; IN_762] = [__v_4, __v_10]; let __cu = unconstrained; if let Some(result) = record.function_queries[762].get_mut(&__args[..]) { if !__cu && *result.multiplicity == G::ZERO { aiur_fn_762(__args, record, io_buffer, false)? } else { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_762] = unsafe { *(result.output.as_ptr() as *const [G; OUT_762]) }; __ret } } else { aiur_fn_762(__args, record, io_buffer, __cu)? } }; let __v_11: G = __r_arr[0]; - let __r_arr: [G; OUT_439] = { let __args: [G; IN_439] = [__v_9, __v_11, __v_6]; let __cu = unconstrained; if let Some(result) = record.function_queries[439].get_mut(&__args[..]) { if !__cu && *result.multiplicity == G::ZERO { aiur_fn_439(__args, record, io_buffer, false)? } else { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_439] = unsafe { *(result.output.as_ptr() as *const [G; OUT_439]) }; __ret } } else { aiur_fn_439(__args, record, io_buffer, __cu)? } }; + let __r_arr: [G; OUT_435] = { let __args: [G; IN_435] = [__v_9, __v_11, __v_6]; let __cu = unconstrained; if let Some(result) = record.function_queries[435].get_mut(&__args[..]) { if !__cu && *result.multiplicity == G::ZERO { aiur_fn_435(__args, record, io_buffer, false)? } else { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_435] = unsafe { *(result.output.as_ptr() as *const [G; OUT_435]) }; __ret } } else { aiur_fn_435(__args, record, io_buffer, __cu)? } }; let __v_12: G = __r_arr[0]; match __v_12.as_canonical_u64() { 0u64 => { let __v_13: G = G::from_u64(0); - let __ret: [G; OUT_463] = [__v_13]; - if let Some(result) = record.function_queries[463].get_mut(&inp[..]) { debug_assert_eq!(result.output, &__ret[..]); if !unconstrained { *result.multiplicity += G::ONE; } } else { record.function_queries[463].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained)); }; + let __ret: [G; OUT_459] = [__v_13]; + if let Some(result) = record.function_queries[459].get_mut(&inp[..]) { debug_assert_eq!(result.output, &__ret[..]); if !unconstrained { *result.multiplicity += G::ONE; } } else { record.function_queries[459].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained)); }; return Ok(__ret); }, _ => { let __v_13: G = G::from_u64(1); let __v_14: G = (__v_5 + __v_13); - let __r_arr: [G; OUT_463] = { let __args: [G; IN_463] = [__v_0, __v_1, __v_2, __v_3, __v_4, __v_14, __v_6]; let __cu = unconstrained; if let Some(result) = record.function_queries[463].get_mut(&__args[..]) { if !__cu && *result.multiplicity == G::ZERO { aiur_fn_463(__args, record, io_buffer, false)? } else { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_463] = unsafe { *(result.output.as_ptr() as *const [G; OUT_463]) }; __ret } } else { aiur_fn_463(__args, record, io_buffer, __cu)? } }; + let __r_arr: [G; OUT_459] = { let __args: [G; IN_459] = [__v_0, __v_1, __v_2, __v_3, __v_4, __v_14, __v_6]; let __cu = unconstrained; if let Some(result) = record.function_queries[459].get_mut(&__args[..]) { if !__cu && *result.multiplicity == G::ZERO { aiur_fn_459(__args, record, io_buffer, false)? } else { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_459] = unsafe { *(result.output.as_ptr() as *const [G; OUT_459]) }; __ret } } else { aiur_fn_459(__args, record, io_buffer, __cu)? } }; let __v_15: G = __r_arr[0]; - let __ret: [G; OUT_463] = [__v_15]; - if let Some(result) = record.function_queries[463].get_mut(&inp[..]) { debug_assert_eq!(result.output, &__ret[..]); if !unconstrained { *result.multiplicity += G::ONE; } } else { record.function_queries[463].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained)); }; + let __ret: [G; OUT_459] = [__v_15]; + if let Some(result) = record.function_queries[459].get_mut(&inp[..]) { debug_assert_eq!(result.output, &__ret[..]); if !unconstrained { *result.multiplicity += G::ONE; } } else { record.function_queries[459].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained)); }; return Ok(__ret); }, } @@ -41530,19 +41256,19 @@ fn aiur_fn_463( }) } -const INPUT_SIZE_464: usize = 2; -const IN_464: usize = 2; -const OUT_464: usize = 1; -fn aiur_fn_464( - inp: [G; IN_464], +const INPUT_SIZE_460: usize = 2; +const IN_460: usize = 2; +const OUT_460: usize = 1; +fn aiur_fn_460( + inp: [G; IN_460], record: &mut QueryRecord, io_buffer: &mut IOBuffer, unconstrained: bool, -) -> Result<[G; OUT_464], ExecError> { +) -> Result<[G; OUT_460], ExecError> { stacker::maybe_grow(64 * 1024, 4 * 1024 * 1024, || { let __v_0: G = inp[0]; let __v_1: G = inp[1]; - let __r_arr: [G; OUT_293] = { let __args: [G; IN_293] = [__v_1]; let __cu = unconstrained; if let Some(result) = record.function_queries[293].get_mut(&__args[..]) { if !__cu && *result.multiplicity == G::ZERO { aiur_fn_293(__args, record, io_buffer, false)? } else { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_293] = unsafe { *(result.output.as_ptr() as *const [G; OUT_293]) }; __ret } } else { aiur_fn_293(__args, record, io_buffer, __cu)? } }; + let __r_arr: [G; OUT_289] = { let __args: [G; IN_289] = [__v_1]; let __cu = unconstrained; if let Some(result) = record.function_queries[289].get_mut(&__args[..]) { if !__cu && *result.multiplicity == G::ZERO { aiur_fn_289(__args, record, io_buffer, false)? } else { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_289] = unsafe { *(result.output.as_ptr() as *const [G; OUT_289]) }; __ret } } else { aiur_fn_289(__args, record, io_buffer, __cu)? } }; let __v_2: G = __r_arr[0]; let __v_3: G = __r_arr[1]; let __v_4: G = __r_arr[2]; @@ -41569,21 +41295,21 @@ fn aiur_fn_464( let __v_24: G = __r_arr[0]; let __r_arr: [G; OUT_21] = { let __args: [G; IN_21] = [__v_24]; let __cu = unconstrained; if let Some(result) = record.function_queries[21].get_mut(&__args[..]) { if !__cu && *result.multiplicity == G::ZERO { aiur_fn_21(__args, record, io_buffer, false)? } else { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_21] = unsafe { *(result.output.as_ptr() as *const [G; OUT_21]) }; __ret } } else { aiur_fn_21(__args, record, io_buffer, __cu)? } }; let __v_25: G = __r_arr[0]; - let __ret: [G; OUT_464] = [__v_25]; - if let Some(result) = record.function_queries[464].get_mut(&inp[..]) { debug_assert_eq!(result.output, &__ret[..]); if !unconstrained { *result.multiplicity += G::ONE; } } else { record.function_queries[464].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained)); }; + let __ret: [G; OUT_460] = [__v_25]; + if let Some(result) = record.function_queries[460].get_mut(&inp[..]) { debug_assert_eq!(result.output, &__ret[..]); if !unconstrained { *result.multiplicity += G::ONE; } } else { record.function_queries[460].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained)); }; return Ok(__ret); }) } -const INPUT_SIZE_465: usize = 3; -const IN_465: usize = 3; -const OUT_465: usize = 1; -fn aiur_fn_465( - inp: [G; IN_465], +const INPUT_SIZE_461: usize = 3; +const IN_461: usize = 3; +const OUT_461: usize = 1; +fn aiur_fn_461( + inp: [G; IN_461], record: &mut QueryRecord, io_buffer: &mut IOBuffer, unconstrained: bool, -) -> Result<[G; OUT_465], ExecError> { +) -> Result<[G; OUT_461], ExecError> { stacker::maybe_grow(64 * 1024, 4 * 1024 * 1024, || { let __v_0: G = inp[0]; let __v_1: G = inp[1]; @@ -41603,15 +41329,15 @@ fn aiur_fn_465( match __v_7.as_canonical_u64() { 4u64 => { let __v_11: G = G::from_u64(0); - let __ret: [G; OUT_465] = [__v_11]; - if let Some(result) = record.function_queries[465].get_mut(&inp[..]) { debug_assert_eq!(result.output, &__ret[..]); if !unconstrained { *result.multiplicity += G::ONE; } } else { record.function_queries[465].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained)); }; + let __ret: [G; OUT_461] = [__v_11]; + if let Some(result) = record.function_queries[461].get_mut(&inp[..]) { debug_assert_eq!(result.output, &__ret[..]); if !unconstrained { *result.multiplicity += G::ONE; } } else { record.function_queries[461].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained)); }; return Ok(__ret); }, _ => { - let __r_arr: [G; OUT_469] = { let __args: [G; IN_469] = [__v_4, __v_5, __v_1, __v_2]; let __cu = unconstrained; if let Some(result) = record.function_queries[469].get_mut(&__args[..]) { if !__cu && *result.multiplicity == G::ZERO { aiur_fn_469(__args, record, io_buffer, false)? } else { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_469] = unsafe { *(result.output.as_ptr() as *const [G; OUT_469]) }; __ret } } else { aiur_fn_469(__args, record, io_buffer, __cu)? } }; + let __r_arr: [G; OUT_465] = { let __args: [G; IN_465] = [__v_4, __v_5, __v_1, __v_2]; let __cu = unconstrained; if let Some(result) = record.function_queries[465].get_mut(&__args[..]) { if !__cu && *result.multiplicity == G::ZERO { aiur_fn_465(__args, record, io_buffer, false)? } else { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_465] = unsafe { *(result.output.as_ptr() as *const [G; OUT_465]) }; __ret } } else { aiur_fn_465(__args, record, io_buffer, __cu)? } }; let __v_11: G = __r_arr[0]; - let __ret: [G; OUT_465] = [__v_11]; - if let Some(result) = record.function_queries[465].get_mut(&inp[..]) { debug_assert_eq!(result.output, &__ret[..]); if !unconstrained { *result.multiplicity += G::ONE; } } else { record.function_queries[465].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained)); }; + let __ret: [G; OUT_461] = [__v_11]; + if let Some(result) = record.function_queries[461].get_mut(&inp[..]) { debug_assert_eq!(result.output, &__ret[..]); if !unconstrained { *result.multiplicity += G::ONE; } } else { record.function_queries[461].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained)); }; return Ok(__ret); }, } @@ -41624,16 +41350,16 @@ fn aiur_fn_465( let __v_10: G = __loaded[3]; match __v_7.as_canonical_u64() { 4u64 => { - let __r_arr: [G; OUT_469] = { let __args: [G; IN_469] = [__v_8, __v_9, __v_0, __v_2]; let __cu = unconstrained; if let Some(result) = record.function_queries[469].get_mut(&__args[..]) { if !__cu && *result.multiplicity == G::ZERO { aiur_fn_469(__args, record, io_buffer, false)? } else { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_469] = unsafe { *(result.output.as_ptr() as *const [G; OUT_469]) }; __ret } } else { aiur_fn_469(__args, record, io_buffer, __cu)? } }; + let __r_arr: [G; OUT_465] = { let __args: [G; IN_465] = [__v_8, __v_9, __v_0, __v_2]; let __cu = unconstrained; if let Some(result) = record.function_queries[465].get_mut(&__args[..]) { if !__cu && *result.multiplicity == G::ZERO { aiur_fn_465(__args, record, io_buffer, false)? } else { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_465] = unsafe { *(result.output.as_ptr() as *const [G; OUT_465]) }; __ret } } else { aiur_fn_465(__args, record, io_buffer, __cu)? } }; let __v_11: G = __r_arr[0]; - let __ret: [G; OUT_465] = [__v_11]; - if let Some(result) = record.function_queries[465].get_mut(&inp[..]) { debug_assert_eq!(result.output, &__ret[..]); if !unconstrained { *result.multiplicity += G::ONE; } } else { record.function_queries[465].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained)); }; + let __ret: [G; OUT_461] = [__v_11]; + if let Some(result) = record.function_queries[461].get_mut(&inp[..]) { debug_assert_eq!(result.output, &__ret[..]); if !unconstrained { *result.multiplicity += G::ONE; } } else { record.function_queries[461].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained)); }; return Ok(__ret); }, _ => { let __v_11: G = G::from_u64(0); - let __ret: [G; OUT_465] = [__v_11]; - if let Some(result) = record.function_queries[465].get_mut(&inp[..]) { debug_assert_eq!(result.output, &__ret[..]); if !unconstrained { *result.multiplicity += G::ONE; } } else { record.function_queries[465].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained)); }; + let __ret: [G; OUT_461] = [__v_11]; + if let Some(result) = record.function_queries[461].get_mut(&inp[..]) { debug_assert_eq!(result.output, &__ret[..]); if !unconstrained { *result.multiplicity += G::ONE; } } else { record.function_queries[461].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained)); }; return Ok(__ret); }, } @@ -41642,54 +41368,54 @@ fn aiur_fn_465( }) } -const INPUT_SIZE_466: usize = 3; -const IN_466: usize = 3; -const OUT_466: usize = 1; -fn aiur_fn_466( - inp: [G; IN_466], +const INPUT_SIZE_462: usize = 3; +const IN_462: usize = 3; +const OUT_462: usize = 1; +fn aiur_fn_462( + inp: [G; IN_462], record: &mut QueryRecord, io_buffer: &mut IOBuffer, unconstrained: bool, -) -> Result<[G; OUT_466], ExecError> { +) -> Result<[G; OUT_462], ExecError> { stacker::maybe_grow(64 * 1024, 4 * 1024 * 1024, || { let __v_0: G = inp[0]; let __v_1: G = inp[1]; let __v_2: G = inp[2]; - let __r_arr: [G; OUT_433] = { let __args: [G; IN_433] = [__v_0, __v_2]; let __cu = unconstrained; if let Some(result) = record.function_queries[433].get_mut(&__args[..]) { if !__cu && *result.multiplicity == G::ZERO { aiur_fn_433(__args, record, io_buffer, false)? } else { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_433] = unsafe { *(result.output.as_ptr() as *const [G; OUT_433]) }; __ret } } else { aiur_fn_433(__args, record, io_buffer, __cu)? } }; + let __r_arr: [G; OUT_429] = { let __args: [G; IN_429] = [__v_0, __v_2]; let __cu = unconstrained; if let Some(result) = record.function_queries[429].get_mut(&__args[..]) { if !__cu && *result.multiplicity == G::ZERO { aiur_fn_429(__args, record, io_buffer, false)? } else { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_429] = unsafe { *(result.output.as_ptr() as *const [G; OUT_429]) }; __ret } } else { aiur_fn_429(__args, record, io_buffer, __cu)? } }; let __v_3: G = __r_arr[0]; - let __r_arr: [G; OUT_418] = { let __args: [G; IN_418] = [__v_3, __v_2]; let __cu = unconstrained; if let Some(result) = record.function_queries[418].get_mut(&__args[..]) { if !__cu && *result.multiplicity == G::ZERO { aiur_fn_418(__args, record, io_buffer, false)? } else { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_418] = unsafe { *(result.output.as_ptr() as *const [G; OUT_418]) }; __ret } } else { aiur_fn_418(__args, record, io_buffer, __cu)? } }; + let __r_arr: [G; OUT_414] = { let __args: [G; IN_414] = [__v_3, __v_2]; let __cu = unconstrained; if let Some(result) = record.function_queries[414].get_mut(&__args[..]) { if !__cu && *result.multiplicity == G::ZERO { aiur_fn_414(__args, record, io_buffer, false)? } else { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_414] = unsafe { *(result.output.as_ptr() as *const [G; OUT_414]) }; __ret } } else { aiur_fn_414(__args, record, io_buffer, __cu)? } }; let __v_4: G = __r_arr[0]; - let __r_arr: [G; OUT_467] = { let __args: [G; IN_467] = [__v_4]; let __cu = unconstrained; if let Some(result) = record.function_queries[467].get_mut(&__args[..]) { if !__cu && *result.multiplicity == G::ZERO { aiur_fn_467(__args, record, io_buffer, false)? } else { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_467] = unsafe { *(result.output.as_ptr() as *const [G; OUT_467]) }; __ret } } else { aiur_fn_467(__args, record, io_buffer, __cu)? } }; + let __r_arr: [G; OUT_463] = { let __args: [G; IN_463] = [__v_4]; let __cu = unconstrained; if let Some(result) = record.function_queries[463].get_mut(&__args[..]) { if !__cu && *result.multiplicity == G::ZERO { aiur_fn_463(__args, record, io_buffer, false)? } else { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_463] = unsafe { *(result.output.as_ptr() as *const [G; OUT_463]) }; __ret } } else { aiur_fn_463(__args, record, io_buffer, __cu)? } }; let __v_5: G = __r_arr[0]; match __v_5.as_canonical_u64() { 0u64 => { let __v_6: G = G::from_u64(0); - let __ret: [G; OUT_466] = [__v_6]; - if let Some(result) = record.function_queries[466].get_mut(&inp[..]) { debug_assert_eq!(result.output, &__ret[..]); if !unconstrained { *result.multiplicity += G::ONE; } } else { record.function_queries[466].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained)); }; + let __ret: [G; OUT_462] = [__v_6]; + if let Some(result) = record.function_queries[462].get_mut(&inp[..]) { debug_assert_eq!(result.output, &__ret[..]); if !unconstrained { *result.multiplicity += G::ONE; } } else { record.function_queries[462].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained)); }; return Ok(__ret); }, _ => { - let __r_arr: [G; OUT_433] = { let __args: [G; IN_433] = [__v_1, __v_2]; let __cu = unconstrained; if let Some(result) = record.function_queries[433].get_mut(&__args[..]) { if !__cu && *result.multiplicity == G::ZERO { aiur_fn_433(__args, record, io_buffer, false)? } else { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_433] = unsafe { *(result.output.as_ptr() as *const [G; OUT_433]) }; __ret } } else { aiur_fn_433(__args, record, io_buffer, __cu)? } }; + let __r_arr: [G; OUT_429] = { let __args: [G; IN_429] = [__v_1, __v_2]; let __cu = unconstrained; if let Some(result) = record.function_queries[429].get_mut(&__args[..]) { if !__cu && *result.multiplicity == G::ZERO { aiur_fn_429(__args, record, io_buffer, false)? } else { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_429] = unsafe { *(result.output.as_ptr() as *const [G; OUT_429]) }; __ret } } else { aiur_fn_429(__args, record, io_buffer, __cu)? } }; let __v_6: G = __r_arr[0]; - let __r_arr: [G; OUT_439] = { let __args: [G; IN_439] = [__v_3, __v_6, __v_2]; let __cu = unconstrained; if let Some(result) = record.function_queries[439].get_mut(&__args[..]) { if !__cu && *result.multiplicity == G::ZERO { aiur_fn_439(__args, record, io_buffer, false)? } else { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_439] = unsafe { *(result.output.as_ptr() as *const [G; OUT_439]) }; __ret } } else { aiur_fn_439(__args, record, io_buffer, __cu)? } }; + let __r_arr: [G; OUT_435] = { let __args: [G; IN_435] = [__v_3, __v_6, __v_2]; let __cu = unconstrained; if let Some(result) = record.function_queries[435].get_mut(&__args[..]) { if !__cu && *result.multiplicity == G::ZERO { aiur_fn_435(__args, record, io_buffer, false)? } else { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_435] = unsafe { *(result.output.as_ptr() as *const [G; OUT_435]) }; __ret } } else { aiur_fn_435(__args, record, io_buffer, __cu)? } }; let __v_7: G = __r_arr[0]; - let __ret: [G; OUT_466] = [__v_7]; - if let Some(result) = record.function_queries[466].get_mut(&inp[..]) { debug_assert_eq!(result.output, &__ret[..]); if !unconstrained { *result.multiplicity += G::ONE; } } else { record.function_queries[466].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained)); }; + let __ret: [G; OUT_462] = [__v_7]; + if let Some(result) = record.function_queries[462].get_mut(&inp[..]) { debug_assert_eq!(result.output, &__ret[..]); if !unconstrained { *result.multiplicity += G::ONE; } } else { record.function_queries[462].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained)); }; return Ok(__ret); }, } }) } -const INPUT_SIZE_467: usize = 1; -const IN_467: usize = 1; -const OUT_467: usize = 1; -fn aiur_fn_467( - inp: [G; IN_467], +const INPUT_SIZE_463: usize = 1; +const IN_463: usize = 1; +const OUT_463: usize = 1; +fn aiur_fn_463( + inp: [G; IN_463], record: &mut QueryRecord, io_buffer: &mut IOBuffer, unconstrained: bool, -) -> Result<[G; OUT_467], ExecError> { +) -> Result<[G; OUT_463], ExecError> { stacker::maybe_grow(64 * 1024, 4 * 1024 * 1024, || { let __v_0: G = inp[0]; let __r_arr: [G; OUT_111] = { let __args: [G; IN_111] = [__v_0]; let __cu = unconstrained; if let Some(result) = record.function_queries[111].get_mut(&__args[..]) { if !__cu && *result.multiplicity == G::ZERO { aiur_fn_111(__args, record, io_buffer, false)? } else { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_111] = unsafe { *(result.output.as_ptr() as *const [G; OUT_111]) }; __ret } } else { aiur_fn_111(__args, record, io_buffer, __cu)? } }; @@ -41702,7 +41428,7 @@ fn aiur_fn_467( let __v_6: G = __loaded[3]; match __v_3.as_canonical_u64() { 2u64 => { - let __r_arr: [G; OUT_287] = { let __args: [G; IN_287] = [__v_4]; let __cu = unconstrained; if let Some(result) = record.function_queries[287].get_mut(&__args[..]) { if !__cu && *result.multiplicity == G::ZERO { aiur_fn_287(__args, record, io_buffer, false)? } else { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_287] = unsafe { *(result.output.as_ptr() as *const [G; OUT_287]) }; __ret } } else { aiur_fn_287(__args, record, io_buffer, __cu)? } }; + let __r_arr: [G; OUT_283] = { let __args: [G; IN_283] = [__v_4]; let __cu = unconstrained; if let Some(result) = record.function_queries[283].get_mut(&__args[..]) { if !__cu && *result.multiplicity == G::ZERO { aiur_fn_283(__args, record, io_buffer, false)? } else { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_283] = unsafe { *(result.output.as_ptr() as *const [G; OUT_283]) }; __ret } } else { aiur_fn_283(__args, record, io_buffer, __cu)? } }; let __v_7: G = __r_arr[0]; let __loaded: [G; 12] = { let __mq = record.memory_queries.get_mut(&12).ok_or(ExecError::InvalidMemorySize(12))?; let __ptr_u64 = __v_7.as_canonical_u64(); let __ptr_usize = usize::try_from(__ptr_u64).ok().ok_or(ExecError::PointerTooLarge(__ptr_u64))?; let (__args, __mult) = __mq.get_index_mut(__ptr_usize).ok_or(ExecError::UnboundPointer { ptr: __ptr_u64, size: 12 })?; if !unconstrained { *__mult += G::ONE; } let __arr: [G; 12] = __args[..12].try_into().unwrap(); __arr }; let __v_8: G = __loaded[0]; @@ -41726,7 +41452,7 @@ fn aiur_fn_467( match __v_21.as_canonical_u64() { 0u64 => { let __v_22: G = G::from_u64(0); - let __r_arr: [G; OUT_290] = { let __args: [G; IN_290] = [__v_15, __v_16, __v_22]; let __cu = unconstrained; if let Some(result) = record.function_queries[290].get_mut(&__args[..]) { if !__cu && *result.multiplicity == G::ZERO { aiur_fn_290(__args, record, io_buffer, false)? } else { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_290] = unsafe { *(result.output.as_ptr() as *const [G; OUT_290]) }; __ret } } else { aiur_fn_290(__args, record, io_buffer, __cu)? } }; + let __r_arr: [G; OUT_286] = { let __args: [G; IN_286] = [__v_15, __v_16, __v_22]; let __cu = unconstrained; if let Some(result) = record.function_queries[286].get_mut(&__args[..]) { if !__cu && *result.multiplicity == G::ZERO { aiur_fn_286(__args, record, io_buffer, false)? } else { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_286] = unsafe { *(result.output.as_ptr() as *const [G; OUT_286]) }; __ret } } else { aiur_fn_286(__args, record, io_buffer, __cu)? } }; let __v_23: G = __r_arr[0]; let __loaded: [G; 12] = { let __mq = record.memory_queries.get_mut(&12).ok_or(ExecError::InvalidMemorySize(12))?; let __ptr_u64 = __v_23.as_canonical_u64(); let __ptr_usize = usize::try_from(__ptr_u64).ok().ok_or(ExecError::PointerTooLarge(__ptr_u64))?; let (__args, __mult) = __mq.get_index_mut(__ptr_usize).ok_or(ExecError::UnboundPointer { ptr: __ptr_u64, size: 12 })?; if !unconstrained { *__mult += G::ONE; } let __arr: [G; 12] = __args[..12].try_into().unwrap(); __arr }; let __v_24: G = __loaded[0]; @@ -41746,114 +41472,114 @@ fn aiur_fn_467( match __v_31.as_canonical_u64() { 0u64 => { let __v_36: G = G::from_u64(1); - let __ret: [G; OUT_467] = [__v_36]; - if let Some(result) = record.function_queries[467].get_mut(&inp[..]) { debug_assert_eq!(result.output, &__ret[..]); if !unconstrained { *result.multiplicity += G::ONE; } } else { record.function_queries[467].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained)); }; + let __ret: [G; OUT_463] = [__v_36]; + if let Some(result) = record.function_queries[463].get_mut(&inp[..]) { debug_assert_eq!(result.output, &__ret[..]); if !unconstrained { *result.multiplicity += G::ONE; } } else { record.function_queries[463].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained)); }; return Ok(__ret); }, _ => { let __v_36: G = G::from_u64(0); - let __ret: [G; OUT_467] = [__v_36]; - if let Some(result) = record.function_queries[467].get_mut(&inp[..]) { debug_assert_eq!(result.output, &__ret[..]); if !unconstrained { *result.multiplicity += G::ONE; } } else { record.function_queries[467].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained)); }; + let __ret: [G; OUT_463] = [__v_36]; + if let Some(result) = record.function_queries[463].get_mut(&inp[..]) { debug_assert_eq!(result.output, &__ret[..]); if !unconstrained { *result.multiplicity += G::ONE; } } else { record.function_queries[463].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained)); }; return Ok(__ret); }, } }, _ => { let __v_36: G = G::from_u64(0); - let __ret: [G; OUT_467] = [__v_36]; - if let Some(result) = record.function_queries[467].get_mut(&inp[..]) { debug_assert_eq!(result.output, &__ret[..]); if !unconstrained { *result.multiplicity += G::ONE; } } else { record.function_queries[467].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained)); }; + let __ret: [G; OUT_463] = [__v_36]; + if let Some(result) = record.function_queries[463].get_mut(&inp[..]) { debug_assert_eq!(result.output, &__ret[..]); if !unconstrained { *result.multiplicity += G::ONE; } } else { record.function_queries[463].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained)); }; return Ok(__ret); }, } }, _ => { let __v_22: G = G::from_u64(0); - let __ret: [G; OUT_467] = [__v_22]; - if let Some(result) = record.function_queries[467].get_mut(&inp[..]) { debug_assert_eq!(result.output, &__ret[..]); if !unconstrained { *result.multiplicity += G::ONE; } } else { record.function_queries[467].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained)); }; + let __ret: [G; OUT_463] = [__v_22]; + if let Some(result) = record.function_queries[463].get_mut(&inp[..]) { debug_assert_eq!(result.output, &__ret[..]); if !unconstrained { *result.multiplicity += G::ONE; } } else { record.function_queries[463].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained)); }; return Ok(__ret); }, } }, _ => { let __v_20: G = G::from_u64(0); - let __ret: [G; OUT_467] = [__v_20]; - if let Some(result) = record.function_queries[467].get_mut(&inp[..]) { debug_assert_eq!(result.output, &__ret[..]); if !unconstrained { *result.multiplicity += G::ONE; } } else { record.function_queries[467].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained)); }; + let __ret: [G; OUT_463] = [__v_20]; + if let Some(result) = record.function_queries[463].get_mut(&inp[..]) { debug_assert_eq!(result.output, &__ret[..]); if !unconstrained { *result.multiplicity += G::ONE; } } else { record.function_queries[463].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained)); }; return Ok(__ret); }, } }, _ => { let __v_20: G = G::from_u64(0); - let __ret: [G; OUT_467] = [__v_20]; - if let Some(result) = record.function_queries[467].get_mut(&inp[..]) { debug_assert_eq!(result.output, &__ret[..]); if !unconstrained { *result.multiplicity += G::ONE; } } else { record.function_queries[467].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained)); }; + let __ret: [G; OUT_463] = [__v_20]; + if let Some(result) = record.function_queries[463].get_mut(&inp[..]) { debug_assert_eq!(result.output, &__ret[..]); if !unconstrained { *result.multiplicity += G::ONE; } } else { record.function_queries[463].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained)); }; return Ok(__ret); }, } }, _ => { let __v_7: G = G::from_u64(0); - let __ret: [G; OUT_467] = [__v_7]; - if let Some(result) = record.function_queries[467].get_mut(&inp[..]) { debug_assert_eq!(result.output, &__ret[..]); if !unconstrained { *result.multiplicity += G::ONE; } } else { record.function_queries[467].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained)); }; + let __ret: [G; OUT_463] = [__v_7]; + if let Some(result) = record.function_queries[463].get_mut(&inp[..]) { debug_assert_eq!(result.output, &__ret[..]); if !unconstrained { *result.multiplicity += G::ONE; } } else { record.function_queries[463].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained)); }; return Ok(__ret); }, } }) } -const INPUT_SIZE_468: usize = 3; -const IN_468: usize = 3; -const OUT_468: usize = 1; -fn aiur_fn_468( - inp: [G; IN_468], +const INPUT_SIZE_464: usize = 3; +const IN_464: usize = 3; +const OUT_464: usize = 1; +fn aiur_fn_464( + inp: [G; IN_464], record: &mut QueryRecord, io_buffer: &mut IOBuffer, unconstrained: bool, -) -> Result<[G; OUT_468], ExecError> { +) -> Result<[G; OUT_464], ExecError> { stacker::maybe_grow(64 * 1024, 4 * 1024 * 1024, || { let __v_0: G = inp[0]; let __v_1: G = inp[1]; let __v_2: G = inp[2]; - let __r_arr: [G; OUT_433] = { let __args: [G; IN_433] = [__v_0, __v_2]; let __cu = unconstrained; if let Some(result) = record.function_queries[433].get_mut(&__args[..]) { if !__cu && *result.multiplicity == G::ZERO { aiur_fn_433(__args, record, io_buffer, false)? } else { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_433] = unsafe { *(result.output.as_ptr() as *const [G; OUT_433]) }; __ret } } else { aiur_fn_433(__args, record, io_buffer, __cu)? } }; + let __r_arr: [G; OUT_429] = { let __args: [G; IN_429] = [__v_0, __v_2]; let __cu = unconstrained; if let Some(result) = record.function_queries[429].get_mut(&__args[..]) { if !__cu && *result.multiplicity == G::ZERO { aiur_fn_429(__args, record, io_buffer, false)? } else { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_429] = unsafe { *(result.output.as_ptr() as *const [G; OUT_429]) }; __ret } } else { aiur_fn_429(__args, record, io_buffer, __cu)? } }; let __v_3: G = __r_arr[0]; - let __r_arr: [G; OUT_470] = { let __args: [G; IN_470] = [__v_3, __v_2]; let __cu = unconstrained; if let Some(result) = record.function_queries[470].get_mut(&__args[..]) { if !__cu && *result.multiplicity == G::ZERO { aiur_fn_470(__args, record, io_buffer, false)? } else { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_470] = unsafe { *(result.output.as_ptr() as *const [G; OUT_470]) }; __ret } } else { aiur_fn_470(__args, record, io_buffer, __cu)? } }; + let __r_arr: [G; OUT_466] = { let __args: [G; IN_466] = [__v_3, __v_2]; let __cu = unconstrained; if let Some(result) = record.function_queries[466].get_mut(&__args[..]) { if !__cu && *result.multiplicity == G::ZERO { aiur_fn_466(__args, record, io_buffer, false)? } else { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_466] = unsafe { *(result.output.as_ptr() as *const [G; OUT_466]) }; __ret } } else { aiur_fn_466(__args, record, io_buffer, __cu)? } }; let __v_4: G = __r_arr[0]; match __v_4.as_canonical_u64() { 0u64 => { let __v_5: G = G::from_u64(0); - let __ret: [G; OUT_468] = [__v_5]; - if let Some(result) = record.function_queries[468].get_mut(&inp[..]) { debug_assert_eq!(result.output, &__ret[..]); if !unconstrained { *result.multiplicity += G::ONE; } } else { record.function_queries[468].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained)); }; + let __ret: [G; OUT_464] = [__v_5]; + if let Some(result) = record.function_queries[464].get_mut(&inp[..]) { debug_assert_eq!(result.output, &__ret[..]); if !unconstrained { *result.multiplicity += G::ONE; } } else { record.function_queries[464].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained)); }; return Ok(__ret); }, _ => { - let __r_arr: [G; OUT_433] = { let __args: [G; IN_433] = [__v_1, __v_2]; let __cu = unconstrained; if let Some(result) = record.function_queries[433].get_mut(&__args[..]) { if !__cu && *result.multiplicity == G::ZERO { aiur_fn_433(__args, record, io_buffer, false)? } else { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_433] = unsafe { *(result.output.as_ptr() as *const [G; OUT_433]) }; __ret } } else { aiur_fn_433(__args, record, io_buffer, __cu)? } }; + let __r_arr: [G; OUT_429] = { let __args: [G; IN_429] = [__v_1, __v_2]; let __cu = unconstrained; if let Some(result) = record.function_queries[429].get_mut(&__args[..]) { if !__cu && *result.multiplicity == G::ZERO { aiur_fn_429(__args, record, io_buffer, false)? } else { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_429] = unsafe { *(result.output.as_ptr() as *const [G; OUT_429]) }; __ret } } else { aiur_fn_429(__args, record, io_buffer, __cu)? } }; let __v_5: G = __r_arr[0]; - let __r_arr: [G; OUT_439] = { let __args: [G; IN_439] = [__v_3, __v_5, __v_2]; let __cu = unconstrained; if let Some(result) = record.function_queries[439].get_mut(&__args[..]) { if !__cu && *result.multiplicity == G::ZERO { aiur_fn_439(__args, record, io_buffer, false)? } else { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_439] = unsafe { *(result.output.as_ptr() as *const [G; OUT_439]) }; __ret } } else { aiur_fn_439(__args, record, io_buffer, __cu)? } }; + let __r_arr: [G; OUT_435] = { let __args: [G; IN_435] = [__v_3, __v_5, __v_2]; let __cu = unconstrained; if let Some(result) = record.function_queries[435].get_mut(&__args[..]) { if !__cu && *result.multiplicity == G::ZERO { aiur_fn_435(__args, record, io_buffer, false)? } else { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_435] = unsafe { *(result.output.as_ptr() as *const [G; OUT_435]) }; __ret } } else { aiur_fn_435(__args, record, io_buffer, __cu)? } }; let __v_6: G = __r_arr[0]; - let __ret: [G; OUT_468] = [__v_6]; - if let Some(result) = record.function_queries[468].get_mut(&inp[..]) { debug_assert_eq!(result.output, &__ret[..]); if !unconstrained { *result.multiplicity += G::ONE; } } else { record.function_queries[468].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained)); }; + let __ret: [G; OUT_464] = [__v_6]; + if let Some(result) = record.function_queries[464].get_mut(&inp[..]) { debug_assert_eq!(result.output, &__ret[..]); if !unconstrained { *result.multiplicity += G::ONE; } } else { record.function_queries[464].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained)); }; return Ok(__ret); }, } }) } -const INPUT_SIZE_469: usize = 4; -const IN_469: usize = 4; -const OUT_469: usize = 1; -fn aiur_fn_469( - inp: [G; IN_469], +const INPUT_SIZE_465: usize = 4; +const IN_465: usize = 4; +const OUT_465: usize = 1; +fn aiur_fn_465( + inp: [G; IN_465], record: &mut QueryRecord, io_buffer: &mut IOBuffer, unconstrained: bool, -) -> Result<[G; OUT_469], ExecError> { +) -> Result<[G; OUT_465], ExecError> { stacker::maybe_grow(64 * 1024, 4 * 1024 * 1024, || { let __v_0: G = inp[0]; let __v_1: G = inp[1]; let __v_2: G = inp[2]; let __v_3: G = inp[3]; - let __r_arr: [G; OUT_433] = { let __args: [G; IN_433] = [__v_2, __v_3]; let __cu = unconstrained; if let Some(result) = record.function_queries[433].get_mut(&__args[..]) { if !__cu && *result.multiplicity == G::ZERO { aiur_fn_433(__args, record, io_buffer, false)? } else { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_433] = unsafe { *(result.output.as_ptr() as *const [G; OUT_433]) }; __ret } } else { aiur_fn_433(__args, record, io_buffer, __cu)? } }; + let __r_arr: [G; OUT_429] = { let __args: [G; IN_429] = [__v_2, __v_3]; let __cu = unconstrained; if let Some(result) = record.function_queries[429].get_mut(&__args[..]) { if !__cu && *result.multiplicity == G::ZERO { aiur_fn_429(__args, record, io_buffer, false)? } else { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_429] = unsafe { *(result.output.as_ptr() as *const [G; OUT_429]) }; __ret } } else { aiur_fn_429(__args, record, io_buffer, __cu)? } }; let __v_4: G = __r_arr[0]; - let __r_arr: [G; OUT_418] = { let __args: [G; IN_418] = [__v_4, __v_3]; let __cu = unconstrained; if let Some(result) = record.function_queries[418].get_mut(&__args[..]) { if !__cu && *result.multiplicity == G::ZERO { aiur_fn_418(__args, record, io_buffer, false)? } else { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_418] = unsafe { *(result.output.as_ptr() as *const [G; OUT_418]) }; __ret } } else { aiur_fn_418(__args, record, io_buffer, __cu)? } }; + let __r_arr: [G; OUT_414] = { let __args: [G; IN_414] = [__v_4, __v_3]; let __cu = unconstrained; if let Some(result) = record.function_queries[414].get_mut(&__args[..]) { if !__cu && *result.multiplicity == G::ZERO { aiur_fn_414(__args, record, io_buffer, false)? } else { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_414] = unsafe { *(result.output.as_ptr() as *const [G; OUT_414]) }; __ret } } else { aiur_fn_414(__args, record, io_buffer, __cu)? } }; let __v_5: G = __r_arr[0]; let __loaded: [G; 4] = { let __mq = record.memory_queries.get_mut(&4).ok_or(ExecError::InvalidMemorySize(4))?; let __ptr_u64 = __v_5.as_canonical_u64(); let __ptr_usize = usize::try_from(__ptr_u64).ok().ok_or(ExecError::PointerTooLarge(__ptr_u64))?; let (__args, __mult) = __mq.get_index_mut(__ptr_usize).ok_or(ExecError::UnboundPointer { ptr: __ptr_u64, size: 4 })?; if !unconstrained { *__mult += G::ONE; } let __arr: [G; 4] = __args[..4].try_into().unwrap(); __arr }; let __v_6: G = __loaded[0]; @@ -41862,19 +41588,19 @@ fn aiur_fn_469( let __v_9: G = __loaded[3]; match __v_6.as_canonical_u64() { 5u64 => { - let __r_arr: [G; OUT_439] = { let __args: [G; IN_439] = [__v_0, __v_7, __v_3]; let __cu = unconstrained; if let Some(result) = record.function_queries[439].get_mut(&__args[..]) { if !__cu && *result.multiplicity == G::ZERO { aiur_fn_439(__args, record, io_buffer, false)? } else { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_439] = unsafe { *(result.output.as_ptr() as *const [G; OUT_439]) }; __ret } } else { aiur_fn_439(__args, record, io_buffer, __cu)? } }; + let __r_arr: [G; OUT_435] = { let __args: [G; IN_435] = [__v_0, __v_7, __v_3]; let __cu = unconstrained; if let Some(result) = record.function_queries[435].get_mut(&__args[..]) { if !__cu && *result.multiplicity == G::ZERO { aiur_fn_435(__args, record, io_buffer, false)? } else { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_435] = unsafe { *(result.output.as_ptr() as *const [G; OUT_435]) }; __ret } } else { aiur_fn_435(__args, record, io_buffer, __cu)? } }; let __v_10: G = __r_arr[0]; match __v_10.as_canonical_u64() { 0u64 => { let __v_11: G = G::from_u64(0); - let __ret: [G; OUT_469] = [__v_11]; - if let Some(result) = record.function_queries[469].get_mut(&inp[..]) { debug_assert_eq!(result.output, &__ret[..]); if !unconstrained { *result.multiplicity += G::ONE; } } else { record.function_queries[469].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained)); }; + let __ret: [G; OUT_465] = [__v_11]; + if let Some(result) = record.function_queries[465].get_mut(&inp[..]) { debug_assert_eq!(result.output, &__ret[..]); if !unconstrained { *result.multiplicity += G::ONE; } } else { record.function_queries[465].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained)); }; return Ok(__ret); }, _ => { let __v_11: G = G::from_u64(1); let __v_12: G = G::from_u64(0); - let __r_arr: [G; OUT_359] = { let __args: [G; IN_359] = [__v_2, __v_11, __v_12]; let __cu = unconstrained; if let Some(result) = record.function_queries[359].get_mut(&__args[..]) { if !__cu && *result.multiplicity == G::ZERO { aiur_fn_359(__args, record, io_buffer, false)? } else { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_359] = unsafe { *(result.output.as_ptr() as *const [G; OUT_359]) }; __ret } } else { aiur_fn_359(__args, record, io_buffer, __cu)? } }; + let __r_arr: [G; OUT_355] = { let __args: [G; IN_355] = [__v_2, __v_11, __v_12]; let __cu = unconstrained; if let Some(result) = record.function_queries[355].get_mut(&__args[..]) { if !__cu && *result.multiplicity == G::ZERO { aiur_fn_355(__args, record, io_buffer, false)? } else { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_355] = unsafe { *(result.output.as_ptr() as *const [G; OUT_355]) }; __ret } } else { aiur_fn_355(__args, record, io_buffer, __cu)? } }; let __v_13: G = __r_arr[0]; let __v_14: G = G::from_u64(0); let __v_15: G = G::from_u64(0); @@ -41885,39 +41611,39 @@ fn aiur_fn_469( let __v_20: G = { let __values: [G; 4] = [__v_18, __v_13, __v_17, __v_19]; let __mq = record.memory_queries.get_mut(&4).ok_or(ExecError::InvalidMemorySize(4))?; if let Some(result) = __mq.get_mut(&__values[..]) { if !unconstrained { *result.multiplicity += G::ONE; } result.output[0] } else { let __ptr = G::from_usize(__mq.len()); __mq.insert(&__values[..], &[__ptr], G::from_bool(!unconstrained)); __ptr } }; let __v_21: G = G::from_u64(0); let __v_22: G = { let __values: [G; 3] = [__v_21, __v_0, __v_3]; let __mq = record.memory_queries.get_mut(&3).ok_or(ExecError::InvalidMemorySize(3))?; if let Some(result) = __mq.get_mut(&__values[..]) { if !unconstrained { *result.multiplicity += G::ONE; } result.output[0] } else { let __ptr = G::from_usize(__mq.len()); __mq.insert(&__values[..], &[__ptr], G::from_bool(!unconstrained)); __ptr } }; - let __r_arr: [G; OUT_439] = { let __args: [G; IN_439] = [__v_1, __v_20, __v_22]; let __cu = unconstrained; if let Some(result) = record.function_queries[439].get_mut(&__args[..]) { if !__cu && *result.multiplicity == G::ZERO { aiur_fn_439(__args, record, io_buffer, false)? } else { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_439] = unsafe { *(result.output.as_ptr() as *const [G; OUT_439]) }; __ret } } else { aiur_fn_439(__args, record, io_buffer, __cu)? } }; + let __r_arr: [G; OUT_435] = { let __args: [G; IN_435] = [__v_1, __v_20, __v_22]; let __cu = unconstrained; if let Some(result) = record.function_queries[435].get_mut(&__args[..]) { if !__cu && *result.multiplicity == G::ZERO { aiur_fn_435(__args, record, io_buffer, false)? } else { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_435] = unsafe { *(result.output.as_ptr() as *const [G; OUT_435]) }; __ret } } else { aiur_fn_435(__args, record, io_buffer, __cu)? } }; let __v_23: G = __r_arr[0]; - let __ret: [G; OUT_469] = [__v_23]; - if let Some(result) = record.function_queries[469].get_mut(&inp[..]) { debug_assert_eq!(result.output, &__ret[..]); if !unconstrained { *result.multiplicity += G::ONE; } } else { record.function_queries[469].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained)); }; + let __ret: [G; OUT_465] = [__v_23]; + if let Some(result) = record.function_queries[465].get_mut(&inp[..]) { debug_assert_eq!(result.output, &__ret[..]); if !unconstrained { *result.multiplicity += G::ONE; } } else { record.function_queries[465].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained)); }; return Ok(__ret); }, } }, _ => { let __v_10: G = G::from_u64(0); - let __ret: [G; OUT_469] = [__v_10]; - if let Some(result) = record.function_queries[469].get_mut(&inp[..]) { debug_assert_eq!(result.output, &__ret[..]); if !unconstrained { *result.multiplicity += G::ONE; } } else { record.function_queries[469].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained)); }; + let __ret: [G; OUT_465] = [__v_10]; + if let Some(result) = record.function_queries[465].get_mut(&inp[..]) { debug_assert_eq!(result.output, &__ret[..]); if !unconstrained { *result.multiplicity += G::ONE; } } else { record.function_queries[465].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained)); }; return Ok(__ret); }, } }) } -const INPUT_SIZE_470: usize = 2; -const IN_470: usize = 2; -const OUT_470: usize = 1; -fn aiur_fn_470( - inp: [G; IN_470], +const INPUT_SIZE_466: usize = 2; +const IN_466: usize = 2; +const OUT_466: usize = 1; +fn aiur_fn_466( + inp: [G; IN_466], record: &mut QueryRecord, io_buffer: &mut IOBuffer, unconstrained: bool, -) -> Result<[G; OUT_470], ExecError> { +) -> Result<[G; OUT_466], ExecError> { stacker::maybe_grow(64 * 1024, 4 * 1024 * 1024, || { let __v_0: G = inp[0]; let __v_1: G = inp[1]; - let __r_arr: [G; OUT_433] = { let __args: [G; IN_433] = [__v_0, __v_1]; let __cu = unconstrained; if let Some(result) = record.function_queries[433].get_mut(&__args[..]) { if !__cu && *result.multiplicity == G::ZERO { aiur_fn_433(__args, record, io_buffer, false)? } else { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_433] = unsafe { *(result.output.as_ptr() as *const [G; OUT_433]) }; __ret } } else { aiur_fn_433(__args, record, io_buffer, __cu)? } }; + let __r_arr: [G; OUT_429] = { let __args: [G; IN_429] = [__v_0, __v_1]; let __cu = unconstrained; if let Some(result) = record.function_queries[429].get_mut(&__args[..]) { if !__cu && *result.multiplicity == G::ZERO { aiur_fn_429(__args, record, io_buffer, false)? } else { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_429] = unsafe { *(result.output.as_ptr() as *const [G; OUT_429]) }; __ret } } else { aiur_fn_429(__args, record, io_buffer, __cu)? } }; let __v_2: G = __r_arr[0]; - let __r_arr: [G; OUT_418] = { let __args: [G; IN_418] = [__v_2, __v_1]; let __cu = unconstrained; if let Some(result) = record.function_queries[418].get_mut(&__args[..]) { if !__cu && *result.multiplicity == G::ZERO { aiur_fn_418(__args, record, io_buffer, false)? } else { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_418] = unsafe { *(result.output.as_ptr() as *const [G; OUT_418]) }; __ret } } else { aiur_fn_418(__args, record, io_buffer, __cu)? } }; + let __r_arr: [G; OUT_414] = { let __args: [G; IN_414] = [__v_2, __v_1]; let __cu = unconstrained; if let Some(result) = record.function_queries[414].get_mut(&__args[..]) { if !__cu && *result.multiplicity == G::ZERO { aiur_fn_414(__args, record, io_buffer, false)? } else { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_414] = unsafe { *(result.output.as_ptr() as *const [G; OUT_414]) }; __ret } } else { aiur_fn_414(__args, record, io_buffer, __cu)? } }; let __v_3: G = __r_arr[0]; let __loaded: [G; 4] = { let __mq = record.memory_queries.get_mut(&4).ok_or(ExecError::InvalidMemorySize(4))?; let __ptr_u64 = __v_3.as_canonical_u64(); let __ptr_usize = usize::try_from(__ptr_u64).ok().ok_or(ExecError::PointerTooLarge(__ptr_u64))?; let (__args, __mult) = __mq.get_index_mut(__ptr_usize).ok_or(ExecError::UnboundPointer { ptr: __ptr_u64, size: 4 })?; if !unconstrained { *__mult += G::ONE; } let __arr: [G; 4] = __args[..4].try_into().unwrap(); __arr }; let __v_4: G = __loaded[0]; @@ -41926,65 +41652,55 @@ fn aiur_fn_470( let __v_7: G = __loaded[3]; match __v_4.as_canonical_u64() { 1u64 => { - let __loaded: [G; 3] = { let __mq = record.memory_queries.get_mut(&3).ok_or(ExecError::InvalidMemorySize(3))?; let __ptr_u64 = __v_5.as_canonical_u64(); let __ptr_usize = usize::try_from(__ptr_u64).ok().ok_or(ExecError::PointerTooLarge(__ptr_u64))?; let (__args, __mult) = __mq.get_index_mut(__ptr_usize).ok_or(ExecError::UnboundPointer { ptr: __ptr_u64, size: 3 })?; if !unconstrained { *__mult += G::ONE; } let __arr: [G; 3] = __args[..3].try_into().unwrap(); __arr }; - let __v_8: G = __loaded[0]; - let __v_9: G = __loaded[1]; - let __v_10: G = __loaded[2]; - match __v_8.as_canonical_u64() { - 0u64 => { - let __v_11: G = G::from_u64(1); - let __ret: [G; OUT_470] = [__v_11]; - if let Some(result) = record.function_queries[470].get_mut(&inp[..]) { debug_assert_eq!(result.output, &__ret[..]); if !unconstrained { *result.multiplicity += G::ONE; } } else { record.function_queries[470].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained)); }; - return Ok(__ret); - }, - _ => { - let __v_11: G = G::from_u64(0); - let __ret: [G; OUT_470] = [__v_11]; - if let Some(result) = record.function_queries[470].get_mut(&inp[..]) { debug_assert_eq!(result.output, &__ret[..]); if !unconstrained { *result.multiplicity += G::ONE; } } else { record.function_queries[470].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained)); }; - return Ok(__ret); - }, - } + let __v_8: G = G::from_u64(0); + let __v_9: G = G::from_u64(0); + let __v_10: G = { let __values: [G; 3] = [__v_8, __v_9, __v_9]; let __mq = record.memory_queries.get_mut(&3).ok_or(ExecError::InvalidMemorySize(3))?; if let Some(result) = __mq.get_mut(&__values[..]) { if !unconstrained { *result.multiplicity += G::ONE; } result.output[0] } else { let __ptr = G::from_usize(__mq.len()); __mq.insert(&__values[..], &[__ptr], G::from_bool(!unconstrained)); __ptr } }; + let __r_arr: [G; OUT_320] = { let __args: [G; IN_320] = [__v_5, __v_10]; let __cu = unconstrained; if let Some(result) = record.function_queries[320].get_mut(&__args[..]) { if !__cu && *result.multiplicity == G::ZERO { aiur_fn_320(__args, record, io_buffer, false)? } else { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_320] = unsafe { *(result.output.as_ptr() as *const [G; OUT_320]) }; __ret } } else { aiur_fn_320(__args, record, io_buffer, __cu)? } }; + let __v_11: G = __r_arr[0]; + let __ret: [G; OUT_466] = [__v_11]; + if let Some(result) = record.function_queries[466].get_mut(&inp[..]) { debug_assert_eq!(result.output, &__ret[..]); if !unconstrained { *result.multiplicity += G::ONE; } } else { record.function_queries[466].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained)); }; + return Ok(__ret); }, _ => { let __v_8: G = G::from_u64(0); - let __ret: [G; OUT_470] = [__v_8]; - if let Some(result) = record.function_queries[470].get_mut(&inp[..]) { debug_assert_eq!(result.output, &__ret[..]); if !unconstrained { *result.multiplicity += G::ONE; } } else { record.function_queries[470].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained)); }; + let __ret: [G; OUT_466] = [__v_8]; + if let Some(result) = record.function_queries[466].get_mut(&inp[..]) { debug_assert_eq!(result.output, &__ret[..]); if !unconstrained { *result.multiplicity += G::ONE; } } else { record.function_queries[466].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained)); }; return Ok(__ret); }, } }) } -const INPUT_SIZE_471: usize = 3; -const IN_471: usize = 3; -const OUT_471: usize = 1; -fn aiur_fn_471( - inp: [G; IN_471], +const INPUT_SIZE_467: usize = 3; +const IN_467: usize = 3; +const OUT_467: usize = 1; +fn aiur_fn_467( + inp: [G; IN_467], record: &mut QueryRecord, io_buffer: &mut IOBuffer, unconstrained: bool, -) -> Result<[G; OUT_471], ExecError> { +) -> Result<[G; OUT_467], ExecError> { stacker::maybe_grow(64 * 1024, 4 * 1024 * 1024, || { let __v_0: G = inp[0]; let __v_1: G = inp[1]; let __v_2: G = inp[2]; - let __r_arr: [G; OUT_472] = { let __args: [G; IN_472] = [__v_0, __v_1, __v_2]; let __cu = unconstrained; if let Some(result) = record.function_queries[472].get_mut(&__args[..]) { if !__cu && *result.multiplicity == G::ZERO { aiur_fn_472(__args, record, io_buffer, false)? } else { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_472] = unsafe { *(result.output.as_ptr() as *const [G; OUT_472]) }; __ret } } else { aiur_fn_472(__args, record, io_buffer, __cu)? } }; + let __r_arr: [G; OUT_468] = { let __args: [G; IN_468] = [__v_0, __v_1, __v_2]; let __cu = unconstrained; if let Some(result) = record.function_queries[468].get_mut(&__args[..]) { if !__cu && *result.multiplicity == G::ZERO { aiur_fn_468(__args, record, io_buffer, false)? } else { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_468] = unsafe { *(result.output.as_ptr() as *const [G; OUT_468]) }; __ret } } else { aiur_fn_468(__args, record, io_buffer, __cu)? } }; let __v_3: G = __r_arr[0]; - let __ret: [G; OUT_471] = [__v_3]; - if let Some(result) = record.function_queries[471].get_mut(&inp[..]) { debug_assert_eq!(result.output, &__ret[..]); if !unconstrained { *result.multiplicity += G::ONE; } } else { record.function_queries[471].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained)); }; + let __ret: [G; OUT_467] = [__v_3]; + if let Some(result) = record.function_queries[467].get_mut(&inp[..]) { debug_assert_eq!(result.output, &__ret[..]); if !unconstrained { *result.multiplicity += G::ONE; } } else { record.function_queries[467].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained)); }; return Ok(__ret); }) } -const INPUT_SIZE_472: usize = 3; -const IN_472: usize = 3; -const OUT_472: usize = 1; -fn aiur_fn_472( - inp: [G; IN_472], +const INPUT_SIZE_468: usize = 3; +const IN_468: usize = 3; +const OUT_468: usize = 1; +fn aiur_fn_468( + inp: [G; IN_468], record: &mut QueryRecord, io_buffer: &mut IOBuffer, unconstrained: bool, -) -> Result<[G; OUT_472], ExecError> { +) -> Result<[G; OUT_468], ExecError> { stacker::maybe_grow(64 * 1024, 4 * 1024 * 1024, || { let __v_0: G = inp[0]; let __v_1: G = inp[1]; @@ -42007,22 +41723,22 @@ fn aiur_fn_472( match __v_11.as_canonical_u64() { 0u64 => { let __v_12: G = G::from_u64(1); - let __ret: [G; OUT_472] = [__v_12]; - if let Some(result) = record.function_queries[472].get_mut(&inp[..]) { debug_assert_eq!(result.output, &__ret[..]); if !unconstrained { *result.multiplicity += G::ONE; } } else { record.function_queries[472].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained)); }; + let __ret: [G; OUT_468] = [__v_12]; + if let Some(result) = record.function_queries[468].get_mut(&inp[..]) { debug_assert_eq!(result.output, &__ret[..]); if !unconstrained { *result.multiplicity += G::ONE; } } else { record.function_queries[468].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained)); }; return Ok(__ret); }, _ => { let __v_12: G = G::from_u64(0); - let __ret: [G; OUT_472] = [__v_12]; - if let Some(result) = record.function_queries[472].get_mut(&inp[..]) { debug_assert_eq!(result.output, &__ret[..]); if !unconstrained { *result.multiplicity += G::ONE; } } else { record.function_queries[472].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained)); }; + let __ret: [G; OUT_468] = [__v_12]; + if let Some(result) = record.function_queries[468].get_mut(&inp[..]) { debug_assert_eq!(result.output, &__ret[..]); if !unconstrained { *result.multiplicity += G::ONE; } } else { record.function_queries[468].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained)); }; return Ok(__ret); }, } }, _ => { let __v_11: G = G::from_u64(0); - let __ret: [G; OUT_472] = [__v_11]; - if let Some(result) = record.function_queries[472].get_mut(&inp[..]) { debug_assert_eq!(result.output, &__ret[..]); if !unconstrained { *result.multiplicity += G::ONE; } } else { record.function_queries[472].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained)); }; + let __ret: [G; OUT_468] = [__v_11]; + if let Some(result) = record.function_queries[468].get_mut(&inp[..]) { debug_assert_eq!(result.output, &__ret[..]); if !unconstrained { *result.multiplicity += G::ONE; } } else { record.function_queries[468].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained)); }; return Ok(__ret); }, } @@ -42035,16 +41751,16 @@ fn aiur_fn_472( let __v_10: G = __loaded[3]; match __v_7.as_canonical_u64() { 1u64 => { - let __r_arr: [G; OUT_324] = { let __args: [G; IN_324] = [__v_4, __v_8]; let __cu = unconstrained; if let Some(result) = record.function_queries[324].get_mut(&__args[..]) { if !__cu && *result.multiplicity == G::ZERO { aiur_fn_324(__args, record, io_buffer, false)? } else { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_324] = unsafe { *(result.output.as_ptr() as *const [G; OUT_324]) }; __ret } } else { aiur_fn_324(__args, record, io_buffer, __cu)? } }; + let __r_arr: [G; OUT_320] = { let __args: [G; IN_320] = [__v_4, __v_8]; let __cu = unconstrained; if let Some(result) = record.function_queries[320].get_mut(&__args[..]) { if !__cu && *result.multiplicity == G::ZERO { aiur_fn_320(__args, record, io_buffer, false)? } else { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_320] = unsafe { *(result.output.as_ptr() as *const [G; OUT_320]) }; __ret } } else { aiur_fn_320(__args, record, io_buffer, __cu)? } }; let __v_11: G = __r_arr[0]; - let __ret: [G; OUT_472] = [__v_11]; - if let Some(result) = record.function_queries[472].get_mut(&inp[..]) { debug_assert_eq!(result.output, &__ret[..]); if !unconstrained { *result.multiplicity += G::ONE; } } else { record.function_queries[472].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained)); }; + let __ret: [G; OUT_468] = [__v_11]; + if let Some(result) = record.function_queries[468].get_mut(&inp[..]) { debug_assert_eq!(result.output, &__ret[..]); if !unconstrained { *result.multiplicity += G::ONE; } } else { record.function_queries[468].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained)); }; return Ok(__ret); }, _ => { let __v_11: G = G::from_u64(0); - let __ret: [G; OUT_472] = [__v_11]; - if let Some(result) = record.function_queries[472].get_mut(&inp[..]) { debug_assert_eq!(result.output, &__ret[..]); if !unconstrained { *result.multiplicity += G::ONE; } } else { record.function_queries[472].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained)); }; + let __ret: [G; OUT_468] = [__v_11]; + if let Some(result) = record.function_queries[468].get_mut(&inp[..]) { debug_assert_eq!(result.output, &__ret[..]); if !unconstrained { *result.multiplicity += G::ONE; } } else { record.function_queries[468].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained)); }; return Ok(__ret); }, } @@ -42061,26 +41777,26 @@ fn aiur_fn_472( let __v_11: G = __r_arr[0]; match __v_11.as_canonical_u64() { 1u64 => { - let __r_arr: [G; OUT_438] = { let __args: [G; IN_438] = [__v_5, __v_9]; let __cu = unconstrained; if let Some(result) = record.function_queries[438].get_mut(&__args[..]) { if !__cu && *result.multiplicity == G::ZERO { aiur_fn_438(__args, record, io_buffer, false)? } else { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_438] = unsafe { *(result.output.as_ptr() as *const [G; OUT_438]) }; __ret } } else { aiur_fn_438(__args, record, io_buffer, __cu)? } }; + let __r_arr: [G; OUT_434] = { let __args: [G; IN_434] = [__v_5, __v_9]; let __cu = unconstrained; if let Some(result) = record.function_queries[434].get_mut(&__args[..]) { if !__cu && *result.multiplicity == G::ZERO { aiur_fn_434(__args, record, io_buffer, false)? } else { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_434] = unsafe { *(result.output.as_ptr() as *const [G; OUT_434]) }; __ret } } else { aiur_fn_434(__args, record, io_buffer, __cu)? } }; let __v_12: G = __r_arr[0]; - let __ret: [G; OUT_472] = [__v_12]; - if let Some(result) = record.function_queries[472].get_mut(&inp[..]) { debug_assert_eq!(result.output, &__ret[..]); if !unconstrained { *result.multiplicity += G::ONE; } } else { record.function_queries[472].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained)); }; + let __ret: [G; OUT_468] = [__v_12]; + if let Some(result) = record.function_queries[468].get_mut(&inp[..]) { debug_assert_eq!(result.output, &__ret[..]); if !unconstrained { *result.multiplicity += G::ONE; } } else { record.function_queries[468].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained)); }; return Ok(__ret); }, _ => { - let __r_arr: [G; OUT_485] = { let __args: [G; IN_485] = [__v_0, __v_1, __v_2]; let __cu = unconstrained; if let Some(result) = record.function_queries[485].get_mut(&__args[..]) { if !__cu && *result.multiplicity == G::ZERO { aiur_fn_485(__args, record, io_buffer, false)? } else { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_485] = unsafe { *(result.output.as_ptr() as *const [G; OUT_485]) }; __ret } } else { aiur_fn_485(__args, record, io_buffer, __cu)? } }; + let __r_arr: [G; OUT_481] = { let __args: [G; IN_481] = [__v_0, __v_1, __v_2]; let __cu = unconstrained; if let Some(result) = record.function_queries[481].get_mut(&__args[..]) { if !__cu && *result.multiplicity == G::ZERO { aiur_fn_481(__args, record, io_buffer, false)? } else { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_481] = unsafe { *(result.output.as_ptr() as *const [G; OUT_481]) }; __ret } } else { aiur_fn_481(__args, record, io_buffer, __cu)? } }; let __v_12: G = __r_arr[0]; - let __ret: [G; OUT_472] = [__v_12]; - if let Some(result) = record.function_queries[472].get_mut(&inp[..]) { debug_assert_eq!(result.output, &__ret[..]); if !unconstrained { *result.multiplicity += G::ONE; } } else { record.function_queries[472].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained)); }; + let __ret: [G; OUT_468] = [__v_12]; + if let Some(result) = record.function_queries[468].get_mut(&inp[..]) { debug_assert_eq!(result.output, &__ret[..]); if !unconstrained { *result.multiplicity += G::ONE; } } else { record.function_queries[468].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained)); }; return Ok(__ret); }, } }, _ => { - let __r_arr: [G; OUT_485] = { let __args: [G; IN_485] = [__v_0, __v_1, __v_2]; let __cu = unconstrained; if let Some(result) = record.function_queries[485].get_mut(&__args[..]) { if !__cu && *result.multiplicity == G::ZERO { aiur_fn_485(__args, record, io_buffer, false)? } else { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_485] = unsafe { *(result.output.as_ptr() as *const [G; OUT_485]) }; __ret } } else { aiur_fn_485(__args, record, io_buffer, __cu)? } }; + let __r_arr: [G; OUT_481] = { let __args: [G; IN_481] = [__v_0, __v_1, __v_2]; let __cu = unconstrained; if let Some(result) = record.function_queries[481].get_mut(&__args[..]) { if !__cu && *result.multiplicity == G::ZERO { aiur_fn_481(__args, record, io_buffer, false)? } else { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_481] = unsafe { *(result.output.as_ptr() as *const [G; OUT_481]) }; __ret } } else { aiur_fn_481(__args, record, io_buffer, __cu)? } }; let __v_11: G = __r_arr[0]; - let __ret: [G; OUT_472] = [__v_11]; - if let Some(result) = record.function_queries[472].get_mut(&inp[..]) { debug_assert_eq!(result.output, &__ret[..]); if !unconstrained { *result.multiplicity += G::ONE; } } else { record.function_queries[472].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained)); }; + let __ret: [G; OUT_468] = [__v_11]; + if let Some(result) = record.function_queries[468].get_mut(&inp[..]) { debug_assert_eq!(result.output, &__ret[..]); if !unconstrained { *result.multiplicity += G::ONE; } } else { record.function_queries[468].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained)); }; return Ok(__ret); }, } @@ -42093,31 +41809,31 @@ fn aiur_fn_472( let __v_10: G = __loaded[3]; match __v_7.as_canonical_u64() { 3u64 => { - let __r_arr: [G; OUT_439] = { let __args: [G; IN_439] = [__v_4, __v_8, __v_2]; let __cu = unconstrained; if let Some(result) = record.function_queries[439].get_mut(&__args[..]) { if !__cu && *result.multiplicity == G::ZERO { aiur_fn_439(__args, record, io_buffer, false)? } else { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_439] = unsafe { *(result.output.as_ptr() as *const [G; OUT_439]) }; __ret } } else { aiur_fn_439(__args, record, io_buffer, __cu)? } }; + let __r_arr: [G; OUT_435] = { let __args: [G; IN_435] = [__v_4, __v_8, __v_2]; let __cu = unconstrained; if let Some(result) = record.function_queries[435].get_mut(&__args[..]) { if !__cu && *result.multiplicity == G::ZERO { aiur_fn_435(__args, record, io_buffer, false)? } else { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_435] = unsafe { *(result.output.as_ptr() as *const [G; OUT_435]) }; __ret } } else { aiur_fn_435(__args, record, io_buffer, __cu)? } }; let __v_11: G = __r_arr[0]; match __v_11.as_canonical_u64() { 0u64 => { - let __r_arr: [G; OUT_485] = { let __args: [G; IN_485] = [__v_0, __v_1, __v_2]; let __cu = unconstrained; if let Some(result) = record.function_queries[485].get_mut(&__args[..]) { if !__cu && *result.multiplicity == G::ZERO { aiur_fn_485(__args, record, io_buffer, false)? } else { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_485] = unsafe { *(result.output.as_ptr() as *const [G; OUT_485]) }; __ret } } else { aiur_fn_485(__args, record, io_buffer, __cu)? } }; + let __r_arr: [G; OUT_481] = { let __args: [G; IN_481] = [__v_0, __v_1, __v_2]; let __cu = unconstrained; if let Some(result) = record.function_queries[481].get_mut(&__args[..]) { if !__cu && *result.multiplicity == G::ZERO { aiur_fn_481(__args, record, io_buffer, false)? } else { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_481] = unsafe { *(result.output.as_ptr() as *const [G; OUT_481]) }; __ret } } else { aiur_fn_481(__args, record, io_buffer, __cu)? } }; let __v_12: G = __r_arr[0]; - let __ret: [G; OUT_472] = [__v_12]; - if let Some(result) = record.function_queries[472].get_mut(&inp[..]) { debug_assert_eq!(result.output, &__ret[..]); if !unconstrained { *result.multiplicity += G::ONE; } } else { record.function_queries[472].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained)); }; + let __ret: [G; OUT_468] = [__v_12]; + if let Some(result) = record.function_queries[468].get_mut(&inp[..]) { debug_assert_eq!(result.output, &__ret[..]); if !unconstrained { *result.multiplicity += G::ONE; } } else { record.function_queries[468].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained)); }; return Ok(__ret); }, _ => { - let __r_arr: [G; OUT_439] = { let __args: [G; IN_439] = [__v_5, __v_9, __v_2]; let __cu = unconstrained; if let Some(result) = record.function_queries[439].get_mut(&__args[..]) { if !__cu && *result.multiplicity == G::ZERO { aiur_fn_439(__args, record, io_buffer, false)? } else { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_439] = unsafe { *(result.output.as_ptr() as *const [G; OUT_439]) }; __ret } } else { aiur_fn_439(__args, record, io_buffer, __cu)? } }; + let __r_arr: [G; OUT_435] = { let __args: [G; IN_435] = [__v_5, __v_9, __v_2]; let __cu = unconstrained; if let Some(result) = record.function_queries[435].get_mut(&__args[..]) { if !__cu && *result.multiplicity == G::ZERO { aiur_fn_435(__args, record, io_buffer, false)? } else { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_435] = unsafe { *(result.output.as_ptr() as *const [G; OUT_435]) }; __ret } } else { aiur_fn_435(__args, record, io_buffer, __cu)? } }; let __v_12: G = __r_arr[0]; match __v_12.as_canonical_u64() { 0u64 => { - let __r_arr: [G; OUT_485] = { let __args: [G; IN_485] = [__v_0, __v_1, __v_2]; let __cu = unconstrained; if let Some(result) = record.function_queries[485].get_mut(&__args[..]) { if !__cu && *result.multiplicity == G::ZERO { aiur_fn_485(__args, record, io_buffer, false)? } else { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_485] = unsafe { *(result.output.as_ptr() as *const [G; OUT_485]) }; __ret } } else { aiur_fn_485(__args, record, io_buffer, __cu)? } }; + let __r_arr: [G; OUT_481] = { let __args: [G; IN_481] = [__v_0, __v_1, __v_2]; let __cu = unconstrained; if let Some(result) = record.function_queries[481].get_mut(&__args[..]) { if !__cu && *result.multiplicity == G::ZERO { aiur_fn_481(__args, record, io_buffer, false)? } else { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_481] = unsafe { *(result.output.as_ptr() as *const [G; OUT_481]) }; __ret } } else { aiur_fn_481(__args, record, io_buffer, __cu)? } }; let __v_13: G = __r_arr[0]; - let __ret: [G; OUT_472] = [__v_13]; - if let Some(result) = record.function_queries[472].get_mut(&inp[..]) { debug_assert_eq!(result.output, &__ret[..]); if !unconstrained { *result.multiplicity += G::ONE; } } else { record.function_queries[472].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained)); }; + let __ret: [G; OUT_468] = [__v_13]; + if let Some(result) = record.function_queries[468].get_mut(&inp[..]) { debug_assert_eq!(result.output, &__ret[..]); if !unconstrained { *result.multiplicity += G::ONE; } } else { record.function_queries[468].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained)); }; return Ok(__ret); }, _ => { let __v_13: G = G::from_u64(1); - let __ret: [G; OUT_472] = [__v_13]; - if let Some(result) = record.function_queries[472].get_mut(&inp[..]) { debug_assert_eq!(result.output, &__ret[..]); if !unconstrained { *result.multiplicity += G::ONE; } } else { record.function_queries[472].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained)); }; + let __ret: [G; OUT_468] = [__v_13]; + if let Some(result) = record.function_queries[468].get_mut(&inp[..]) { debug_assert_eq!(result.output, &__ret[..]); if !unconstrained { *result.multiplicity += G::ONE; } } else { record.function_queries[468].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained)); }; return Ok(__ret); }, } @@ -42125,10 +41841,10 @@ fn aiur_fn_472( } }, _ => { - let __r_arr: [G; OUT_485] = { let __args: [G; IN_485] = [__v_0, __v_1, __v_2]; let __cu = unconstrained; if let Some(result) = record.function_queries[485].get_mut(&__args[..]) { if !__cu && *result.multiplicity == G::ZERO { aiur_fn_485(__args, record, io_buffer, false)? } else { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_485] = unsafe { *(result.output.as_ptr() as *const [G; OUT_485]) }; __ret } } else { aiur_fn_485(__args, record, io_buffer, __cu)? } }; + let __r_arr: [G; OUT_481] = { let __args: [G; IN_481] = [__v_0, __v_1, __v_2]; let __cu = unconstrained; if let Some(result) = record.function_queries[481].get_mut(&__args[..]) { if !__cu && *result.multiplicity == G::ZERO { aiur_fn_481(__args, record, io_buffer, false)? } else { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_481] = unsafe { *(result.output.as_ptr() as *const [G; OUT_481]) }; __ret } } else { aiur_fn_481(__args, record, io_buffer, __cu)? } }; let __v_11: G = __r_arr[0]; - let __ret: [G; OUT_472] = [__v_11]; - if let Some(result) = record.function_queries[472].get_mut(&inp[..]) { debug_assert_eq!(result.output, &__ret[..]); if !unconstrained { *result.multiplicity += G::ONE; } } else { record.function_queries[472].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained)); }; + let __ret: [G; OUT_468] = [__v_11]; + if let Some(result) = record.function_queries[468].get_mut(&inp[..]) { debug_assert_eq!(result.output, &__ret[..]); if !unconstrained { *result.multiplicity += G::ONE; } } else { record.function_queries[468].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained)); }; return Ok(__ret); }, } @@ -42141,31 +41857,31 @@ fn aiur_fn_472( let __v_10: G = __loaded[3]; match __v_7.as_canonical_u64() { 4u64 => { - let __r_arr: [G; OUT_439] = { let __args: [G; IN_439] = [__v_4, __v_8, __v_2]; let __cu = unconstrained; if let Some(result) = record.function_queries[439].get_mut(&__args[..]) { if !__cu && *result.multiplicity == G::ZERO { aiur_fn_439(__args, record, io_buffer, false)? } else { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_439] = unsafe { *(result.output.as_ptr() as *const [G; OUT_439]) }; __ret } } else { aiur_fn_439(__args, record, io_buffer, __cu)? } }; + let __r_arr: [G; OUT_435] = { let __args: [G; IN_435] = [__v_4, __v_8, __v_2]; let __cu = unconstrained; if let Some(result) = record.function_queries[435].get_mut(&__args[..]) { if !__cu && *result.multiplicity == G::ZERO { aiur_fn_435(__args, record, io_buffer, false)? } else { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_435] = unsafe { *(result.output.as_ptr() as *const [G; OUT_435]) }; __ret } } else { aiur_fn_435(__args, record, io_buffer, __cu)? } }; let __v_11: G = __r_arr[0]; match __v_11.as_canonical_u64() { 0u64 => { let __v_12: G = G::from_u64(0); - let __ret: [G; OUT_472] = [__v_12]; - if let Some(result) = record.function_queries[472].get_mut(&inp[..]) { debug_assert_eq!(result.output, &__ret[..]); if !unconstrained { *result.multiplicity += G::ONE; } } else { record.function_queries[472].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained)); }; + let __ret: [G; OUT_468] = [__v_12]; + if let Some(result) = record.function_queries[468].get_mut(&inp[..]) { debug_assert_eq!(result.output, &__ret[..]); if !unconstrained { *result.multiplicity += G::ONE; } } else { record.function_queries[468].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained)); }; return Ok(__ret); }, _ => { let __v_12: G = G::from_u64(0); let __v_13: G = { let __values: [G; 3] = [__v_12, __v_4, __v_2]; let __mq = record.memory_queries.get_mut(&3).ok_or(ExecError::InvalidMemorySize(3))?; if let Some(result) = __mq.get_mut(&__values[..]) { if !unconstrained { *result.multiplicity += G::ONE; } result.output[0] } else { let __ptr = G::from_usize(__mq.len()); __mq.insert(&__values[..], &[__ptr], G::from_bool(!unconstrained)); __ptr } }; - let __r_arr: [G; OUT_439] = { let __args: [G; IN_439] = [__v_5, __v_9, __v_13]; let __cu = unconstrained; if let Some(result) = record.function_queries[439].get_mut(&__args[..]) { if !__cu && *result.multiplicity == G::ZERO { aiur_fn_439(__args, record, io_buffer, false)? } else { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_439] = unsafe { *(result.output.as_ptr() as *const [G; OUT_439]) }; __ret } } else { aiur_fn_439(__args, record, io_buffer, __cu)? } }; + let __r_arr: [G; OUT_435] = { let __args: [G; IN_435] = [__v_5, __v_9, __v_13]; let __cu = unconstrained; if let Some(result) = record.function_queries[435].get_mut(&__args[..]) { if !__cu && *result.multiplicity == G::ZERO { aiur_fn_435(__args, record, io_buffer, false)? } else { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_435] = unsafe { *(result.output.as_ptr() as *const [G; OUT_435]) }; __ret } } else { aiur_fn_435(__args, record, io_buffer, __cu)? } }; let __v_14: G = __r_arr[0]; - let __ret: [G; OUT_472] = [__v_14]; - if let Some(result) = record.function_queries[472].get_mut(&inp[..]) { debug_assert_eq!(result.output, &__ret[..]); if !unconstrained { *result.multiplicity += G::ONE; } } else { record.function_queries[472].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained)); }; + let __ret: [G; OUT_468] = [__v_14]; + if let Some(result) = record.function_queries[468].get_mut(&inp[..]) { debug_assert_eq!(result.output, &__ret[..]); if !unconstrained { *result.multiplicity += G::ONE; } } else { record.function_queries[468].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained)); }; return Ok(__ret); }, } }, _ => { - let __r_arr: [G; OUT_469] = { let __args: [G; IN_469] = [__v_4, __v_5, __v_1, __v_2]; let __cu = unconstrained; if let Some(result) = record.function_queries[469].get_mut(&__args[..]) { if !__cu && *result.multiplicity == G::ZERO { aiur_fn_469(__args, record, io_buffer, false)? } else { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_469] = unsafe { *(result.output.as_ptr() as *const [G; OUT_469]) }; __ret } } else { aiur_fn_469(__args, record, io_buffer, __cu)? } }; + let __r_arr: [G; OUT_465] = { let __args: [G; IN_465] = [__v_4, __v_5, __v_1, __v_2]; let __cu = unconstrained; if let Some(result) = record.function_queries[465].get_mut(&__args[..]) { if !__cu && *result.multiplicity == G::ZERO { aiur_fn_465(__args, record, io_buffer, false)? } else { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_465] = unsafe { *(result.output.as_ptr() as *const [G; OUT_465]) }; __ret } } else { aiur_fn_465(__args, record, io_buffer, __cu)? } }; let __v_11: G = __r_arr[0]; - let __ret: [G; OUT_472] = [__v_11]; - if let Some(result) = record.function_queries[472].get_mut(&inp[..]) { debug_assert_eq!(result.output, &__ret[..]); if !unconstrained { *result.multiplicity += G::ONE; } } else { record.function_queries[472].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained)); }; + let __ret: [G; OUT_468] = [__v_11]; + if let Some(result) = record.function_queries[468].get_mut(&inp[..]) { debug_assert_eq!(result.output, &__ret[..]); if !unconstrained { *result.multiplicity += G::ONE; } } else { record.function_queries[468].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained)); }; return Ok(__ret); }, } @@ -42178,38 +41894,38 @@ fn aiur_fn_472( let __v_10: G = __loaded[3]; match __v_7.as_canonical_u64() { 5u64 => { - let __r_arr: [G; OUT_439] = { let __args: [G; IN_439] = [__v_4, __v_8, __v_2]; let __cu = unconstrained; if let Some(result) = record.function_queries[439].get_mut(&__args[..]) { if !__cu && *result.multiplicity == G::ZERO { aiur_fn_439(__args, record, io_buffer, false)? } else { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_439] = unsafe { *(result.output.as_ptr() as *const [G; OUT_439]) }; __ret } } else { aiur_fn_439(__args, record, io_buffer, __cu)? } }; + let __r_arr: [G; OUT_435] = { let __args: [G; IN_435] = [__v_4, __v_8, __v_2]; let __cu = unconstrained; if let Some(result) = record.function_queries[435].get_mut(&__args[..]) { if !__cu && *result.multiplicity == G::ZERO { aiur_fn_435(__args, record, io_buffer, false)? } else { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_435] = unsafe { *(result.output.as_ptr() as *const [G; OUT_435]) }; __ret } } else { aiur_fn_435(__args, record, io_buffer, __cu)? } }; let __v_11: G = __r_arr[0]; match __v_11.as_canonical_u64() { 0u64 => { let __v_12: G = G::from_u64(0); - let __ret: [G; OUT_472] = [__v_12]; - if let Some(result) = record.function_queries[472].get_mut(&inp[..]) { debug_assert_eq!(result.output, &__ret[..]); if !unconstrained { *result.multiplicity += G::ONE; } } else { record.function_queries[472].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained)); }; + let __ret: [G; OUT_468] = [__v_12]; + if let Some(result) = record.function_queries[468].get_mut(&inp[..]) { debug_assert_eq!(result.output, &__ret[..]); if !unconstrained { *result.multiplicity += G::ONE; } } else { record.function_queries[468].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained)); }; return Ok(__ret); }, _ => { let __v_12: G = G::from_u64(0); let __v_13: G = { let __values: [G; 3] = [__v_12, __v_4, __v_2]; let __mq = record.memory_queries.get_mut(&3).ok_or(ExecError::InvalidMemorySize(3))?; if let Some(result) = __mq.get_mut(&__values[..]) { if !unconstrained { *result.multiplicity += G::ONE; } result.output[0] } else { let __ptr = G::from_usize(__mq.len()); __mq.insert(&__values[..], &[__ptr], G::from_bool(!unconstrained)); __ptr } }; - let __r_arr: [G; OUT_439] = { let __args: [G; IN_439] = [__v_5, __v_9, __v_13]; let __cu = unconstrained; if let Some(result) = record.function_queries[439].get_mut(&__args[..]) { if !__cu && *result.multiplicity == G::ZERO { aiur_fn_439(__args, record, io_buffer, false)? } else { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_439] = unsafe { *(result.output.as_ptr() as *const [G; OUT_439]) }; __ret } } else { aiur_fn_439(__args, record, io_buffer, __cu)? } }; + let __r_arr: [G; OUT_435] = { let __args: [G; IN_435] = [__v_5, __v_9, __v_13]; let __cu = unconstrained; if let Some(result) = record.function_queries[435].get_mut(&__args[..]) { if !__cu && *result.multiplicity == G::ZERO { aiur_fn_435(__args, record, io_buffer, false)? } else { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_435] = unsafe { *(result.output.as_ptr() as *const [G; OUT_435]) }; __ret } } else { aiur_fn_435(__args, record, io_buffer, __cu)? } }; let __v_14: G = __r_arr[0]; - let __ret: [G; OUT_472] = [__v_14]; - if let Some(result) = record.function_queries[472].get_mut(&inp[..]) { debug_assert_eq!(result.output, &__ret[..]); if !unconstrained { *result.multiplicity += G::ONE; } } else { record.function_queries[472].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained)); }; + let __ret: [G; OUT_468] = [__v_14]; + if let Some(result) = record.function_queries[468].get_mut(&inp[..]) { debug_assert_eq!(result.output, &__ret[..]); if !unconstrained { *result.multiplicity += G::ONE; } } else { record.function_queries[468].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained)); }; return Ok(__ret); }, } }, _ => { let __v_11: G = G::from_u64(0); - let __ret: [G; OUT_472] = [__v_11]; - if let Some(result) = record.function_queries[472].get_mut(&inp[..]) { debug_assert_eq!(result.output, &__ret[..]); if !unconstrained { *result.multiplicity += G::ONE; } } else { record.function_queries[472].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained)); }; + let __ret: [G; OUT_468] = [__v_11]; + if let Some(result) = record.function_queries[468].get_mut(&inp[..]) { debug_assert_eq!(result.output, &__ret[..]); if !unconstrained { *result.multiplicity += G::ONE; } } else { record.function_queries[468].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained)); }; return Ok(__ret); }, } }, 6u64 => { let __v_7: G = G::from_u64(0); - let __ret: [G; OUT_472] = [__v_7]; - if let Some(result) = record.function_queries[472].get_mut(&inp[..]) { debug_assert_eq!(result.output, &__ret[..]); if !unconstrained { *result.multiplicity += G::ONE; } } else { record.function_queries[472].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained)); }; + let __ret: [G; OUT_468] = [__v_7]; + if let Some(result) = record.function_queries[468].get_mut(&inp[..]) { debug_assert_eq!(result.output, &__ret[..]); if !unconstrained { *result.multiplicity += G::ONE; } } else { record.function_queries[468].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained)); }; return Ok(__ret); }, 7u64 => { @@ -42220,28 +41936,28 @@ fn aiur_fn_472( let __v_10: G = __loaded[3]; match __v_7.as_canonical_u64() { 7u64 => { - let __r_arr: [G; OUT_340] = { let __args: [G; IN_340] = [__v_4, __v_5, __v_8, __v_9]; let __cu = unconstrained; if let Some(result) = record.function_queries[340].get_mut(&__args[..]) { if !__cu && *result.multiplicity == G::ZERO { aiur_fn_340(__args, record, io_buffer, false)? } else { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_340] = unsafe { *(result.output.as_ptr() as *const [G; OUT_340]) }; __ret } } else { aiur_fn_340(__args, record, io_buffer, __cu)? } }; + let __r_arr: [G; OUT_336] = { let __args: [G; IN_336] = [__v_4, __v_5, __v_8, __v_9]; let __cu = unconstrained; if let Some(result) = record.function_queries[336].get_mut(&__args[..]) { if !__cu && *result.multiplicity == G::ZERO { aiur_fn_336(__args, record, io_buffer, false)? } else { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_336] = unsafe { *(result.output.as_ptr() as *const [G; OUT_336]) }; __ret } } else { aiur_fn_336(__args, record, io_buffer, __cu)? } }; let __v_11: G = __r_arr[0]; - let __ret: [G; OUT_472] = [__v_11]; - if let Some(result) = record.function_queries[472].get_mut(&inp[..]) { debug_assert_eq!(result.output, &__ret[..]); if !unconstrained { *result.multiplicity += G::ONE; } } else { record.function_queries[472].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained)); }; + let __ret: [G; OUT_468] = [__v_11]; + if let Some(result) = record.function_queries[468].get_mut(&inp[..]) { debug_assert_eq!(result.output, &__ret[..]); if !unconstrained { *result.multiplicity += G::ONE; } } else { record.function_queries[468].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained)); }; return Ok(__ret); }, _ => { - let __r_arr: [G; OUT_400] = { let __args: [G; IN_400] = [__v_0]; let __cu = unconstrained; if let Some(result) = record.function_queries[400].get_mut(&__args[..]) { if !__cu && *result.multiplicity == G::ZERO { aiur_fn_400(__args, record, io_buffer, false)? } else { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_400] = unsafe { *(result.output.as_ptr() as *const [G; OUT_400]) }; __ret } } else { aiur_fn_400(__args, record, io_buffer, __cu)? } }; + let __r_arr: [G; OUT_396] = { let __args: [G; IN_396] = [__v_0]; let __cu = unconstrained; if let Some(result) = record.function_queries[396].get_mut(&__args[..]) { if !__cu && *result.multiplicity == G::ZERO { aiur_fn_396(__args, record, io_buffer, false)? } else { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_396] = unsafe { *(result.output.as_ptr() as *const [G; OUT_396]) }; __ret } } else { aiur_fn_396(__args, record, io_buffer, __cu)? } }; let __v_11: G = __r_arr[0]; let __v_12: G = (__v_11 - __v_0); match __v_12.as_canonical_u64() { 0u64 => { let __v_13: G = G::from_u64(0); - let __ret: [G; OUT_472] = [__v_13]; - if let Some(result) = record.function_queries[472].get_mut(&inp[..]) { debug_assert_eq!(result.output, &__ret[..]); if !unconstrained { *result.multiplicity += G::ONE; } } else { record.function_queries[472].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained)); }; + let __ret: [G; OUT_468] = [__v_13]; + if let Some(result) = record.function_queries[468].get_mut(&inp[..]) { debug_assert_eq!(result.output, &__ret[..]); if !unconstrained { *result.multiplicity += G::ONE; } } else { record.function_queries[468].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained)); }; return Ok(__ret); }, _ => { - let __r_arr: [G; OUT_472] = { let __args: [G; IN_472] = [__v_11, __v_1, __v_2]; let __cu = unconstrained; if let Some(result) = record.function_queries[472].get_mut(&__args[..]) { if !__cu && *result.multiplicity == G::ZERO { aiur_fn_472(__args, record, io_buffer, false)? } else { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_472] = unsafe { *(result.output.as_ptr() as *const [G; OUT_472]) }; __ret } } else { aiur_fn_472(__args, record, io_buffer, __cu)? } }; + let __r_arr: [G; OUT_468] = { let __args: [G; IN_468] = [__v_11, __v_1, __v_2]; let __cu = unconstrained; if let Some(result) = record.function_queries[468].get_mut(&__args[..]) { if !__cu && *result.multiplicity == G::ZERO { aiur_fn_468(__args, record, io_buffer, false)? } else { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_468] = unsafe { *(result.output.as_ptr() as *const [G; OUT_468]) }; __ret } } else { aiur_fn_468(__args, record, io_buffer, __cu)? } }; let __v_13: G = __r_arr[0]; - let __ret: [G; OUT_472] = [__v_13]; - if let Some(result) = record.function_queries[472].get_mut(&inp[..]) { debug_assert_eq!(result.output, &__ret[..]); if !unconstrained { *result.multiplicity += G::ONE; } } else { record.function_queries[472].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained)); }; + let __ret: [G; OUT_468] = [__v_13]; + if let Some(result) = record.function_queries[468].get_mut(&inp[..]) { debug_assert_eq!(result.output, &__ret[..]); if !unconstrained { *result.multiplicity += G::ONE; } } else { record.function_queries[468].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained)); }; return Ok(__ret); }, } @@ -42263,32 +41979,32 @@ fn aiur_fn_472( let __v_12: G = (__v_5 - __v_9); match __v_12.as_canonical_u64() { 0u64 => { - let __r_arr: [G; OUT_439] = { let __args: [G; IN_439] = [__v_6, __v_10, __v_2]; let __cu = unconstrained; if let Some(result) = record.function_queries[439].get_mut(&__args[..]) { if !__cu && *result.multiplicity == G::ZERO { aiur_fn_439(__args, record, io_buffer, false)? } else { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_439] = unsafe { *(result.output.as_ptr() as *const [G; OUT_439]) }; __ret } } else { aiur_fn_439(__args, record, io_buffer, __cu)? } }; + let __r_arr: [G; OUT_435] = { let __args: [G; IN_435] = [__v_6, __v_10, __v_2]; let __cu = unconstrained; if let Some(result) = record.function_queries[435].get_mut(&__args[..]) { if !__cu && *result.multiplicity == G::ZERO { aiur_fn_435(__args, record, io_buffer, false)? } else { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_435] = unsafe { *(result.output.as_ptr() as *const [G; OUT_435]) }; __ret } } else { aiur_fn_435(__args, record, io_buffer, __cu)? } }; let __v_13: G = __r_arr[0]; - let __ret: [G; OUT_472] = [__v_13]; - if let Some(result) = record.function_queries[472].get_mut(&inp[..]) { debug_assert_eq!(result.output, &__ret[..]); if !unconstrained { *result.multiplicity += G::ONE; } } else { record.function_queries[472].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained)); }; + let __ret: [G; OUT_468] = [__v_13]; + if let Some(result) = record.function_queries[468].get_mut(&inp[..]) { debug_assert_eq!(result.output, &__ret[..]); if !unconstrained { *result.multiplicity += G::ONE; } } else { record.function_queries[468].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained)); }; return Ok(__ret); }, _ => { let __v_13: G = G::from_u64(0); - let __ret: [G; OUT_472] = [__v_13]; - if let Some(result) = record.function_queries[472].get_mut(&inp[..]) { debug_assert_eq!(result.output, &__ret[..]); if !unconstrained { *result.multiplicity += G::ONE; } } else { record.function_queries[472].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained)); }; + let __ret: [G; OUT_468] = [__v_13]; + if let Some(result) = record.function_queries[468].get_mut(&inp[..]) { debug_assert_eq!(result.output, &__ret[..]); if !unconstrained { *result.multiplicity += G::ONE; } } else { record.function_queries[468].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained)); }; return Ok(__ret); }, } }, _ => { let __v_12: G = G::from_u64(0); - let __ret: [G; OUT_472] = [__v_12]; - if let Some(result) = record.function_queries[472].get_mut(&inp[..]) { debug_assert_eq!(result.output, &__ret[..]); if !unconstrained { *result.multiplicity += G::ONE; } } else { record.function_queries[472].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained)); }; + let __ret: [G; OUT_468] = [__v_12]; + if let Some(result) = record.function_queries[468].get_mut(&inp[..]) { debug_assert_eq!(result.output, &__ret[..]); if !unconstrained { *result.multiplicity += G::ONE; } } else { record.function_queries[468].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained)); }; return Ok(__ret); }, } }, _ => { let __v_11: G = G::from_u64(0); - let __ret: [G; OUT_472] = [__v_11]; - if let Some(result) = record.function_queries[472].get_mut(&inp[..]) { debug_assert_eq!(result.output, &__ret[..]); if !unconstrained { *result.multiplicity += G::ONE; } } else { record.function_queries[472].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained)); }; + let __ret: [G; OUT_468] = [__v_11]; + if let Some(result) = record.function_queries[468].get_mut(&inp[..]) { debug_assert_eq!(result.output, &__ret[..]); if !unconstrained { *result.multiplicity += G::ONE; } } else { record.function_queries[468].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained)); }; return Ok(__ret); }, } @@ -42300,15 +42016,15 @@ fn aiur_fn_472( }) } -const INPUT_SIZE_473: usize = 4; -const IN_473: usize = 4; -const OUT_473: usize = 3; -fn aiur_fn_473( - inp: [G; IN_473], +const INPUT_SIZE_469: usize = 4; +const IN_469: usize = 4; +const OUT_469: usize = 3; +fn aiur_fn_469( + inp: [G; IN_469], record: &mut QueryRecord, io_buffer: &mut IOBuffer, unconstrained: bool, -) -> Result<[G; OUT_473], ExecError> { +) -> Result<[G; OUT_469], ExecError> { stacker::maybe_grow(64 * 1024, 4 * 1024 * 1024, || { let __v_0: G = inp[0]; let __v_1: G = inp[1]; @@ -42317,8 +42033,8 @@ fn aiur_fn_473( match __v_2.as_canonical_u64() { 0u64 => { let __v_4: G = G::from_u64(0); - let __ret: [G; OUT_473] = [__v_4, __v_0, __v_1]; - if let Some(result) = record.function_queries[473].get_mut(&inp[..]) { debug_assert_eq!(result.output, &__ret[..]); if !unconstrained { *result.multiplicity += G::ONE; } } else { record.function_queries[473].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained)); }; + let __ret: [G; OUT_469] = [__v_4, __v_0, __v_1]; + if let Some(result) = record.function_queries[469].get_mut(&inp[..]) { debug_assert_eq!(result.output, &__ret[..]); if !unconstrained { *result.multiplicity += G::ONE; } } else { record.function_queries[469].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained)); }; return Ok(__ret); }, _ => { @@ -42326,46 +42042,46 @@ fn aiur_fn_473( match __v_4.as_canonical_u64() { 0u64 => { let __v_5: G = G::from_u64(1); - let __ret: [G; OUT_473] = [__v_5, __v_0, __v_1]; - if let Some(result) = record.function_queries[473].get_mut(&inp[..]) { debug_assert_eq!(result.output, &__ret[..]); if !unconstrained { *result.multiplicity += G::ONE; } } else { record.function_queries[473].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained)); }; + let __ret: [G; OUT_469] = [__v_5, __v_0, __v_1]; + if let Some(result) = record.function_queries[469].get_mut(&inp[..]) { debug_assert_eq!(result.output, &__ret[..]); if !unconstrained { *result.multiplicity += G::ONE; } } else { record.function_queries[469].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained)); }; return Ok(__ret); }, _ => { - let __r_arr: [G; OUT_447] = { let __args: [G; IN_447] = [__v_0, __v_1, __v_3]; let __cu = unconstrained; if let Some(result) = record.function_queries[447].get_mut(&__args[..]) { if !__cu && *result.multiplicity == G::ZERO { aiur_fn_447(__args, record, io_buffer, false)? } else { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_447] = unsafe { *(result.output.as_ptr() as *const [G; OUT_447]) }; __ret } } else { aiur_fn_447(__args, record, io_buffer, __cu)? } }; + let __r_arr: [G; OUT_443] = { let __args: [G; IN_443] = [__v_0, __v_1, __v_3]; let __cu = unconstrained; if let Some(result) = record.function_queries[443].get_mut(&__args[..]) { if !__cu && *result.multiplicity == G::ZERO { aiur_fn_443(__args, record, io_buffer, false)? } else { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_443] = unsafe { *(result.output.as_ptr() as *const [G; OUT_443]) }; __ret } } else { aiur_fn_443(__args, record, io_buffer, __cu)? } }; let __v_5: G = __r_arr[0]; let __v_6: G = __r_arr[1]; match __v_5.as_canonical_u64() { 1u64 => { - let __ret: [G; OUT_473] = [__v_6, __v_0, __v_1]; - if let Some(result) = record.function_queries[473].get_mut(&inp[..]) { debug_assert_eq!(result.output, &__ret[..]); if !unconstrained { *result.multiplicity += G::ONE; } } else { record.function_queries[473].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained)); }; + let __ret: [G; OUT_469] = [__v_6, __v_0, __v_1]; + if let Some(result) = record.function_queries[469].get_mut(&inp[..]) { debug_assert_eq!(result.output, &__ret[..]); if !unconstrained { *result.multiplicity += G::ONE; } } else { record.function_queries[469].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained)); }; return Ok(__ret); }, _ => { - let __r_arr: [G; OUT_486] = { let __args: [G; IN_486] = [__v_0]; let __cu = unconstrained; if let Some(result) = record.function_queries[486].get_mut(&__args[..]) { if !__cu && *result.multiplicity == G::ZERO { aiur_fn_486(__args, record, io_buffer, false)? } else { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_486] = unsafe { *(result.output.as_ptr() as *const [G; OUT_486]) }; __ret } } else { aiur_fn_486(__args, record, io_buffer, __cu)? } }; + let __r_arr: [G; OUT_482] = { let __args: [G; IN_482] = [__v_0]; let __cu = unconstrained; if let Some(result) = record.function_queries[482].get_mut(&__args[..]) { if !__cu && *result.multiplicity == G::ZERO { aiur_fn_482(__args, record, io_buffer, false)? } else { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_482] = unsafe { *(result.output.as_ptr() as *const [G; OUT_482]) }; __ret } } else { aiur_fn_482(__args, record, io_buffer, __cu)? } }; let __v_7: G = __r_arr[0]; let __v_8: G = __r_arr[1]; - let __r_arr: [G; OUT_486] = { let __args: [G; IN_486] = [__v_1]; let __cu = unconstrained; if let Some(result) = record.function_queries[486].get_mut(&__args[..]) { if !__cu && *result.multiplicity == G::ZERO { aiur_fn_486(__args, record, io_buffer, false)? } else { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_486] = unsafe { *(result.output.as_ptr() as *const [G; OUT_486]) }; __ret } } else { aiur_fn_486(__args, record, io_buffer, __cu)? } }; + let __r_arr: [G; OUT_482] = { let __args: [G; IN_482] = [__v_1]; let __cu = unconstrained; if let Some(result) = record.function_queries[482].get_mut(&__args[..]) { if !__cu && *result.multiplicity == G::ZERO { aiur_fn_482(__args, record, io_buffer, false)? } else { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_482] = unsafe { *(result.output.as_ptr() as *const [G; OUT_482]) }; __ret } } else { aiur_fn_482(__args, record, io_buffer, __cu)? } }; let __v_9: G = __r_arr[0]; let __v_10: G = __r_arr[1]; match __v_8.as_canonical_u64() { 1u64 => { match __v_10.as_canonical_u64() { 1u64 => { - let __r_arr: [G; OUT_475] = { let __args: [G; IN_475] = [__v_7, __v_9, __v_0, __v_1, __v_2, __v_3]; let __cu = unconstrained; if let Some(result) = record.function_queries[475].get_mut(&__args[..]) { if !__cu && *result.multiplicity == G::ZERO { aiur_fn_475(__args, record, io_buffer, false)? } else { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_475] = unsafe { *(result.output.as_ptr() as *const [G; OUT_475]) }; __ret } } else { aiur_fn_475(__args, record, io_buffer, __cu)? } }; + let __r_arr: [G; OUT_471] = { let __args: [G; IN_471] = [__v_7, __v_9, __v_0, __v_1, __v_2, __v_3]; let __cu = unconstrained; if let Some(result) = record.function_queries[471].get_mut(&__args[..]) { if !__cu && *result.multiplicity == G::ZERO { aiur_fn_471(__args, record, io_buffer, false)? } else { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_471] = unsafe { *(result.output.as_ptr() as *const [G; OUT_471]) }; __ret } } else { aiur_fn_471(__args, record, io_buffer, __cu)? } }; let __v_11: G = __r_arr[0]; let __v_12: G = __r_arr[1]; let __v_13: G = __r_arr[2]; - let __ret: [G; OUT_473] = [__v_11, __v_12, __v_13]; - if let Some(result) = record.function_queries[473].get_mut(&inp[..]) { debug_assert_eq!(result.output, &__ret[..]); if !unconstrained { *result.multiplicity += G::ONE; } } else { record.function_queries[473].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained)); }; + let __ret: [G; OUT_469] = [__v_11, __v_12, __v_13]; + if let Some(result) = record.function_queries[469].get_mut(&inp[..]) { debug_assert_eq!(result.output, &__ret[..]); if !unconstrained { *result.multiplicity += G::ONE; } } else { record.function_queries[469].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained)); }; return Ok(__ret); }, _ => { - let __r_arr: [G; OUT_479] = { let __args: [G; IN_479] = [__v_7, __v_0, __v_1, __v_2, __v_3]; let __cu = unconstrained; if let Some(result) = record.function_queries[479].get_mut(&__args[..]) { if !__cu && *result.multiplicity == G::ZERO { aiur_fn_479(__args, record, io_buffer, false)? } else { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_479] = unsafe { *(result.output.as_ptr() as *const [G; OUT_479]) }; __ret } } else { aiur_fn_479(__args, record, io_buffer, __cu)? } }; + let __r_arr: [G; OUT_475] = { let __args: [G; IN_475] = [__v_7, __v_0, __v_1, __v_2, __v_3]; let __cu = unconstrained; if let Some(result) = record.function_queries[475].get_mut(&__args[..]) { if !__cu && *result.multiplicity == G::ZERO { aiur_fn_475(__args, record, io_buffer, false)? } else { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_475] = unsafe { *(result.output.as_ptr() as *const [G; OUT_475]) }; __ret } } else { aiur_fn_475(__args, record, io_buffer, __cu)? } }; let __v_11: G = __r_arr[0]; let __v_12: G = __r_arr[1]; let __v_13: G = __r_arr[2]; - let __ret: [G; OUT_473] = [__v_11, __v_12, __v_13]; - if let Some(result) = record.function_queries[473].get_mut(&inp[..]) { debug_assert_eq!(result.output, &__ret[..]); if !unconstrained { *result.multiplicity += G::ONE; } } else { record.function_queries[473].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained)); }; + let __ret: [G; OUT_469] = [__v_11, __v_12, __v_13]; + if let Some(result) = record.function_queries[469].get_mut(&inp[..]) { debug_assert_eq!(result.output, &__ret[..]); if !unconstrained { *result.multiplicity += G::ONE; } } else { record.function_queries[469].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained)); }; return Ok(__ret); }, } @@ -42373,21 +42089,21 @@ fn aiur_fn_473( _ => { match __v_10.as_canonical_u64() { 1u64 => { - let __r_arr: [G; OUT_480] = { let __args: [G; IN_480] = [__v_9, __v_0, __v_1, __v_2, __v_3]; let __cu = unconstrained; if let Some(result) = record.function_queries[480].get_mut(&__args[..]) { if !__cu && *result.multiplicity == G::ZERO { aiur_fn_480(__args, record, io_buffer, false)? } else { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_480] = unsafe { *(result.output.as_ptr() as *const [G; OUT_480]) }; __ret } } else { aiur_fn_480(__args, record, io_buffer, __cu)? } }; + let __r_arr: [G; OUT_476] = { let __args: [G; IN_476] = [__v_9, __v_0, __v_1, __v_2, __v_3]; let __cu = unconstrained; if let Some(result) = record.function_queries[476].get_mut(&__args[..]) { if !__cu && *result.multiplicity == G::ZERO { aiur_fn_476(__args, record, io_buffer, false)? } else { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_476] = unsafe { *(result.output.as_ptr() as *const [G; OUT_476]) }; __ret } } else { aiur_fn_476(__args, record, io_buffer, __cu)? } }; let __v_11: G = __r_arr[0]; let __v_12: G = __r_arr[1]; let __v_13: G = __r_arr[2]; - let __ret: [G; OUT_473] = [__v_11, __v_12, __v_13]; - if let Some(result) = record.function_queries[473].get_mut(&inp[..]) { debug_assert_eq!(result.output, &__ret[..]); if !unconstrained { *result.multiplicity += G::ONE; } } else { record.function_queries[473].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained)); }; + let __ret: [G; OUT_469] = [__v_11, __v_12, __v_13]; + if let Some(result) = record.function_queries[469].get_mut(&inp[..]) { debug_assert_eq!(result.output, &__ret[..]); if !unconstrained { *result.multiplicity += G::ONE; } } else { record.function_queries[469].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained)); }; return Ok(__ret); }, _ => { - let __r_arr: [G; OUT_481] = { let __args: [G; IN_481] = [__v_0, __v_1, __v_2, __v_3]; let __cu = unconstrained; if let Some(result) = record.function_queries[481].get_mut(&__args[..]) { if !__cu && *result.multiplicity == G::ZERO { aiur_fn_481(__args, record, io_buffer, false)? } else { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_481] = unsafe { *(result.output.as_ptr() as *const [G; OUT_481]) }; __ret } } else { aiur_fn_481(__args, record, io_buffer, __cu)? } }; + let __r_arr: [G; OUT_477] = { let __args: [G; IN_477] = [__v_0, __v_1, __v_2, __v_3]; let __cu = unconstrained; if let Some(result) = record.function_queries[477].get_mut(&__args[..]) { if !__cu && *result.multiplicity == G::ZERO { aiur_fn_477(__args, record, io_buffer, false)? } else { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_477] = unsafe { *(result.output.as_ptr() as *const [G; OUT_477]) }; __ret } } else { aiur_fn_477(__args, record, io_buffer, __cu)? } }; let __v_11: G = __r_arr[0]; let __v_12: G = __r_arr[1]; let __v_13: G = __r_arr[2]; - let __ret: [G; OUT_473] = [__v_11, __v_12, __v_13]; - if let Some(result) = record.function_queries[473].get_mut(&inp[..]) { debug_assert_eq!(result.output, &__ret[..]); if !unconstrained { *result.multiplicity += G::ONE; } } else { record.function_queries[473].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained)); }; + let __ret: [G; OUT_469] = [__v_11, __v_12, __v_13]; + if let Some(result) = record.function_queries[469].get_mut(&inp[..]) { debug_assert_eq!(result.output, &__ret[..]); if !unconstrained { *result.multiplicity += G::ONE; } } else { record.function_queries[469].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained)); }; return Ok(__ret); }, } @@ -42402,15 +42118,15 @@ fn aiur_fn_473( }) } -const INPUT_SIZE_474: usize = 12; -const IN_474: usize = 12; -const OUT_474: usize = 1; -fn aiur_fn_474( - inp: [G; IN_474], +const INPUT_SIZE_470: usize = 12; +const IN_470: usize = 12; +const OUT_470: usize = 1; +fn aiur_fn_470( + inp: [G; IN_470], record: &mut QueryRecord, io_buffer: &mut IOBuffer, unconstrained: bool, -) -> Result<[G; OUT_474], ExecError> { +) -> Result<[G; OUT_470], ExecError> { stacker::maybe_grow(64 * 1024, 4 * 1024 * 1024, || { let __v_0: G = inp[0]; let __v_1: G = inp[1]; @@ -42426,29 +42142,29 @@ fn aiur_fn_474( let __v_11: G = inp[11]; match __v_0.as_canonical_u64() { 1u64 => { - let __ret: [G; OUT_474] = [__v_5]; - if let Some(result) = record.function_queries[474].get_mut(&inp[..]) { debug_assert_eq!(result.output, &__ret[..]); if !unconstrained { *result.multiplicity += G::ONE; } } else { record.function_queries[474].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained)); }; + let __ret: [G; OUT_470] = [__v_5]; + if let Some(result) = record.function_queries[470].get_mut(&inp[..]) { debug_assert_eq!(result.output, &__ret[..]); if !unconstrained { *result.multiplicity += G::ONE; } } else { record.function_queries[470].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained)); }; return Ok(__ret); }, _ => { let __v_12: G = G::from_u64(0); - let __ret: [G; OUT_474] = [__v_12]; - if let Some(result) = record.function_queries[474].get_mut(&inp[..]) { debug_assert_eq!(result.output, &__ret[..]); if !unconstrained { *result.multiplicity += G::ONE; } } else { record.function_queries[474].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained)); }; + let __ret: [G; OUT_470] = [__v_12]; + if let Some(result) = record.function_queries[470].get_mut(&inp[..]) { debug_assert_eq!(result.output, &__ret[..]); if !unconstrained { *result.multiplicity += G::ONE; } } else { record.function_queries[470].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained)); }; return Ok(__ret); }, } }) } -const INPUT_SIZE_475: usize = 6; -const IN_475: usize = 6; -const OUT_475: usize = 3; -fn aiur_fn_475( - inp: [G; IN_475], +const INPUT_SIZE_471: usize = 6; +const IN_471: usize = 6; +const OUT_471: usize = 3; +fn aiur_fn_471( + inp: [G; IN_471], record: &mut QueryRecord, io_buffer: &mut IOBuffer, unconstrained: bool, -) -> Result<[G; OUT_475], ExecError> { +) -> Result<[G; OUT_471], ExecError> { stacker::maybe_grow(64 * 1024, 4 * 1024 * 1024, || { let __v_0: G = inp[0]; let __v_1: G = inp[1]; @@ -42456,7 +42172,7 @@ fn aiur_fn_475( let __v_3: G = inp[3]; let __v_4: G = inp[4]; let __v_5: G = inp[5]; - let __r_arr: [G; OUT_287] = { let __args: [G; IN_287] = [__v_0]; let __cu = unconstrained; if let Some(result) = record.function_queries[287].get_mut(&__args[..]) { if !__cu && *result.multiplicity == G::ZERO { aiur_fn_287(__args, record, io_buffer, false)? } else { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_287] = unsafe { *(result.output.as_ptr() as *const [G; OUT_287]) }; __ret } } else { aiur_fn_287(__args, record, io_buffer, __cu)? } }; + let __r_arr: [G; OUT_283] = { let __args: [G; IN_283] = [__v_0]; let __cu = unconstrained; if let Some(result) = record.function_queries[283].get_mut(&__args[..]) { if !__cu && *result.multiplicity == G::ZERO { aiur_fn_283(__args, record, io_buffer, false)? } else { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_283] = unsafe { *(result.output.as_ptr() as *const [G; OUT_283]) }; __ret } } else { aiur_fn_283(__args, record, io_buffer, __cu)? } }; let __v_6: G = __r_arr[0]; let __loaded: [G; 12] = { let __mq = record.memory_queries.get_mut(&12).ok_or(ExecError::InvalidMemorySize(12))?; let __ptr_u64 = __v_6.as_canonical_u64(); let __ptr_usize = usize::try_from(__ptr_u64).ok().ok_or(ExecError::PointerTooLarge(__ptr_u64))?; let (__args, __mult) = __mq.get_index_mut(__ptr_usize).ok_or(ExecError::UnboundPointer { ptr: __ptr_u64, size: 12 })?; if !unconstrained { *__mult += G::ONE; } let __arr: [G; 12] = __args[..12].try_into().unwrap(); __arr }; let __v_7: G = __loaded[0]; @@ -42471,7 +42187,7 @@ fn aiur_fn_475( let __v_16: G = __loaded[9]; let __v_17: G = __loaded[10]; let __v_18: G = __loaded[11]; - let __r_arr: [G; OUT_287] = { let __args: [G; IN_287] = [__v_1]; let __cu = unconstrained; if let Some(result) = record.function_queries[287].get_mut(&__args[..]) { if !__cu && *result.multiplicity == G::ZERO { aiur_fn_287(__args, record, io_buffer, false)? } else { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_287] = unsafe { *(result.output.as_ptr() as *const [G; OUT_287]) }; __ret } } else { aiur_fn_287(__args, record, io_buffer, __cu)? } }; + let __r_arr: [G; OUT_283] = { let __args: [G; IN_283] = [__v_1]; let __cu = unconstrained; if let Some(result) = record.function_queries[283].get_mut(&__args[..]) { if !__cu && *result.multiplicity == G::ZERO { aiur_fn_283(__args, record, io_buffer, false)? } else { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_283] = unsafe { *(result.output.as_ptr() as *const [G; OUT_283]) }; __ret } } else { aiur_fn_283(__args, record, io_buffer, __cu)? } }; let __v_19: G = __r_arr[0]; let __loaded: [G; 12] = { let __mq = record.memory_queries.get_mut(&12).ok_or(ExecError::InvalidMemorySize(12))?; let __ptr_u64 = __v_19.as_canonical_u64(); let __ptr_usize = usize::try_from(__ptr_u64).ok().ok_or(ExecError::PointerTooLarge(__ptr_u64))?; let (__args, __mult) = __mq.get_index_mut(__ptr_usize).ok_or(ExecError::UnboundPointer { ptr: __ptr_u64, size: 12 })?; if !unconstrained { *__mult += G::ONE; } let __arr: [G; 12] = __args[..12].try_into().unwrap(); __arr }; let __v_20: G = __loaded[0]; @@ -42486,26 +42202,26 @@ fn aiur_fn_475( let __v_29: G = __loaded[9]; let __v_30: G = __loaded[10]; let __v_31: G = __loaded[11]; - let __r_arr: [G; OUT_482] = { let __args: [G; IN_482] = [__v_7, __v_8, __v_9, __v_10, __v_11, __v_12, __v_13, __v_14, __v_15, __v_16, __v_17, __v_18]; let __cu = unconstrained; if let Some(result) = record.function_queries[482].get_mut(&__args[..]) { if !__cu && *result.multiplicity == G::ZERO { aiur_fn_482(__args, record, io_buffer, false)? } else { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_482] = unsafe { *(result.output.as_ptr() as *const [G; OUT_482]) }; __ret } } else { aiur_fn_482(__args, record, io_buffer, __cu)? } }; + let __r_arr: [G; OUT_478] = { let __args: [G; IN_478] = [__v_7, __v_8, __v_9, __v_10, __v_11, __v_12, __v_13, __v_14, __v_15, __v_16, __v_17, __v_18]; let __cu = unconstrained; if let Some(result) = record.function_queries[478].get_mut(&__args[..]) { if !__cu && *result.multiplicity == G::ZERO { aiur_fn_478(__args, record, io_buffer, false)? } else { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_478] = unsafe { *(result.output.as_ptr() as *const [G; OUT_478]) }; __ret } } else { aiur_fn_478(__args, record, io_buffer, __cu)? } }; let __v_32: G = __r_arr[0]; - let __r_arr: [G; OUT_482] = { let __args: [G; IN_482] = [__v_20, __v_21, __v_22, __v_23, __v_24, __v_25, __v_26, __v_27, __v_28, __v_29, __v_30, __v_31]; let __cu = unconstrained; if let Some(result) = record.function_queries[482].get_mut(&__args[..]) { if !__cu && *result.multiplicity == G::ZERO { aiur_fn_482(__args, record, io_buffer, false)? } else { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_482] = unsafe { *(result.output.as_ptr() as *const [G; OUT_482]) }; __ret } } else { aiur_fn_482(__args, record, io_buffer, __cu)? } }; + let __r_arr: [G; OUT_478] = { let __args: [G; IN_478] = [__v_20, __v_21, __v_22, __v_23, __v_24, __v_25, __v_26, __v_27, __v_28, __v_29, __v_30, __v_31]; let __cu = unconstrained; if let Some(result) = record.function_queries[478].get_mut(&__args[..]) { if !__cu && *result.multiplicity == G::ZERO { aiur_fn_478(__args, record, io_buffer, false)? } else { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_478] = unsafe { *(result.output.as_ptr() as *const [G; OUT_478]) }; __ret } } else { aiur_fn_478(__args, record, io_buffer, __cu)? } }; let __v_33: G = __r_arr[0]; match __v_32.as_canonical_u64() { 0u64 => { match __v_33.as_canonical_u64() { 0u64 => { let __v_34: G = G::from_u64(0); - let __ret: [G; OUT_475] = [__v_34, __v_2, __v_3]; - if let Some(result) = record.function_queries[475].get_mut(&inp[..]) { debug_assert_eq!(result.output, &__ret[..]); if !unconstrained { *result.multiplicity += G::ONE; } } else { record.function_queries[475].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained)); }; + let __ret: [G; OUT_471] = [__v_34, __v_2, __v_3]; + if let Some(result) = record.function_queries[471].get_mut(&inp[..]) { debug_assert_eq!(result.output, &__ret[..]); if !unconstrained { *result.multiplicity += G::ONE; } } else { record.function_queries[471].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained)); }; return Ok(__ret); }, _ => { - let __r_arr: [G; OUT_477] = { let __args: [G; IN_477] = [__v_2, __v_3, __v_4, __v_5]; let __cu = unconstrained; if let Some(result) = record.function_queries[477].get_mut(&__args[..]) { if !__cu && *result.multiplicity == G::ZERO { aiur_fn_477(__args, record, io_buffer, false)? } else { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_477] = unsafe { *(result.output.as_ptr() as *const [G; OUT_477]) }; __ret } } else { aiur_fn_477(__args, record, io_buffer, __cu)? } }; + let __r_arr: [G; OUT_473] = { let __args: [G; IN_473] = [__v_2, __v_3, __v_4, __v_5]; let __cu = unconstrained; if let Some(result) = record.function_queries[473].get_mut(&__args[..]) { if !__cu && *result.multiplicity == G::ZERO { aiur_fn_473(__args, record, io_buffer, false)? } else { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_473] = unsafe { *(result.output.as_ptr() as *const [G; OUT_473]) }; __ret } } else { aiur_fn_473(__args, record, io_buffer, __cu)? } }; let __v_34: G = __r_arr[0]; let __v_35: G = __r_arr[1]; let __v_36: G = __r_arr[2]; - let __ret: [G; OUT_475] = [__v_34, __v_35, __v_36]; - if let Some(result) = record.function_queries[475].get_mut(&inp[..]) { debug_assert_eq!(result.output, &__ret[..]); if !unconstrained { *result.multiplicity += G::ONE; } } else { record.function_queries[475].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained)); }; + let __ret: [G; OUT_471] = [__v_34, __v_35, __v_36]; + if let Some(result) = record.function_queries[471].get_mut(&inp[..]) { debug_assert_eq!(result.output, &__ret[..]); if !unconstrained { *result.multiplicity += G::ONE; } } else { record.function_queries[471].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained)); }; return Ok(__ret); }, } @@ -42513,49 +42229,49 @@ fn aiur_fn_475( _ => { match __v_33.as_canonical_u64() { 0u64 => { - let __r_arr: [G; OUT_476] = { let __args: [G; IN_476] = [__v_2, __v_3, __v_4, __v_5]; let __cu = unconstrained; if let Some(result) = record.function_queries[476].get_mut(&__args[..]) { if !__cu && *result.multiplicity == G::ZERO { aiur_fn_476(__args, record, io_buffer, false)? } else { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_476] = unsafe { *(result.output.as_ptr() as *const [G; OUT_476]) }; __ret } } else { aiur_fn_476(__args, record, io_buffer, __cu)? } }; + let __r_arr: [G; OUT_472] = { let __args: [G; IN_472] = [__v_2, __v_3, __v_4, __v_5]; let __cu = unconstrained; if let Some(result) = record.function_queries[472].get_mut(&__args[..]) { if !__cu && *result.multiplicity == G::ZERO { aiur_fn_472(__args, record, io_buffer, false)? } else { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_472] = unsafe { *(result.output.as_ptr() as *const [G; OUT_472]) }; __ret } } else { aiur_fn_472(__args, record, io_buffer, __cu)? } }; let __v_34: G = __r_arr[0]; let __v_35: G = __r_arr[1]; let __v_36: G = __r_arr[2]; - let __ret: [G; OUT_475] = [__v_34, __v_35, __v_36]; - if let Some(result) = record.function_queries[475].get_mut(&inp[..]) { debug_assert_eq!(result.output, &__ret[..]); if !unconstrained { *result.multiplicity += G::ONE; } } else { record.function_queries[475].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained)); }; + let __ret: [G; OUT_471] = [__v_34, __v_35, __v_36]; + if let Some(result) = record.function_queries[471].get_mut(&inp[..]) { debug_assert_eq!(result.output, &__ret[..]); if !unconstrained { *result.multiplicity += G::ONE; } } else { record.function_queries[471].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained)); }; return Ok(__ret); }, _ => { - let __r_arr: [G; OUT_474] = { let __args: [G; IN_474] = [__v_7, __v_8, __v_9, __v_10, __v_11, __v_12, __v_13, __v_14, __v_15, __v_16, __v_17, __v_18]; let __cu = unconstrained; if let Some(result) = record.function_queries[474].get_mut(&__args[..]) { if !__cu && *result.multiplicity == G::ZERO { aiur_fn_474(__args, record, io_buffer, false)? } else { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_474] = unsafe { *(result.output.as_ptr() as *const [G; OUT_474]) }; __ret } } else { aiur_fn_474(__args, record, io_buffer, __cu)? } }; + let __r_arr: [G; OUT_470] = { let __args: [G; IN_470] = [__v_7, __v_8, __v_9, __v_10, __v_11, __v_12, __v_13, __v_14, __v_15, __v_16, __v_17, __v_18]; let __cu = unconstrained; if let Some(result) = record.function_queries[470].get_mut(&__args[..]) { if !__cu && *result.multiplicity == G::ZERO { aiur_fn_470(__args, record, io_buffer, false)? } else { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_470] = unsafe { *(result.output.as_ptr() as *const [G; OUT_470]) }; __ret } } else { aiur_fn_470(__args, record, io_buffer, __cu)? } }; let __v_34: G = __r_arr[0]; - let __r_arr: [G; OUT_474] = { let __args: [G; IN_474] = [__v_20, __v_21, __v_22, __v_23, __v_24, __v_25, __v_26, __v_27, __v_28, __v_29, __v_30, __v_31]; let __cu = unconstrained; if let Some(result) = record.function_queries[474].get_mut(&__args[..]) { if !__cu && *result.multiplicity == G::ZERO { aiur_fn_474(__args, record, io_buffer, false)? } else { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_474] = unsafe { *(result.output.as_ptr() as *const [G; OUT_474]) }; __ret } } else { aiur_fn_474(__args, record, io_buffer, __cu)? } }; + let __r_arr: [G; OUT_470] = { let __args: [G; IN_470] = [__v_20, __v_21, __v_22, __v_23, __v_24, __v_25, __v_26, __v_27, __v_28, __v_29, __v_30, __v_31]; let __cu = unconstrained; if let Some(result) = record.function_queries[470].get_mut(&__args[..]) { if !__cu && *result.multiplicity == G::ZERO { aiur_fn_470(__args, record, io_buffer, false)? } else { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_470] = unsafe { *(result.output.as_ptr() as *const [G; OUT_470]) }; __ret } } else { aiur_fn_470(__args, record, io_buffer, __cu)? } }; let __v_35: G = __r_arr[0]; let __v_36: G = { let __a_val = __v_35.as_canonical_u64(); let __b_val = __v_34.as_canonical_u64(); let __a_u32 = u32::try_from(__a_val).ok().ok_or(ExecError::U32OutOfRange(__a_val))?; let __b_u32 = u32::try_from(__b_val).ok().ok_or(ExecError::U32OutOfRange(__b_val))?; let __result = G::from_bool(__a_u32 < __b_u32); if !unconstrained { let __x_bytes = __a_u32.to_le_bytes(); let __z_bytes = __b_u32.to_le_bytes(); let __c_u32 = __b_u32.wrapping_sub(__a_u32).wrapping_sub(1); let __y_bytes = __c_u32.to_le_bytes(); record.bytes2_queries.bump_range_check(&G::from_u8(__x_bytes[0]), &G::from_u8(__x_bytes[1])); record.bytes2_queries.bump_range_check(&G::from_u8(__x_bytes[2]), &G::from_u8(__x_bytes[3])); record.bytes2_queries.bump_range_check(&G::from_u8(__y_bytes[0]), &G::from_u8(__y_bytes[1])); record.bytes2_queries.bump_range_check(&G::from_u8(__y_bytes[2]), &G::from_u8(__y_bytes[3])); record.bytes2_queries.bump_range_check(&G::from_u8(__z_bytes[0]), &G::from_u8(__z_bytes[1])); record.bytes2_queries.bump_range_check(&G::from_u8(__z_bytes[2]), &G::from_u8(__z_bytes[3])); } __result }; match __v_36.as_canonical_u64() { 1u64 => { - let __r_arr: [G; OUT_476] = { let __args: [G; IN_476] = [__v_2, __v_3, __v_4, __v_5]; let __cu = unconstrained; if let Some(result) = record.function_queries[476].get_mut(&__args[..]) { if !__cu && *result.multiplicity == G::ZERO { aiur_fn_476(__args, record, io_buffer, false)? } else { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_476] = unsafe { *(result.output.as_ptr() as *const [G; OUT_476]) }; __ret } } else { aiur_fn_476(__args, record, io_buffer, __cu)? } }; + let __r_arr: [G; OUT_472] = { let __args: [G; IN_472] = [__v_2, __v_3, __v_4, __v_5]; let __cu = unconstrained; if let Some(result) = record.function_queries[472].get_mut(&__args[..]) { if !__cu && *result.multiplicity == G::ZERO { aiur_fn_472(__args, record, io_buffer, false)? } else { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_472] = unsafe { *(result.output.as_ptr() as *const [G; OUT_472]) }; __ret } } else { aiur_fn_472(__args, record, io_buffer, __cu)? } }; let __v_37: G = __r_arr[0]; let __v_38: G = __r_arr[1]; let __v_39: G = __r_arr[2]; - let __ret: [G; OUT_475] = [__v_37, __v_38, __v_39]; - if let Some(result) = record.function_queries[475].get_mut(&inp[..]) { debug_assert_eq!(result.output, &__ret[..]); if !unconstrained { *result.multiplicity += G::ONE; } } else { record.function_queries[475].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained)); }; + let __ret: [G; OUT_471] = [__v_37, __v_38, __v_39]; + if let Some(result) = record.function_queries[471].get_mut(&inp[..]) { debug_assert_eq!(result.output, &__ret[..]); if !unconstrained { *result.multiplicity += G::ONE; } } else { record.function_queries[471].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained)); }; return Ok(__ret); }, _ => { let __v_37: G = { let __a_val = __v_34.as_canonical_u64(); let __b_val = __v_35.as_canonical_u64(); let __a_u32 = u32::try_from(__a_val).ok().ok_or(ExecError::U32OutOfRange(__a_val))?; let __b_u32 = u32::try_from(__b_val).ok().ok_or(ExecError::U32OutOfRange(__b_val))?; let __result = G::from_bool(__a_u32 < __b_u32); if !unconstrained { let __x_bytes = __a_u32.to_le_bytes(); let __z_bytes = __b_u32.to_le_bytes(); let __c_u32 = __b_u32.wrapping_sub(__a_u32).wrapping_sub(1); let __y_bytes = __c_u32.to_le_bytes(); record.bytes2_queries.bump_range_check(&G::from_u8(__x_bytes[0]), &G::from_u8(__x_bytes[1])); record.bytes2_queries.bump_range_check(&G::from_u8(__x_bytes[2]), &G::from_u8(__x_bytes[3])); record.bytes2_queries.bump_range_check(&G::from_u8(__y_bytes[0]), &G::from_u8(__y_bytes[1])); record.bytes2_queries.bump_range_check(&G::from_u8(__y_bytes[2]), &G::from_u8(__y_bytes[3])); record.bytes2_queries.bump_range_check(&G::from_u8(__z_bytes[0]), &G::from_u8(__z_bytes[1])); record.bytes2_queries.bump_range_check(&G::from_u8(__z_bytes[2]), &G::from_u8(__z_bytes[3])); } __result }; match __v_37.as_canonical_u64() { 1u64 => { - let __r_arr: [G; OUT_477] = { let __args: [G; IN_477] = [__v_2, __v_3, __v_4, __v_5]; let __cu = unconstrained; if let Some(result) = record.function_queries[477].get_mut(&__args[..]) { if !__cu && *result.multiplicity == G::ZERO { aiur_fn_477(__args, record, io_buffer, false)? } else { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_477] = unsafe { *(result.output.as_ptr() as *const [G; OUT_477]) }; __ret } } else { aiur_fn_477(__args, record, io_buffer, __cu)? } }; + let __r_arr: [G; OUT_473] = { let __args: [G; IN_473] = [__v_2, __v_3, __v_4, __v_5]; let __cu = unconstrained; if let Some(result) = record.function_queries[473].get_mut(&__args[..]) { if !__cu && *result.multiplicity == G::ZERO { aiur_fn_473(__args, record, io_buffer, false)? } else { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_473] = unsafe { *(result.output.as_ptr() as *const [G; OUT_473]) }; __ret } } else { aiur_fn_473(__args, record, io_buffer, __cu)? } }; let __v_38: G = __r_arr[0]; let __v_39: G = __r_arr[1]; let __v_40: G = __r_arr[2]; - let __ret: [G; OUT_475] = [__v_38, __v_39, __v_40]; - if let Some(result) = record.function_queries[475].get_mut(&inp[..]) { debug_assert_eq!(result.output, &__ret[..]); if !unconstrained { *result.multiplicity += G::ONE; } } else { record.function_queries[475].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained)); }; + let __ret: [G; OUT_471] = [__v_38, __v_39, __v_40]; + if let Some(result) = record.function_queries[471].get_mut(&inp[..]) { debug_assert_eq!(result.output, &__ret[..]); if !unconstrained { *result.multiplicity += G::ONE; } } else { record.function_queries[471].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained)); }; return Ok(__ret); }, _ => { - let __r_arr: [G; OUT_478] = { let __args: [G; IN_478] = [__v_2, __v_3, __v_4, __v_5]; let __cu = unconstrained; if let Some(result) = record.function_queries[478].get_mut(&__args[..]) { if !__cu && *result.multiplicity == G::ZERO { aiur_fn_478(__args, record, io_buffer, false)? } else { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_478] = unsafe { *(result.output.as_ptr() as *const [G; OUT_478]) }; __ret } } else { aiur_fn_478(__args, record, io_buffer, __cu)? } }; + let __r_arr: [G; OUT_474] = { let __args: [G; IN_474] = [__v_2, __v_3, __v_4, __v_5]; let __cu = unconstrained; if let Some(result) = record.function_queries[474].get_mut(&__args[..]) { if !__cu && *result.multiplicity == G::ZERO { aiur_fn_474(__args, record, io_buffer, false)? } else { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_474] = unsafe { *(result.output.as_ptr() as *const [G; OUT_474]) }; __ret } } else { aiur_fn_474(__args, record, io_buffer, __cu)? } }; let __v_38: G = __r_arr[0]; let __v_39: G = __r_arr[1]; let __v_40: G = __r_arr[2]; - let __ret: [G; OUT_475] = [__v_38, __v_39, __v_40]; - if let Some(result) = record.function_queries[475].get_mut(&inp[..]) { debug_assert_eq!(result.output, &__ret[..]); if !unconstrained { *result.multiplicity += G::ONE; } } else { record.function_queries[475].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained)); }; + let __ret: [G; OUT_471] = [__v_38, __v_39, __v_40]; + if let Some(result) = record.function_queries[471].get_mut(&inp[..]) { debug_assert_eq!(result.output, &__ret[..]); if !unconstrained { *result.multiplicity += G::ONE; } } else { record.function_queries[471].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained)); }; return Ok(__ret); }, } @@ -42568,176 +42284,176 @@ fn aiur_fn_475( }) } -const INPUT_SIZE_476: usize = 4; -const IN_476: usize = 4; -const OUT_476: usize = 3; -fn aiur_fn_476( - inp: [G; IN_476], +const INPUT_SIZE_472: usize = 4; +const IN_472: usize = 4; +const OUT_472: usize = 3; +fn aiur_fn_472( + inp: [G; IN_472], record: &mut QueryRecord, io_buffer: &mut IOBuffer, unconstrained: bool, -) -> Result<[G; OUT_476], ExecError> { +) -> Result<[G; OUT_472], ExecError> { stacker::maybe_grow(64 * 1024, 4 * 1024 * 1024, || { let __v_0: G = inp[0]; let __v_1: G = inp[1]; let __v_2: G = inp[2]; let __v_3: G = inp[3]; - let __r_arr: [G; OUT_484] = { let __args: [G; IN_484] = [__v_0]; let __cu = unconstrained; if let Some(result) = record.function_queries[484].get_mut(&__args[..]) { if !__cu && *result.multiplicity == G::ZERO { aiur_fn_484(__args, record, io_buffer, false)? } else { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_484] = unsafe { *(result.output.as_ptr() as *const [G; OUT_484]) }; __ret } } else { aiur_fn_484(__args, record, io_buffer, __cu)? } }; + let __r_arr: [G; OUT_480] = { let __args: [G; IN_480] = [__v_0]; let __cu = unconstrained; if let Some(result) = record.function_queries[480].get_mut(&__args[..]) { if !__cu && *result.multiplicity == G::ZERO { aiur_fn_480(__args, record, io_buffer, false)? } else { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_480] = unsafe { *(result.output.as_ptr() as *const [G; OUT_480]) }; __ret } } else { aiur_fn_480(__args, record, io_buffer, __cu)? } }; let __v_4: G = __r_arr[0]; let __v_5: G = __r_arr[1]; match __v_4.as_canonical_u64() { 1u64 => { - let __r_arr: [G; OUT_424] = { let __args: [G; IN_424] = [__v_5, __v_3]; let __cu = unconstrained; if let Some(result) = record.function_queries[424].get_mut(&__args[..]) { if !__cu && *result.multiplicity == G::ZERO { aiur_fn_424(__args, record, io_buffer, false)? } else { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_424] = unsafe { *(result.output.as_ptr() as *const [G; OUT_424]) }; __ret } } else { aiur_fn_424(__args, record, io_buffer, __cu)? } }; + let __r_arr: [G; OUT_420] = { let __args: [G; IN_420] = [__v_5, __v_3]; let __cu = unconstrained; if let Some(result) = record.function_queries[420].get_mut(&__args[..]) { if !__cu && *result.multiplicity == G::ZERO { aiur_fn_420(__args, record, io_buffer, false)? } else { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_420] = unsafe { *(result.output.as_ptr() as *const [G; OUT_420]) }; __ret } } else { aiur_fn_420(__args, record, io_buffer, __cu)? } }; let __v_6: G = __r_arr[0]; let __v_7: G = G::from_u64(1); let __v_8: G = (__v_2 - __v_7); - let __r_arr: [G; OUT_473] = { let __args: [G; IN_473] = [__v_6, __v_1, __v_8, __v_3]; let __cu = unconstrained; if let Some(result) = record.function_queries[473].get_mut(&__args[..]) { if !__cu && *result.multiplicity == G::ZERO { aiur_fn_473(__args, record, io_buffer, false)? } else { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_473] = unsafe { *(result.output.as_ptr() as *const [G; OUT_473]) }; __ret } } else { aiur_fn_473(__args, record, io_buffer, __cu)? } }; + let __r_arr: [G; OUT_469] = { let __args: [G; IN_469] = [__v_6, __v_1, __v_8, __v_3]; let __cu = unconstrained; if let Some(result) = record.function_queries[469].get_mut(&__args[..]) { if !__cu && *result.multiplicity == G::ZERO { aiur_fn_469(__args, record, io_buffer, false)? } else { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_469] = unsafe { *(result.output.as_ptr() as *const [G; OUT_469]) }; __ret } } else { aiur_fn_469(__args, record, io_buffer, __cu)? } }; let __v_9: G = __r_arr[0]; let __v_10: G = __r_arr[1]; let __v_11: G = __r_arr[2]; - let __ret: [G; OUT_476] = [__v_9, __v_10, __v_11]; - if let Some(result) = record.function_queries[476].get_mut(&inp[..]) { debug_assert_eq!(result.output, &__ret[..]); if !unconstrained { *result.multiplicity += G::ONE; } } else { record.function_queries[476].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained)); }; + let __ret: [G; OUT_472] = [__v_9, __v_10, __v_11]; + if let Some(result) = record.function_queries[472].get_mut(&inp[..]) { debug_assert_eq!(result.output, &__ret[..]); if !unconstrained { *result.multiplicity += G::ONE; } } else { record.function_queries[472].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained)); }; return Ok(__ret); }, _ => { let __v_6: G = G::from_u64(0); - let __ret: [G; OUT_476] = [__v_6, __v_0, __v_1]; - if let Some(result) = record.function_queries[476].get_mut(&inp[..]) { debug_assert_eq!(result.output, &__ret[..]); if !unconstrained { *result.multiplicity += G::ONE; } } else { record.function_queries[476].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained)); }; + let __ret: [G; OUT_472] = [__v_6, __v_0, __v_1]; + if let Some(result) = record.function_queries[472].get_mut(&inp[..]) { debug_assert_eq!(result.output, &__ret[..]); if !unconstrained { *result.multiplicity += G::ONE; } } else { record.function_queries[472].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained)); }; return Ok(__ret); }, } }) } -const INPUT_SIZE_477: usize = 4; -const IN_477: usize = 4; -const OUT_477: usize = 3; -fn aiur_fn_477( - inp: [G; IN_477], +const INPUT_SIZE_473: usize = 4; +const IN_473: usize = 4; +const OUT_473: usize = 3; +fn aiur_fn_473( + inp: [G; IN_473], record: &mut QueryRecord, io_buffer: &mut IOBuffer, unconstrained: bool, -) -> Result<[G; OUT_477], ExecError> { +) -> Result<[G; OUT_473], ExecError> { stacker::maybe_grow(64 * 1024, 4 * 1024 * 1024, || { let __v_0: G = inp[0]; let __v_1: G = inp[1]; let __v_2: G = inp[2]; let __v_3: G = inp[3]; - let __r_arr: [G; OUT_484] = { let __args: [G; IN_484] = [__v_1]; let __cu = unconstrained; if let Some(result) = record.function_queries[484].get_mut(&__args[..]) { if !__cu && *result.multiplicity == G::ZERO { aiur_fn_484(__args, record, io_buffer, false)? } else { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_484] = unsafe { *(result.output.as_ptr() as *const [G; OUT_484]) }; __ret } } else { aiur_fn_484(__args, record, io_buffer, __cu)? } }; + let __r_arr: [G; OUT_480] = { let __args: [G; IN_480] = [__v_1]; let __cu = unconstrained; if let Some(result) = record.function_queries[480].get_mut(&__args[..]) { if !__cu && *result.multiplicity == G::ZERO { aiur_fn_480(__args, record, io_buffer, false)? } else { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_480] = unsafe { *(result.output.as_ptr() as *const [G; OUT_480]) }; __ret } } else { aiur_fn_480(__args, record, io_buffer, __cu)? } }; let __v_4: G = __r_arr[0]; let __v_5: G = __r_arr[1]; match __v_4.as_canonical_u64() { 1u64 => { - let __r_arr: [G; OUT_424] = { let __args: [G; IN_424] = [__v_5, __v_3]; let __cu = unconstrained; if let Some(result) = record.function_queries[424].get_mut(&__args[..]) { if !__cu && *result.multiplicity == G::ZERO { aiur_fn_424(__args, record, io_buffer, false)? } else { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_424] = unsafe { *(result.output.as_ptr() as *const [G; OUT_424]) }; __ret } } else { aiur_fn_424(__args, record, io_buffer, __cu)? } }; + let __r_arr: [G; OUT_420] = { let __args: [G; IN_420] = [__v_5, __v_3]; let __cu = unconstrained; if let Some(result) = record.function_queries[420].get_mut(&__args[..]) { if !__cu && *result.multiplicity == G::ZERO { aiur_fn_420(__args, record, io_buffer, false)? } else { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_420] = unsafe { *(result.output.as_ptr() as *const [G; OUT_420]) }; __ret } } else { aiur_fn_420(__args, record, io_buffer, __cu)? } }; let __v_6: G = __r_arr[0]; let __v_7: G = G::from_u64(1); let __v_8: G = (__v_2 - __v_7); - let __r_arr: [G; OUT_473] = { let __args: [G; IN_473] = [__v_0, __v_6, __v_8, __v_3]; let __cu = unconstrained; if let Some(result) = record.function_queries[473].get_mut(&__args[..]) { if !__cu && *result.multiplicity == G::ZERO { aiur_fn_473(__args, record, io_buffer, false)? } else { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_473] = unsafe { *(result.output.as_ptr() as *const [G; OUT_473]) }; __ret } } else { aiur_fn_473(__args, record, io_buffer, __cu)? } }; + let __r_arr: [G; OUT_469] = { let __args: [G; IN_469] = [__v_0, __v_6, __v_8, __v_3]; let __cu = unconstrained; if let Some(result) = record.function_queries[469].get_mut(&__args[..]) { if !__cu && *result.multiplicity == G::ZERO { aiur_fn_469(__args, record, io_buffer, false)? } else { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_469] = unsafe { *(result.output.as_ptr() as *const [G; OUT_469]) }; __ret } } else { aiur_fn_469(__args, record, io_buffer, __cu)? } }; let __v_9: G = __r_arr[0]; let __v_10: G = __r_arr[1]; let __v_11: G = __r_arr[2]; - let __ret: [G; OUT_477] = [__v_9, __v_10, __v_11]; - if let Some(result) = record.function_queries[477].get_mut(&inp[..]) { debug_assert_eq!(result.output, &__ret[..]); if !unconstrained { *result.multiplicity += G::ONE; } } else { record.function_queries[477].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained)); }; + let __ret: [G; OUT_473] = [__v_9, __v_10, __v_11]; + if let Some(result) = record.function_queries[473].get_mut(&inp[..]) { debug_assert_eq!(result.output, &__ret[..]); if !unconstrained { *result.multiplicity += G::ONE; } } else { record.function_queries[473].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained)); }; return Ok(__ret); }, _ => { let __v_6: G = G::from_u64(0); - let __ret: [G; OUT_477] = [__v_6, __v_0, __v_1]; - if let Some(result) = record.function_queries[477].get_mut(&inp[..]) { debug_assert_eq!(result.output, &__ret[..]); if !unconstrained { *result.multiplicity += G::ONE; } } else { record.function_queries[477].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained)); }; + let __ret: [G; OUT_473] = [__v_6, __v_0, __v_1]; + if let Some(result) = record.function_queries[473].get_mut(&inp[..]) { debug_assert_eq!(result.output, &__ret[..]); if !unconstrained { *result.multiplicity += G::ONE; } } else { record.function_queries[473].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained)); }; return Ok(__ret); }, } }) } -const INPUT_SIZE_478: usize = 4; -const IN_478: usize = 4; -const OUT_478: usize = 3; -fn aiur_fn_478( - inp: [G; IN_478], +const INPUT_SIZE_474: usize = 4; +const IN_474: usize = 4; +const OUT_474: usize = 3; +fn aiur_fn_474( + inp: [G; IN_474], record: &mut QueryRecord, io_buffer: &mut IOBuffer, unconstrained: bool, -) -> Result<[G; OUT_478], ExecError> { +) -> Result<[G; OUT_474], ExecError> { stacker::maybe_grow(64 * 1024, 4 * 1024 * 1024, || { let __v_0: G = inp[0]; let __v_1: G = inp[1]; let __v_2: G = inp[2]; let __v_3: G = inp[3]; - let __r_arr: [G; OUT_484] = { let __args: [G; IN_484] = [__v_0]; let __cu = unconstrained; if let Some(result) = record.function_queries[484].get_mut(&__args[..]) { if !__cu && *result.multiplicity == G::ZERO { aiur_fn_484(__args, record, io_buffer, false)? } else { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_484] = unsafe { *(result.output.as_ptr() as *const [G; OUT_484]) }; __ret } } else { aiur_fn_484(__args, record, io_buffer, __cu)? } }; + let __r_arr: [G; OUT_480] = { let __args: [G; IN_480] = [__v_0]; let __cu = unconstrained; if let Some(result) = record.function_queries[480].get_mut(&__args[..]) { if !__cu && *result.multiplicity == G::ZERO { aiur_fn_480(__args, record, io_buffer, false)? } else { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_480] = unsafe { *(result.output.as_ptr() as *const [G; OUT_480]) }; __ret } } else { aiur_fn_480(__args, record, io_buffer, __cu)? } }; let __v_4: G = __r_arr[0]; let __v_5: G = __r_arr[1]; match __v_4.as_canonical_u64() { 1u64 => { - let __r_arr: [G; OUT_484] = { let __args: [G; IN_484] = [__v_1]; let __cu = unconstrained; if let Some(result) = record.function_queries[484].get_mut(&__args[..]) { if !__cu && *result.multiplicity == G::ZERO { aiur_fn_484(__args, record, io_buffer, false)? } else { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_484] = unsafe { *(result.output.as_ptr() as *const [G; OUT_484]) }; __ret } } else { aiur_fn_484(__args, record, io_buffer, __cu)? } }; + let __r_arr: [G; OUT_480] = { let __args: [G; IN_480] = [__v_1]; let __cu = unconstrained; if let Some(result) = record.function_queries[480].get_mut(&__args[..]) { if !__cu && *result.multiplicity == G::ZERO { aiur_fn_480(__args, record, io_buffer, false)? } else { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_480] = unsafe { *(result.output.as_ptr() as *const [G; OUT_480]) }; __ret } } else { aiur_fn_480(__args, record, io_buffer, __cu)? } }; let __v_6: G = __r_arr[0]; let __v_7: G = __r_arr[1]; match __v_6.as_canonical_u64() { 1u64 => { - let __r_arr: [G; OUT_424] = { let __args: [G; IN_424] = [__v_5, __v_3]; let __cu = unconstrained; if let Some(result) = record.function_queries[424].get_mut(&__args[..]) { if !__cu && *result.multiplicity == G::ZERO { aiur_fn_424(__args, record, io_buffer, false)? } else { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_424] = unsafe { *(result.output.as_ptr() as *const [G; OUT_424]) }; __ret } } else { aiur_fn_424(__args, record, io_buffer, __cu)? } }; + let __r_arr: [G; OUT_420] = { let __args: [G; IN_420] = [__v_5, __v_3]; let __cu = unconstrained; if let Some(result) = record.function_queries[420].get_mut(&__args[..]) { if !__cu && *result.multiplicity == G::ZERO { aiur_fn_420(__args, record, io_buffer, false)? } else { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_420] = unsafe { *(result.output.as_ptr() as *const [G; OUT_420]) }; __ret } } else { aiur_fn_420(__args, record, io_buffer, __cu)? } }; let __v_8: G = __r_arr[0]; - let __r_arr: [G; OUT_424] = { let __args: [G; IN_424] = [__v_7, __v_3]; let __cu = unconstrained; if let Some(result) = record.function_queries[424].get_mut(&__args[..]) { if !__cu && *result.multiplicity == G::ZERO { aiur_fn_424(__args, record, io_buffer, false)? } else { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_424] = unsafe { *(result.output.as_ptr() as *const [G; OUT_424]) }; __ret } } else { aiur_fn_424(__args, record, io_buffer, __cu)? } }; + let __r_arr: [G; OUT_420] = { let __args: [G; IN_420] = [__v_7, __v_3]; let __cu = unconstrained; if let Some(result) = record.function_queries[420].get_mut(&__args[..]) { if !__cu && *result.multiplicity == G::ZERO { aiur_fn_420(__args, record, io_buffer, false)? } else { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_420] = unsafe { *(result.output.as_ptr() as *const [G; OUT_420]) }; __ret } } else { aiur_fn_420(__args, record, io_buffer, __cu)? } }; let __v_9: G = __r_arr[0]; let __v_10: G = G::from_u64(1); let __v_11: G = (__v_2 - __v_10); - let __r_arr: [G; OUT_473] = { let __args: [G; IN_473] = [__v_8, __v_9, __v_11, __v_3]; let __cu = unconstrained; if let Some(result) = record.function_queries[473].get_mut(&__args[..]) { if !__cu && *result.multiplicity == G::ZERO { aiur_fn_473(__args, record, io_buffer, false)? } else { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_473] = unsafe { *(result.output.as_ptr() as *const [G; OUT_473]) }; __ret } } else { aiur_fn_473(__args, record, io_buffer, __cu)? } }; + let __r_arr: [G; OUT_469] = { let __args: [G; IN_469] = [__v_8, __v_9, __v_11, __v_3]; let __cu = unconstrained; if let Some(result) = record.function_queries[469].get_mut(&__args[..]) { if !__cu && *result.multiplicity == G::ZERO { aiur_fn_469(__args, record, io_buffer, false)? } else { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_469] = unsafe { *(result.output.as_ptr() as *const [G; OUT_469]) }; __ret } } else { aiur_fn_469(__args, record, io_buffer, __cu)? } }; let __v_12: G = __r_arr[0]; let __v_13: G = __r_arr[1]; let __v_14: G = __r_arr[2]; - let __ret: [G; OUT_478] = [__v_12, __v_13, __v_14]; - if let Some(result) = record.function_queries[478].get_mut(&inp[..]) { debug_assert_eq!(result.output, &__ret[..]); if !unconstrained { *result.multiplicity += G::ONE; } } else { record.function_queries[478].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained)); }; + let __ret: [G; OUT_474] = [__v_12, __v_13, __v_14]; + if let Some(result) = record.function_queries[474].get_mut(&inp[..]) { debug_assert_eq!(result.output, &__ret[..]); if !unconstrained { *result.multiplicity += G::ONE; } } else { record.function_queries[474].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained)); }; return Ok(__ret); }, _ => { let __v_8: G = G::from_u64(0); - let __ret: [G; OUT_478] = [__v_8, __v_0, __v_1]; - if let Some(result) = record.function_queries[478].get_mut(&inp[..]) { debug_assert_eq!(result.output, &__ret[..]); if !unconstrained { *result.multiplicity += G::ONE; } } else { record.function_queries[478].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained)); }; + let __ret: [G; OUT_474] = [__v_8, __v_0, __v_1]; + if let Some(result) = record.function_queries[474].get_mut(&inp[..]) { debug_assert_eq!(result.output, &__ret[..]); if !unconstrained { *result.multiplicity += G::ONE; } } else { record.function_queries[474].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained)); }; return Ok(__ret); }, } }, _ => { let __v_6: G = G::from_u64(0); - let __ret: [G; OUT_478] = [__v_6, __v_0, __v_1]; - if let Some(result) = record.function_queries[478].get_mut(&inp[..]) { debug_assert_eq!(result.output, &__ret[..]); if !unconstrained { *result.multiplicity += G::ONE; } } else { record.function_queries[478].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained)); }; + let __ret: [G; OUT_474] = [__v_6, __v_0, __v_1]; + if let Some(result) = record.function_queries[474].get_mut(&inp[..]) { debug_assert_eq!(result.output, &__ret[..]); if !unconstrained { *result.multiplicity += G::ONE; } } else { record.function_queries[474].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained)); }; return Ok(__ret); }, } }) } -const INPUT_SIZE_479: usize = 5; -const IN_479: usize = 5; -const OUT_479: usize = 3; -fn aiur_fn_479( - inp: [G; IN_479], +const INPUT_SIZE_475: usize = 5; +const IN_475: usize = 5; +const OUT_475: usize = 3; +fn aiur_fn_475( + inp: [G; IN_475], record: &mut QueryRecord, io_buffer: &mut IOBuffer, unconstrained: bool, -) -> Result<[G; OUT_479], ExecError> { +) -> Result<[G; OUT_475], ExecError> { stacker::maybe_grow(64 * 1024, 4 * 1024 * 1024, || { let __v_0: G = inp[0]; let __v_1: G = inp[1]; let __v_2: G = inp[2]; let __v_3: G = inp[3]; let __v_4: G = inp[4]; - let __r_arr: [G; OUT_483] = { let __args: [G; IN_483] = [__v_2, __v_4]; let __cu = unconstrained; if let Some(result) = record.function_queries[483].get_mut(&__args[..]) { if !__cu && *result.multiplicity == G::ZERO { aiur_fn_483(__args, record, io_buffer, false)? } else { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_483] = unsafe { *(result.output.as_ptr() as *const [G; OUT_483]) }; __ret } } else { aiur_fn_483(__args, record, io_buffer, __cu)? } }; + let __r_arr: [G; OUT_479] = { let __args: [G; IN_479] = [__v_2, __v_4]; let __cu = unconstrained; if let Some(result) = record.function_queries[479].get_mut(&__args[..]) { if !__cu && *result.multiplicity == G::ZERO { aiur_fn_479(__args, record, io_buffer, false)? } else { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_479] = unsafe { *(result.output.as_ptr() as *const [G; OUT_479]) }; __ret } } else { aiur_fn_479(__args, record, io_buffer, __cu)? } }; let __v_5: G = __r_arr[0]; let __v_6: G = __r_arr[1]; match __v_5.as_canonical_u64() { 1u64 => { let __v_7: G = G::from_u64(1); let __v_8: G = (__v_3 - __v_7); - let __r_arr: [G; OUT_473] = { let __args: [G; IN_473] = [__v_1, __v_6, __v_8, __v_4]; let __cu = unconstrained; if let Some(result) = record.function_queries[473].get_mut(&__args[..]) { if !__cu && *result.multiplicity == G::ZERO { aiur_fn_473(__args, record, io_buffer, false)? } else { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_473] = unsafe { *(result.output.as_ptr() as *const [G; OUT_473]) }; __ret } } else { aiur_fn_473(__args, record, io_buffer, __cu)? } }; + let __r_arr: [G; OUT_469] = { let __args: [G; IN_469] = [__v_1, __v_6, __v_8, __v_4]; let __cu = unconstrained; if let Some(result) = record.function_queries[469].get_mut(&__args[..]) { if !__cu && *result.multiplicity == G::ZERO { aiur_fn_469(__args, record, io_buffer, false)? } else { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_469] = unsafe { *(result.output.as_ptr() as *const [G; OUT_469]) }; __ret } } else { aiur_fn_469(__args, record, io_buffer, __cu)? } }; let __v_9: G = __r_arr[0]; let __v_10: G = __r_arr[1]; let __v_11: G = __r_arr[2]; - let __ret: [G; OUT_479] = [__v_9, __v_10, __v_11]; - if let Some(result) = record.function_queries[479].get_mut(&inp[..]) { debug_assert_eq!(result.output, &__ret[..]); if !unconstrained { *result.multiplicity += G::ONE; } } else { record.function_queries[479].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained)); }; + let __ret: [G; OUT_475] = [__v_9, __v_10, __v_11]; + if let Some(result) = record.function_queries[475].get_mut(&inp[..]) { debug_assert_eq!(result.output, &__ret[..]); if !unconstrained { *result.multiplicity += G::ONE; } } else { record.function_queries[475].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained)); }; return Ok(__ret); }, _ => { - let __r_arr: [G; OUT_287] = { let __args: [G; IN_287] = [__v_0]; let __cu = unconstrained; if let Some(result) = record.function_queries[287].get_mut(&__args[..]) { if !__cu && *result.multiplicity == G::ZERO { aiur_fn_287(__args, record, io_buffer, false)? } else { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_287] = unsafe { *(result.output.as_ptr() as *const [G; OUT_287]) }; __ret } } else { aiur_fn_287(__args, record, io_buffer, __cu)? } }; + let __r_arr: [G; OUT_283] = { let __args: [G; IN_283] = [__v_0]; let __cu = unconstrained; if let Some(result) = record.function_queries[283].get_mut(&__args[..]) { if !__cu && *result.multiplicity == G::ZERO { aiur_fn_283(__args, record, io_buffer, false)? } else { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_283] = unsafe { *(result.output.as_ptr() as *const [G; OUT_283]) }; __ret } } else { aiur_fn_283(__args, record, io_buffer, __cu)? } }; let __v_7: G = __r_arr[0]; let __loaded: [G; 12] = { let __mq = record.memory_queries.get_mut(&12).ok_or(ExecError::InvalidMemorySize(12))?; let __ptr_u64 = __v_7.as_canonical_u64(); let __ptr_usize = usize::try_from(__ptr_u64).ok().ok_or(ExecError::PointerTooLarge(__ptr_u64))?; let (__args, __mult) = __mq.get_index_mut(__ptr_usize).ok_or(ExecError::UnboundPointer { ptr: __ptr_u64, size: 12 })?; if !unconstrained { *__mult += G::ONE; } let __arr: [G; 12] = __args[..12].try_into().unwrap(); __arr }; let __v_8: G = __loaded[0]; @@ -42752,35 +42468,35 @@ fn aiur_fn_479( let __v_17: G = __loaded[9]; let __v_18: G = __loaded[10]; let __v_19: G = __loaded[11]; - let __r_arr: [G; OUT_482] = { let __args: [G; IN_482] = [__v_8, __v_9, __v_10, __v_11, __v_12, __v_13, __v_14, __v_15, __v_16, __v_17, __v_18, __v_19]; let __cu = unconstrained; if let Some(result) = record.function_queries[482].get_mut(&__args[..]) { if !__cu && *result.multiplicity == G::ZERO { aiur_fn_482(__args, record, io_buffer, false)? } else { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_482] = unsafe { *(result.output.as_ptr() as *const [G; OUT_482]) }; __ret } } else { aiur_fn_482(__args, record, io_buffer, __cu)? } }; + let __r_arr: [G; OUT_478] = { let __args: [G; IN_478] = [__v_8, __v_9, __v_10, __v_11, __v_12, __v_13, __v_14, __v_15, __v_16, __v_17, __v_18, __v_19]; let __cu = unconstrained; if let Some(result) = record.function_queries[478].get_mut(&__args[..]) { if !__cu && *result.multiplicity == G::ZERO { aiur_fn_478(__args, record, io_buffer, false)? } else { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_478] = unsafe { *(result.output.as_ptr() as *const [G; OUT_478]) }; __ret } } else { aiur_fn_478(__args, record, io_buffer, __cu)? } }; let __v_20: G = __r_arr[0]; match __v_20.as_canonical_u64() { 0u64 => { let __v_21: G = G::from_u64(0); - let __ret: [G; OUT_479] = [__v_21, __v_1, __v_2]; - if let Some(result) = record.function_queries[479].get_mut(&inp[..]) { debug_assert_eq!(result.output, &__ret[..]); if !unconstrained { *result.multiplicity += G::ONE; } } else { record.function_queries[479].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained)); }; + let __ret: [G; OUT_475] = [__v_21, __v_1, __v_2]; + if let Some(result) = record.function_queries[475].get_mut(&inp[..]) { debug_assert_eq!(result.output, &__ret[..]); if !unconstrained { *result.multiplicity += G::ONE; } } else { record.function_queries[475].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained)); }; return Ok(__ret); }, _ => { - let __r_arr: [G; OUT_487] = { let __args: [G; IN_487] = [__v_1, __v_8, __v_9, __v_10, __v_11, __v_12, __v_13, __v_14, __v_15, __v_16, __v_17, __v_18, __v_19, __v_4]; let __cu = unconstrained; if let Some(result) = record.function_queries[487].get_mut(&__args[..]) { if !__cu && *result.multiplicity == G::ZERO { aiur_fn_487(__args, record, io_buffer, false)? } else { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_487] = unsafe { *(result.output.as_ptr() as *const [G; OUT_487]) }; __ret } } else { aiur_fn_487(__args, record, io_buffer, __cu)? } }; + let __r_arr: [G; OUT_483] = { let __args: [G; IN_483] = [__v_1, __v_8, __v_9, __v_10, __v_11, __v_12, __v_13, __v_14, __v_15, __v_16, __v_17, __v_18, __v_19, __v_4]; let __cu = unconstrained; if let Some(result) = record.function_queries[483].get_mut(&__args[..]) { if !__cu && *result.multiplicity == G::ZERO { aiur_fn_483(__args, record, io_buffer, false)? } else { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_483] = unsafe { *(result.output.as_ptr() as *const [G; OUT_483]) }; __ret } } else { aiur_fn_483(__args, record, io_buffer, __cu)? } }; let __v_21: G = __r_arr[0]; let __v_22: G = __r_arr[1]; match __v_21.as_canonical_u64() { 1u64 => { let __v_23: G = G::from_u64(1); let __v_24: G = (__v_3 - __v_23); - let __r_arr: [G; OUT_473] = { let __args: [G; IN_473] = [__v_22, __v_2, __v_24, __v_4]; let __cu = unconstrained; if let Some(result) = record.function_queries[473].get_mut(&__args[..]) { if !__cu && *result.multiplicity == G::ZERO { aiur_fn_473(__args, record, io_buffer, false)? } else { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_473] = unsafe { *(result.output.as_ptr() as *const [G; OUT_473]) }; __ret } } else { aiur_fn_473(__args, record, io_buffer, __cu)? } }; + let __r_arr: [G; OUT_469] = { let __args: [G; IN_469] = [__v_22, __v_2, __v_24, __v_4]; let __cu = unconstrained; if let Some(result) = record.function_queries[469].get_mut(&__args[..]) { if !__cu && *result.multiplicity == G::ZERO { aiur_fn_469(__args, record, io_buffer, false)? } else { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_469] = unsafe { *(result.output.as_ptr() as *const [G; OUT_469]) }; __ret } } else { aiur_fn_469(__args, record, io_buffer, __cu)? } }; let __v_25: G = __r_arr[0]; let __v_26: G = __r_arr[1]; let __v_27: G = __r_arr[2]; - let __ret: [G; OUT_479] = [__v_25, __v_26, __v_27]; - if let Some(result) = record.function_queries[479].get_mut(&inp[..]) { debug_assert_eq!(result.output, &__ret[..]); if !unconstrained { *result.multiplicity += G::ONE; } } else { record.function_queries[479].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained)); }; + let __ret: [G; OUT_475] = [__v_25, __v_26, __v_27]; + if let Some(result) = record.function_queries[475].get_mut(&inp[..]) { debug_assert_eq!(result.output, &__ret[..]); if !unconstrained { *result.multiplicity += G::ONE; } } else { record.function_queries[475].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained)); }; return Ok(__ret); }, _ => { let __v_23: G = G::from_u64(0); - let __ret: [G; OUT_479] = [__v_23, __v_1, __v_2]; - if let Some(result) = record.function_queries[479].get_mut(&inp[..]) { debug_assert_eq!(result.output, &__ret[..]); if !unconstrained { *result.multiplicity += G::ONE; } } else { record.function_queries[479].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained)); }; + let __ret: [G; OUT_475] = [__v_23, __v_1, __v_2]; + if let Some(result) = record.function_queries[475].get_mut(&inp[..]) { debug_assert_eq!(result.output, &__ret[..]); if !unconstrained { *result.multiplicity += G::ONE; } } else { record.function_queries[475].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained)); }; return Ok(__ret); }, } @@ -42791,38 +42507,38 @@ fn aiur_fn_479( }) } -const INPUT_SIZE_480: usize = 5; -const IN_480: usize = 5; -const OUT_480: usize = 3; -fn aiur_fn_480( - inp: [G; IN_480], +const INPUT_SIZE_476: usize = 5; +const IN_476: usize = 5; +const OUT_476: usize = 3; +fn aiur_fn_476( + inp: [G; IN_476], record: &mut QueryRecord, io_buffer: &mut IOBuffer, unconstrained: bool, -) -> Result<[G; OUT_480], ExecError> { +) -> Result<[G; OUT_476], ExecError> { stacker::maybe_grow(64 * 1024, 4 * 1024 * 1024, || { let __v_0: G = inp[0]; let __v_1: G = inp[1]; let __v_2: G = inp[2]; let __v_3: G = inp[3]; let __v_4: G = inp[4]; - let __r_arr: [G; OUT_483] = { let __args: [G; IN_483] = [__v_1, __v_4]; let __cu = unconstrained; if let Some(result) = record.function_queries[483].get_mut(&__args[..]) { if !__cu && *result.multiplicity == G::ZERO { aiur_fn_483(__args, record, io_buffer, false)? } else { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_483] = unsafe { *(result.output.as_ptr() as *const [G; OUT_483]) }; __ret } } else { aiur_fn_483(__args, record, io_buffer, __cu)? } }; + let __r_arr: [G; OUT_479] = { let __args: [G; IN_479] = [__v_1, __v_4]; let __cu = unconstrained; if let Some(result) = record.function_queries[479].get_mut(&__args[..]) { if !__cu && *result.multiplicity == G::ZERO { aiur_fn_479(__args, record, io_buffer, false)? } else { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_479] = unsafe { *(result.output.as_ptr() as *const [G; OUT_479]) }; __ret } } else { aiur_fn_479(__args, record, io_buffer, __cu)? } }; let __v_5: G = __r_arr[0]; let __v_6: G = __r_arr[1]; match __v_5.as_canonical_u64() { 1u64 => { let __v_7: G = G::from_u64(1); let __v_8: G = (__v_3 - __v_7); - let __r_arr: [G; OUT_473] = { let __args: [G; IN_473] = [__v_6, __v_2, __v_8, __v_4]; let __cu = unconstrained; if let Some(result) = record.function_queries[473].get_mut(&__args[..]) { if !__cu && *result.multiplicity == G::ZERO { aiur_fn_473(__args, record, io_buffer, false)? } else { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_473] = unsafe { *(result.output.as_ptr() as *const [G; OUT_473]) }; __ret } } else { aiur_fn_473(__args, record, io_buffer, __cu)? } }; + let __r_arr: [G; OUT_469] = { let __args: [G; IN_469] = [__v_6, __v_2, __v_8, __v_4]; let __cu = unconstrained; if let Some(result) = record.function_queries[469].get_mut(&__args[..]) { if !__cu && *result.multiplicity == G::ZERO { aiur_fn_469(__args, record, io_buffer, false)? } else { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_469] = unsafe { *(result.output.as_ptr() as *const [G; OUT_469]) }; __ret } } else { aiur_fn_469(__args, record, io_buffer, __cu)? } }; let __v_9: G = __r_arr[0]; let __v_10: G = __r_arr[1]; let __v_11: G = __r_arr[2]; - let __ret: [G; OUT_480] = [__v_9, __v_10, __v_11]; - if let Some(result) = record.function_queries[480].get_mut(&inp[..]) { debug_assert_eq!(result.output, &__ret[..]); if !unconstrained { *result.multiplicity += G::ONE; } } else { record.function_queries[480].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained)); }; + let __ret: [G; OUT_476] = [__v_9, __v_10, __v_11]; + if let Some(result) = record.function_queries[476].get_mut(&inp[..]) { debug_assert_eq!(result.output, &__ret[..]); if !unconstrained { *result.multiplicity += G::ONE; } } else { record.function_queries[476].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained)); }; return Ok(__ret); }, _ => { - let __r_arr: [G; OUT_287] = { let __args: [G; IN_287] = [__v_0]; let __cu = unconstrained; if let Some(result) = record.function_queries[287].get_mut(&__args[..]) { if !__cu && *result.multiplicity == G::ZERO { aiur_fn_287(__args, record, io_buffer, false)? } else { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_287] = unsafe { *(result.output.as_ptr() as *const [G; OUT_287]) }; __ret } } else { aiur_fn_287(__args, record, io_buffer, __cu)? } }; + let __r_arr: [G; OUT_283] = { let __args: [G; IN_283] = [__v_0]; let __cu = unconstrained; if let Some(result) = record.function_queries[283].get_mut(&__args[..]) { if !__cu && *result.multiplicity == G::ZERO { aiur_fn_283(__args, record, io_buffer, false)? } else { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_283] = unsafe { *(result.output.as_ptr() as *const [G; OUT_283]) }; __ret } } else { aiur_fn_283(__args, record, io_buffer, __cu)? } }; let __v_7: G = __r_arr[0]; let __loaded: [G; 12] = { let __mq = record.memory_queries.get_mut(&12).ok_or(ExecError::InvalidMemorySize(12))?; let __ptr_u64 = __v_7.as_canonical_u64(); let __ptr_usize = usize::try_from(__ptr_u64).ok().ok_or(ExecError::PointerTooLarge(__ptr_u64))?; let (__args, __mult) = __mq.get_index_mut(__ptr_usize).ok_or(ExecError::UnboundPointer { ptr: __ptr_u64, size: 12 })?; if !unconstrained { *__mult += G::ONE; } let __arr: [G; 12] = __args[..12].try_into().unwrap(); __arr }; let __v_8: G = __loaded[0]; @@ -42837,35 +42553,35 @@ fn aiur_fn_480( let __v_17: G = __loaded[9]; let __v_18: G = __loaded[10]; let __v_19: G = __loaded[11]; - let __r_arr: [G; OUT_482] = { let __args: [G; IN_482] = [__v_8, __v_9, __v_10, __v_11, __v_12, __v_13, __v_14, __v_15, __v_16, __v_17, __v_18, __v_19]; let __cu = unconstrained; if let Some(result) = record.function_queries[482].get_mut(&__args[..]) { if !__cu && *result.multiplicity == G::ZERO { aiur_fn_482(__args, record, io_buffer, false)? } else { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_482] = unsafe { *(result.output.as_ptr() as *const [G; OUT_482]) }; __ret } } else { aiur_fn_482(__args, record, io_buffer, __cu)? } }; + let __r_arr: [G; OUT_478] = { let __args: [G; IN_478] = [__v_8, __v_9, __v_10, __v_11, __v_12, __v_13, __v_14, __v_15, __v_16, __v_17, __v_18, __v_19]; let __cu = unconstrained; if let Some(result) = record.function_queries[478].get_mut(&__args[..]) { if !__cu && *result.multiplicity == G::ZERO { aiur_fn_478(__args, record, io_buffer, false)? } else { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_478] = unsafe { *(result.output.as_ptr() as *const [G; OUT_478]) }; __ret } } else { aiur_fn_478(__args, record, io_buffer, __cu)? } }; let __v_20: G = __r_arr[0]; match __v_20.as_canonical_u64() { 0u64 => { let __v_21: G = G::from_u64(0); - let __ret: [G; OUT_480] = [__v_21, __v_1, __v_2]; - if let Some(result) = record.function_queries[480].get_mut(&inp[..]) { debug_assert_eq!(result.output, &__ret[..]); if !unconstrained { *result.multiplicity += G::ONE; } } else { record.function_queries[480].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained)); }; + let __ret: [G; OUT_476] = [__v_21, __v_1, __v_2]; + if let Some(result) = record.function_queries[476].get_mut(&inp[..]) { debug_assert_eq!(result.output, &__ret[..]); if !unconstrained { *result.multiplicity += G::ONE; } } else { record.function_queries[476].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained)); }; return Ok(__ret); }, _ => { - let __r_arr: [G; OUT_487] = { let __args: [G; IN_487] = [__v_2, __v_8, __v_9, __v_10, __v_11, __v_12, __v_13, __v_14, __v_15, __v_16, __v_17, __v_18, __v_19, __v_4]; let __cu = unconstrained; if let Some(result) = record.function_queries[487].get_mut(&__args[..]) { if !__cu && *result.multiplicity == G::ZERO { aiur_fn_487(__args, record, io_buffer, false)? } else { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_487] = unsafe { *(result.output.as_ptr() as *const [G; OUT_487]) }; __ret } } else { aiur_fn_487(__args, record, io_buffer, __cu)? } }; + let __r_arr: [G; OUT_483] = { let __args: [G; IN_483] = [__v_2, __v_8, __v_9, __v_10, __v_11, __v_12, __v_13, __v_14, __v_15, __v_16, __v_17, __v_18, __v_19, __v_4]; let __cu = unconstrained; if let Some(result) = record.function_queries[483].get_mut(&__args[..]) { if !__cu && *result.multiplicity == G::ZERO { aiur_fn_483(__args, record, io_buffer, false)? } else { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_483] = unsafe { *(result.output.as_ptr() as *const [G; OUT_483]) }; __ret } } else { aiur_fn_483(__args, record, io_buffer, __cu)? } }; let __v_21: G = __r_arr[0]; let __v_22: G = __r_arr[1]; match __v_21.as_canonical_u64() { 1u64 => { let __v_23: G = G::from_u64(1); let __v_24: G = (__v_3 - __v_23); - let __r_arr: [G; OUT_473] = { let __args: [G; IN_473] = [__v_1, __v_22, __v_24, __v_4]; let __cu = unconstrained; if let Some(result) = record.function_queries[473].get_mut(&__args[..]) { if !__cu && *result.multiplicity == G::ZERO { aiur_fn_473(__args, record, io_buffer, false)? } else { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_473] = unsafe { *(result.output.as_ptr() as *const [G; OUT_473]) }; __ret } } else { aiur_fn_473(__args, record, io_buffer, __cu)? } }; + let __r_arr: [G; OUT_469] = { let __args: [G; IN_469] = [__v_1, __v_22, __v_24, __v_4]; let __cu = unconstrained; if let Some(result) = record.function_queries[469].get_mut(&__args[..]) { if !__cu && *result.multiplicity == G::ZERO { aiur_fn_469(__args, record, io_buffer, false)? } else { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_469] = unsafe { *(result.output.as_ptr() as *const [G; OUT_469]) }; __ret } } else { aiur_fn_469(__args, record, io_buffer, __cu)? } }; let __v_25: G = __r_arr[0]; let __v_26: G = __r_arr[1]; let __v_27: G = __r_arr[2]; - let __ret: [G; OUT_480] = [__v_25, __v_26, __v_27]; - if let Some(result) = record.function_queries[480].get_mut(&inp[..]) { debug_assert_eq!(result.output, &__ret[..]); if !unconstrained { *result.multiplicity += G::ONE; } } else { record.function_queries[480].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained)); }; + let __ret: [G; OUT_476] = [__v_25, __v_26, __v_27]; + if let Some(result) = record.function_queries[476].get_mut(&inp[..]) { debug_assert_eq!(result.output, &__ret[..]); if !unconstrained { *result.multiplicity += G::ONE; } } else { record.function_queries[476].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained)); }; return Ok(__ret); }, _ => { let __v_23: G = G::from_u64(0); - let __ret: [G; OUT_480] = [__v_23, __v_1, __v_2]; - if let Some(result) = record.function_queries[480].get_mut(&inp[..]) { debug_assert_eq!(result.output, &__ret[..]); if !unconstrained { *result.multiplicity += G::ONE; } } else { record.function_queries[480].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained)); }; + let __ret: [G; OUT_476] = [__v_23, __v_1, __v_2]; + if let Some(result) = record.function_queries[476].get_mut(&inp[..]) { debug_assert_eq!(result.output, &__ret[..]); if !unconstrained { *result.multiplicity += G::ONE; } } else { record.function_queries[476].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained)); }; return Ok(__ret); }, } @@ -42876,24 +42592,24 @@ fn aiur_fn_480( }) } -const INPUT_SIZE_481: usize = 4; -const IN_481: usize = 4; -const OUT_481: usize = 3; -fn aiur_fn_481( - inp: [G; IN_481], +const INPUT_SIZE_477: usize = 4; +const IN_477: usize = 4; +const OUT_477: usize = 3; +fn aiur_fn_477( + inp: [G; IN_477], record: &mut QueryRecord, io_buffer: &mut IOBuffer, unconstrained: bool, -) -> Result<[G; OUT_481], ExecError> { +) -> Result<[G; OUT_477], ExecError> { stacker::maybe_grow(64 * 1024, 4 * 1024 * 1024, || { let __v_0: G = inp[0]; let __v_1: G = inp[1]; let __v_2: G = inp[2]; let __v_3: G = inp[3]; - let __r_arr: [G; OUT_483] = { let __args: [G; IN_483] = [__v_0, __v_3]; let __cu = unconstrained; if let Some(result) = record.function_queries[483].get_mut(&__args[..]) { if !__cu && *result.multiplicity == G::ZERO { aiur_fn_483(__args, record, io_buffer, false)? } else { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_483] = unsafe { *(result.output.as_ptr() as *const [G; OUT_483]) }; __ret } } else { aiur_fn_483(__args, record, io_buffer, __cu)? } }; + let __r_arr: [G; OUT_479] = { let __args: [G; IN_479] = [__v_0, __v_3]; let __cu = unconstrained; if let Some(result) = record.function_queries[479].get_mut(&__args[..]) { if !__cu && *result.multiplicity == G::ZERO { aiur_fn_479(__args, record, io_buffer, false)? } else { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_479] = unsafe { *(result.output.as_ptr() as *const [G; OUT_479]) }; __ret } } else { aiur_fn_479(__args, record, io_buffer, __cu)? } }; let __v_4: G = __r_arr[0]; let __v_5: G = __r_arr[1]; - let __r_arr: [G; OUT_483] = { let __args: [G; IN_483] = [__v_1, __v_3]; let __cu = unconstrained; if let Some(result) = record.function_queries[483].get_mut(&__args[..]) { if !__cu && *result.multiplicity == G::ZERO { aiur_fn_483(__args, record, io_buffer, false)? } else { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_483] = unsafe { *(result.output.as_ptr() as *const [G; OUT_483]) }; __ret } } else { aiur_fn_483(__args, record, io_buffer, __cu)? } }; + let __r_arr: [G; OUT_479] = { let __args: [G; IN_479] = [__v_1, __v_3]; let __cu = unconstrained; if let Some(result) = record.function_queries[479].get_mut(&__args[..]) { if !__cu && *result.multiplicity == G::ZERO { aiur_fn_479(__args, record, io_buffer, false)? } else { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_479] = unsafe { *(result.output.as_ptr() as *const [G; OUT_479]) }; __ret } } else { aiur_fn_479(__args, record, io_buffer, __cu)? } }; let __v_6: G = __r_arr[0]; let __v_7: G = __r_arr[1]; match __v_4.as_canonical_u64() { @@ -42902,23 +42618,23 @@ fn aiur_fn_481( 1u64 => { let __v_8: G = G::from_u64(1); let __v_9: G = (__v_2 - __v_8); - let __r_arr: [G; OUT_473] = { let __args: [G; IN_473] = [__v_5, __v_7, __v_9, __v_3]; let __cu = unconstrained; if let Some(result) = record.function_queries[473].get_mut(&__args[..]) { if !__cu && *result.multiplicity == G::ZERO { aiur_fn_473(__args, record, io_buffer, false)? } else { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_473] = unsafe { *(result.output.as_ptr() as *const [G; OUT_473]) }; __ret } } else { aiur_fn_473(__args, record, io_buffer, __cu)? } }; + let __r_arr: [G; OUT_469] = { let __args: [G; IN_469] = [__v_5, __v_7, __v_9, __v_3]; let __cu = unconstrained; if let Some(result) = record.function_queries[469].get_mut(&__args[..]) { if !__cu && *result.multiplicity == G::ZERO { aiur_fn_469(__args, record, io_buffer, false)? } else { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_469] = unsafe { *(result.output.as_ptr() as *const [G; OUT_469]) }; __ret } } else { aiur_fn_469(__args, record, io_buffer, __cu)? } }; let __v_10: G = __r_arr[0]; let __v_11: G = __r_arr[1]; let __v_12: G = __r_arr[2]; - let __ret: [G; OUT_481] = [__v_10, __v_11, __v_12]; - if let Some(result) = record.function_queries[481].get_mut(&inp[..]) { debug_assert_eq!(result.output, &__ret[..]); if !unconstrained { *result.multiplicity += G::ONE; } } else { record.function_queries[481].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained)); }; + let __ret: [G; OUT_477] = [__v_10, __v_11, __v_12]; + if let Some(result) = record.function_queries[477].get_mut(&inp[..]) { debug_assert_eq!(result.output, &__ret[..]); if !unconstrained { *result.multiplicity += G::ONE; } } else { record.function_queries[477].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained)); }; return Ok(__ret); }, _ => { let __v_8: G = G::from_u64(1); let __v_9: G = (__v_2 - __v_8); - let __r_arr: [G; OUT_473] = { let __args: [G; IN_473] = [__v_5, __v_1, __v_9, __v_3]; let __cu = unconstrained; if let Some(result) = record.function_queries[473].get_mut(&__args[..]) { if !__cu && *result.multiplicity == G::ZERO { aiur_fn_473(__args, record, io_buffer, false)? } else { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_473] = unsafe { *(result.output.as_ptr() as *const [G; OUT_473]) }; __ret } } else { aiur_fn_473(__args, record, io_buffer, __cu)? } }; + let __r_arr: [G; OUT_469] = { let __args: [G; IN_469] = [__v_5, __v_1, __v_9, __v_3]; let __cu = unconstrained; if let Some(result) = record.function_queries[469].get_mut(&__args[..]) { if !__cu && *result.multiplicity == G::ZERO { aiur_fn_469(__args, record, io_buffer, false)? } else { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_469] = unsafe { *(result.output.as_ptr() as *const [G; OUT_469]) }; __ret } } else { aiur_fn_469(__args, record, io_buffer, __cu)? } }; let __v_10: G = __r_arr[0]; let __v_11: G = __r_arr[1]; let __v_12: G = __r_arr[2]; - let __ret: [G; OUT_481] = [__v_10, __v_11, __v_12]; - if let Some(result) = record.function_queries[481].get_mut(&inp[..]) { debug_assert_eq!(result.output, &__ret[..]); if !unconstrained { *result.multiplicity += G::ONE; } } else { record.function_queries[481].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained)); }; + let __ret: [G; OUT_477] = [__v_10, __v_11, __v_12]; + if let Some(result) = record.function_queries[477].get_mut(&inp[..]) { debug_assert_eq!(result.output, &__ret[..]); if !unconstrained { *result.multiplicity += G::ONE; } } else { record.function_queries[477].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained)); }; return Ok(__ret); }, } @@ -42928,18 +42644,18 @@ fn aiur_fn_481( 1u64 => { let __v_8: G = G::from_u64(1); let __v_9: G = (__v_2 - __v_8); - let __r_arr: [G; OUT_473] = { let __args: [G; IN_473] = [__v_0, __v_7, __v_9, __v_3]; let __cu = unconstrained; if let Some(result) = record.function_queries[473].get_mut(&__args[..]) { if !__cu && *result.multiplicity == G::ZERO { aiur_fn_473(__args, record, io_buffer, false)? } else { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_473] = unsafe { *(result.output.as_ptr() as *const [G; OUT_473]) }; __ret } } else { aiur_fn_473(__args, record, io_buffer, __cu)? } }; + let __r_arr: [G; OUT_469] = { let __args: [G; IN_469] = [__v_0, __v_7, __v_9, __v_3]; let __cu = unconstrained; if let Some(result) = record.function_queries[469].get_mut(&__args[..]) { if !__cu && *result.multiplicity == G::ZERO { aiur_fn_469(__args, record, io_buffer, false)? } else { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_469] = unsafe { *(result.output.as_ptr() as *const [G; OUT_469]) }; __ret } } else { aiur_fn_469(__args, record, io_buffer, __cu)? } }; let __v_10: G = __r_arr[0]; let __v_11: G = __r_arr[1]; let __v_12: G = __r_arr[2]; - let __ret: [G; OUT_481] = [__v_10, __v_11, __v_12]; - if let Some(result) = record.function_queries[481].get_mut(&inp[..]) { debug_assert_eq!(result.output, &__ret[..]); if !unconstrained { *result.multiplicity += G::ONE; } } else { record.function_queries[481].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained)); }; + let __ret: [G; OUT_477] = [__v_10, __v_11, __v_12]; + if let Some(result) = record.function_queries[477].get_mut(&inp[..]) { debug_assert_eq!(result.output, &__ret[..]); if !unconstrained { *result.multiplicity += G::ONE; } } else { record.function_queries[477].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained)); }; return Ok(__ret); }, _ => { let __v_8: G = G::from_u64(0); - let __ret: [G; OUT_481] = [__v_8, __v_0, __v_1]; - if let Some(result) = record.function_queries[481].get_mut(&inp[..]) { debug_assert_eq!(result.output, &__ret[..]); if !unconstrained { *result.multiplicity += G::ONE; } } else { record.function_queries[481].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained)); }; + let __ret: [G; OUT_477] = [__v_8, __v_0, __v_1]; + if let Some(result) = record.function_queries[477].get_mut(&inp[..]) { debug_assert_eq!(result.output, &__ret[..]); if !unconstrained { *result.multiplicity += G::ONE; } } else { record.function_queries[477].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained)); }; return Ok(__ret); }, } @@ -42948,15 +42664,15 @@ fn aiur_fn_481( }) } -const INPUT_SIZE_482: usize = 12; -const IN_482: usize = 12; -const OUT_482: usize = 1; -fn aiur_fn_482( - inp: [G; IN_482], +const INPUT_SIZE_478: usize = 12; +const IN_478: usize = 12; +const OUT_478: usize = 1; +fn aiur_fn_478( + inp: [G; IN_478], record: &mut QueryRecord, io_buffer: &mut IOBuffer, unconstrained: bool, -) -> Result<[G; OUT_482], ExecError> { +) -> Result<[G; OUT_478], ExecError> { stacker::maybe_grow(64 * 1024, 4 * 1024 * 1024, || { let __v_0: G = inp[0]; let __v_1: G = inp[1]; @@ -42973,35 +42689,35 @@ fn aiur_fn_482( match __v_0.as_canonical_u64() { 1u64 => { let __v_12: G = G::from_u64(1); - let __ret: [G; OUT_482] = [__v_12]; - if let Some(result) = record.function_queries[482].get_mut(&inp[..]) { debug_assert_eq!(result.output, &__ret[..]); if !unconstrained { *result.multiplicity += G::ONE; } } else { record.function_queries[482].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained)); }; + let __ret: [G; OUT_478] = [__v_12]; + if let Some(result) = record.function_queries[478].get_mut(&inp[..]) { debug_assert_eq!(result.output, &__ret[..]); if !unconstrained { *result.multiplicity += G::ONE; } } else { record.function_queries[478].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained)); }; return Ok(__ret); }, 2u64 => { let __v_12: G = G::from_u64(1); - let __ret: [G; OUT_482] = [__v_12]; - if let Some(result) = record.function_queries[482].get_mut(&inp[..]) { debug_assert_eq!(result.output, &__ret[..]); if !unconstrained { *result.multiplicity += G::ONE; } } else { record.function_queries[482].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained)); }; + let __ret: [G; OUT_478] = [__v_12]; + if let Some(result) = record.function_queries[478].get_mut(&inp[..]) { debug_assert_eq!(result.output, &__ret[..]); if !unconstrained { *result.multiplicity += G::ONE; } } else { record.function_queries[478].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained)); }; return Ok(__ret); }, _ => { let __v_12: G = G::from_u64(0); - let __ret: [G; OUT_482] = [__v_12]; - if let Some(result) = record.function_queries[482].get_mut(&inp[..]) { debug_assert_eq!(result.output, &__ret[..]); if !unconstrained { *result.multiplicity += G::ONE; } } else { record.function_queries[482].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained)); }; + let __ret: [G; OUT_478] = [__v_12]; + if let Some(result) = record.function_queries[478].get_mut(&inp[..]) { debug_assert_eq!(result.output, &__ret[..]); if !unconstrained { *result.multiplicity += G::ONE; } } else { record.function_queries[478].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained)); }; return Ok(__ret); }, } }) } -const INPUT_SIZE_483: usize = 2; -const IN_483: usize = 2; -const OUT_483: usize = 2; -fn aiur_fn_483( - inp: [G; IN_483], +const INPUT_SIZE_479: usize = 2; +const IN_479: usize = 2; +const OUT_479: usize = 2; +fn aiur_fn_479( + inp: [G; IN_479], record: &mut QueryRecord, io_buffer: &mut IOBuffer, unconstrained: bool, -) -> Result<[G; OUT_483], ExecError> { +) -> Result<[G; OUT_479], ExecError> { stacker::maybe_grow(64 * 1024, 4 * 1024 * 1024, || { let __v_0: G = inp[0]; let __v_1: G = inp[1]; @@ -43015,7 +42731,7 @@ fn aiur_fn_483( let __v_7: G = __loaded[3]; match __v_4.as_canonical_u64() { 8u64 => { - let __r_arr: [G; OUT_424] = { let __args: [G; IN_424] = [__v_0, __v_1]; let __cu = unconstrained; if let Some(result) = record.function_queries[424].get_mut(&__args[..]) { if !__cu && *result.multiplicity == G::ZERO { aiur_fn_424(__args, record, io_buffer, false)? } else { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_424] = unsafe { *(result.output.as_ptr() as *const [G; OUT_424]) }; __ret } } else { aiur_fn_424(__args, record, io_buffer, __cu)? } }; + let __r_arr: [G; OUT_420] = { let __args: [G; IN_420] = [__v_0, __v_1]; let __cu = unconstrained; if let Some(result) = record.function_queries[420].get_mut(&__args[..]) { if !__cu && *result.multiplicity == G::ZERO { aiur_fn_420(__args, record, io_buffer, false)? } else { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_420] = unsafe { *(result.output.as_ptr() as *const [G; OUT_420]) }; __ret } } else { aiur_fn_420(__args, record, io_buffer, __cu)? } }; let __v_8: G = __r_arr[0]; let __r_arr: [G; OUT_111] = { let __args: [G; IN_111] = [__v_8]; let __cu = unconstrained; if let Some(result) = record.function_queries[111].get_mut(&__args[..]) { if !__cu && *result.multiplicity == G::ZERO { aiur_fn_111(__args, record, io_buffer, false)? } else { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_111] = unsafe { *(result.output.as_ptr() as *const [G; OUT_111]) }; __ret } } else { aiur_fn_111(__args, record, io_buffer, __cu)? } }; let __v_9: G = __r_arr[0]; @@ -43027,7 +42743,7 @@ fn aiur_fn_483( let __v_14: G = __loaded[3]; match __v_11.as_canonical_u64() { 8u64 => { - let __r_arr: [G; OUT_484] = { let __args: [G; IN_484] = [__v_7]; let __cu = unconstrained; if let Some(result) = record.function_queries[484].get_mut(&__args[..]) { if !__cu && *result.multiplicity == G::ZERO { aiur_fn_484(__args, record, io_buffer, false)? } else { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_484] = unsafe { *(result.output.as_ptr() as *const [G; OUT_484]) }; __ret } } else { aiur_fn_484(__args, record, io_buffer, __cu)? } }; + let __r_arr: [G; OUT_480] = { let __args: [G; IN_480] = [__v_7]; let __cu = unconstrained; if let Some(result) = record.function_queries[480].get_mut(&__args[..]) { if !__cu && *result.multiplicity == G::ZERO { aiur_fn_480(__args, record, io_buffer, false)? } else { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_480] = unsafe { *(result.output.as_ptr() as *const [G; OUT_480]) }; __ret } } else { aiur_fn_480(__args, record, io_buffer, __cu)? } }; let __v_15: G = __r_arr[0]; let __v_16: G = __r_arr[1]; match __v_15.as_canonical_u64() { @@ -43035,47 +42751,47 @@ fn aiur_fn_483( let __v_17: G = G::from_u64(8); let __v_18: G = { let __values: [G; 4] = [__v_17, __v_5, __v_6, __v_16]; let __mq = record.memory_queries.get_mut(&4).ok_or(ExecError::InvalidMemorySize(4))?; if let Some(result) = __mq.get_mut(&__values[..]) { if !unconstrained { *result.multiplicity += G::ONE; } result.output[0] } else { let __ptr = G::from_usize(__mq.len()); __mq.insert(&__values[..], &[__ptr], G::from_bool(!unconstrained)); __ptr } }; let __v_19: G = G::from_u64(1); - let __r_arr: [G; OUT_255] = { let __args: [G; IN_255] = [__v_18, __v_3]; let __cu = unconstrained; if let Some(result) = record.function_queries[255].get_mut(&__args[..]) { if !__cu && *result.multiplicity == G::ZERO { aiur_fn_255(__args, record, io_buffer, false)? } else { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_255] = unsafe { *(result.output.as_ptr() as *const [G; OUT_255]) }; __ret } } else { aiur_fn_255(__args, record, io_buffer, __cu)? } }; + let __r_arr: [G; OUT_251] = { let __args: [G; IN_251] = [__v_18, __v_3]; let __cu = unconstrained; if let Some(result) = record.function_queries[251].get_mut(&__args[..]) { if !__cu && *result.multiplicity == G::ZERO { aiur_fn_251(__args, record, io_buffer, false)? } else { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_251] = unsafe { *(result.output.as_ptr() as *const [G; OUT_251]) }; __ret } } else { aiur_fn_251(__args, record, io_buffer, __cu)? } }; let __v_20: G = __r_arr[0]; - let __ret: [G; OUT_483] = [__v_19, __v_20]; - if let Some(result) = record.function_queries[483].get_mut(&inp[..]) { debug_assert_eq!(result.output, &__ret[..]); if !unconstrained { *result.multiplicity += G::ONE; } } else { record.function_queries[483].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained)); }; + let __ret: [G; OUT_479] = [__v_19, __v_20]; + if let Some(result) = record.function_queries[479].get_mut(&inp[..]) { debug_assert_eq!(result.output, &__ret[..]); if !unconstrained { *result.multiplicity += G::ONE; } } else { record.function_queries[479].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained)); }; return Ok(__ret); }, _ => { let __v_17: G = G::from_u64(0); - let __ret: [G; OUT_483] = [__v_17, __v_0]; - if let Some(result) = record.function_queries[483].get_mut(&inp[..]) { debug_assert_eq!(result.output, &__ret[..]); if !unconstrained { *result.multiplicity += G::ONE; } } else { record.function_queries[483].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained)); }; + let __ret: [G; OUT_479] = [__v_17, __v_0]; + if let Some(result) = record.function_queries[479].get_mut(&inp[..]) { debug_assert_eq!(result.output, &__ret[..]); if !unconstrained { *result.multiplicity += G::ONE; } } else { record.function_queries[479].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained)); }; return Ok(__ret); }, } }, _ => { let __v_15: G = G::from_u64(1); - let __ret: [G; OUT_483] = [__v_15, __v_8]; - if let Some(result) = record.function_queries[483].get_mut(&inp[..]) { debug_assert_eq!(result.output, &__ret[..]); if !unconstrained { *result.multiplicity += G::ONE; } } else { record.function_queries[483].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained)); }; + let __ret: [G; OUT_479] = [__v_15, __v_8]; + if let Some(result) = record.function_queries[479].get_mut(&inp[..]) { debug_assert_eq!(result.output, &__ret[..]); if !unconstrained { *result.multiplicity += G::ONE; } } else { record.function_queries[479].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained)); }; return Ok(__ret); }, } }, _ => { let __v_8: G = G::from_u64(0); - let __ret: [G; OUT_483] = [__v_8, __v_0]; - if let Some(result) = record.function_queries[483].get_mut(&inp[..]) { debug_assert_eq!(result.output, &__ret[..]); if !unconstrained { *result.multiplicity += G::ONE; } } else { record.function_queries[483].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained)); }; + let __ret: [G; OUT_479] = [__v_8, __v_0]; + if let Some(result) = record.function_queries[479].get_mut(&inp[..]) { debug_assert_eq!(result.output, &__ret[..]); if !unconstrained { *result.multiplicity += G::ONE; } } else { record.function_queries[479].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained)); }; return Ok(__ret); }, } }) } -const INPUT_SIZE_484: usize = 1; -const IN_484: usize = 1; -const OUT_484: usize = 2; -fn aiur_fn_484( - inp: [G; IN_484], +const INPUT_SIZE_480: usize = 1; +const IN_480: usize = 1; +const OUT_480: usize = 2; +fn aiur_fn_480( + inp: [G; IN_480], record: &mut QueryRecord, io_buffer: &mut IOBuffer, unconstrained: bool, -) -> Result<[G; OUT_484], ExecError> { +) -> Result<[G; OUT_480], ExecError> { stacker::maybe_grow(64 * 1024, 4 * 1024 * 1024, || { let __v_0: G = inp[0]; let __r_arr: [G; OUT_111] = { let __args: [G; IN_111] = [__v_0]; let __cu = unconstrained; if let Some(result) = record.function_queries[111].get_mut(&__args[..]) { if !__cu && *result.multiplicity == G::ZERO { aiur_fn_111(__args, record, io_buffer, false)? } else { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_111] = unsafe { *(result.output.as_ptr() as *const [G; OUT_111]) }; __ret } } else { aiur_fn_111(__args, record, io_buffer, __cu)? } }; @@ -43088,7 +42804,7 @@ fn aiur_fn_484( let __v_6: G = __loaded[3]; match __v_3.as_canonical_u64() { 2u64 => { - let __r_arr: [G; OUT_287] = { let __args: [G; IN_287] = [__v_4]; let __cu = unconstrained; if let Some(result) = record.function_queries[287].get_mut(&__args[..]) { if !__cu && *result.multiplicity == G::ZERO { aiur_fn_287(__args, record, io_buffer, false)? } else { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_287] = unsafe { *(result.output.as_ptr() as *const [G; OUT_287]) }; __ret } } else { aiur_fn_287(__args, record, io_buffer, __cu)? } }; + let __r_arr: [G; OUT_283] = { let __args: [G; IN_283] = [__v_4]; let __cu = unconstrained; if let Some(result) = record.function_queries[283].get_mut(&__args[..]) { if !__cu && *result.multiplicity == G::ZERO { aiur_fn_283(__args, record, io_buffer, false)? } else { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_283] = unsafe { *(result.output.as_ptr() as *const [G; OUT_283]) }; __ret } } else { aiur_fn_283(__args, record, io_buffer, __cu)? } }; let __v_7: G = __r_arr[0]; let __loaded: [G; 12] = { let __mq = record.memory_queries.get_mut(&12).ok_or(ExecError::InvalidMemorySize(12))?; let __ptr_u64 = __v_7.as_canonical_u64(); let __ptr_usize = usize::try_from(__ptr_u64).ok().ok_or(ExecError::PointerTooLarge(__ptr_u64))?; let (__args, __mult) = __mq.get_index_mut(__ptr_usize).ok_or(ExecError::UnboundPointer { ptr: __ptr_u64, size: 12 })?; if !unconstrained { *__mult += G::ONE; } let __arr: [G; 12] = __args[..12].try_into().unwrap(); __arr }; let __v_8: G = __loaded[0]; @@ -43105,79 +42821,79 @@ fn aiur_fn_484( let __v_19: G = __loaded[11]; match __v_8.as_canonical_u64() { 1u64 => { - let __r_arr: [G; OUT_336] = { let __args: [G; IN_336] = [__v_11, __v_5]; let __cu = unconstrained; if let Some(result) = record.function_queries[336].get_mut(&__args[..]) { if !__cu && *result.multiplicity == G::ZERO { aiur_fn_336(__args, record, io_buffer, false)? } else { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_336] = unsafe { *(result.output.as_ptr() as *const [G; OUT_336]) }; __ret } } else { aiur_fn_336(__args, record, io_buffer, __cu)? } }; + let __r_arr: [G; OUT_332] = { let __args: [G; IN_332] = [__v_11, __v_5]; let __cu = unconstrained; if let Some(result) = record.function_queries[332].get_mut(&__args[..]) { if !__cu && *result.multiplicity == G::ZERO { aiur_fn_332(__args, record, io_buffer, false)? } else { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_332] = unsafe { *(result.output.as_ptr() as *const [G; OUT_332]) }; __ret } } else { aiur_fn_332(__args, record, io_buffer, __cu)? } }; let __v_20: G = __r_arr[0]; let __v_21: G = G::from_u64(1); - let __r_arr: [G; OUT_255] = { let __args: [G; IN_255] = [__v_20, __v_2]; let __cu = unconstrained; if let Some(result) = record.function_queries[255].get_mut(&__args[..]) { if !__cu && *result.multiplicity == G::ZERO { aiur_fn_255(__args, record, io_buffer, false)? } else { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_255] = unsafe { *(result.output.as_ptr() as *const [G; OUT_255]) }; __ret } } else { aiur_fn_255(__args, record, io_buffer, __cu)? } }; + let __r_arr: [G; OUT_251] = { let __args: [G; IN_251] = [__v_20, __v_2]; let __cu = unconstrained; if let Some(result) = record.function_queries[251].get_mut(&__args[..]) { if !__cu && *result.multiplicity == G::ZERO { aiur_fn_251(__args, record, io_buffer, false)? } else { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_251] = unsafe { *(result.output.as_ptr() as *const [G; OUT_251]) }; __ret } } else { aiur_fn_251(__args, record, io_buffer, __cu)? } }; let __v_22: G = __r_arr[0]; - let __ret: [G; OUT_484] = [__v_21, __v_22]; - if let Some(result) = record.function_queries[484].get_mut(&inp[..]) { debug_assert_eq!(result.output, &__ret[..]); if !unconstrained { *result.multiplicity += G::ONE; } } else { record.function_queries[484].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained)); }; + let __ret: [G; OUT_480] = [__v_21, __v_22]; + if let Some(result) = record.function_queries[480].get_mut(&inp[..]) { debug_assert_eq!(result.output, &__ret[..]); if !unconstrained { *result.multiplicity += G::ONE; } } else { record.function_queries[480].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained)); }; return Ok(__ret); }, 2u64 => { - let __r_arr: [G; OUT_336] = { let __args: [G; IN_336] = [__v_11, __v_5]; let __cu = unconstrained; if let Some(result) = record.function_queries[336].get_mut(&__args[..]) { if !__cu && *result.multiplicity == G::ZERO { aiur_fn_336(__args, record, io_buffer, false)? } else { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_336] = unsafe { *(result.output.as_ptr() as *const [G; OUT_336]) }; __ret } } else { aiur_fn_336(__args, record, io_buffer, __cu)? } }; + let __r_arr: [G; OUT_332] = { let __args: [G; IN_332] = [__v_11, __v_5]; let __cu = unconstrained; if let Some(result) = record.function_queries[332].get_mut(&__args[..]) { if !__cu && *result.multiplicity == G::ZERO { aiur_fn_332(__args, record, io_buffer, false)? } else { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_332] = unsafe { *(result.output.as_ptr() as *const [G; OUT_332]) }; __ret } } else { aiur_fn_332(__args, record, io_buffer, __cu)? } }; let __v_20: G = __r_arr[0]; let __v_21: G = G::from_u64(1); - let __r_arr: [G; OUT_255] = { let __args: [G; IN_255] = [__v_20, __v_2]; let __cu = unconstrained; if let Some(result) = record.function_queries[255].get_mut(&__args[..]) { if !__cu && *result.multiplicity == G::ZERO { aiur_fn_255(__args, record, io_buffer, false)? } else { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_255] = unsafe { *(result.output.as_ptr() as *const [G; OUT_255]) }; __ret } } else { aiur_fn_255(__args, record, io_buffer, __cu)? } }; + let __r_arr: [G; OUT_251] = { let __args: [G; IN_251] = [__v_20, __v_2]; let __cu = unconstrained; if let Some(result) = record.function_queries[251].get_mut(&__args[..]) { if !__cu && *result.multiplicity == G::ZERO { aiur_fn_251(__args, record, io_buffer, false)? } else { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_251] = unsafe { *(result.output.as_ptr() as *const [G; OUT_251]) }; __ret } } else { aiur_fn_251(__args, record, io_buffer, __cu)? } }; let __v_22: G = __r_arr[0]; - let __ret: [G; OUT_484] = [__v_21, __v_22]; - if let Some(result) = record.function_queries[484].get_mut(&inp[..]) { debug_assert_eq!(result.output, &__ret[..]); if !unconstrained { *result.multiplicity += G::ONE; } } else { record.function_queries[484].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained)); }; + let __ret: [G; OUT_480] = [__v_21, __v_22]; + if let Some(result) = record.function_queries[480].get_mut(&inp[..]) { debug_assert_eq!(result.output, &__ret[..]); if !unconstrained { *result.multiplicity += G::ONE; } } else { record.function_queries[480].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained)); }; return Ok(__ret); }, _ => { let __v_20: G = G::from_u64(0); - let __ret: [G; OUT_484] = [__v_20, __v_0]; - if let Some(result) = record.function_queries[484].get_mut(&inp[..]) { debug_assert_eq!(result.output, &__ret[..]); if !unconstrained { *result.multiplicity += G::ONE; } } else { record.function_queries[484].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained)); }; + let __ret: [G; OUT_480] = [__v_20, __v_0]; + if let Some(result) = record.function_queries[480].get_mut(&inp[..]) { debug_assert_eq!(result.output, &__ret[..]); if !unconstrained { *result.multiplicity += G::ONE; } } else { record.function_queries[480].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained)); }; return Ok(__ret); }, } }, _ => { let __v_7: G = G::from_u64(0); - let __ret: [G; OUT_484] = [__v_7, __v_0]; - if let Some(result) = record.function_queries[484].get_mut(&inp[..]) { debug_assert_eq!(result.output, &__ret[..]); if !unconstrained { *result.multiplicity += G::ONE; } } else { record.function_queries[484].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained)); }; + let __ret: [G; OUT_480] = [__v_7, __v_0]; + if let Some(result) = record.function_queries[480].get_mut(&inp[..]) { debug_assert_eq!(result.output, &__ret[..]); if !unconstrained { *result.multiplicity += G::ONE; } } else { record.function_queries[480].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained)); }; return Ok(__ret); }, } }) } -const INPUT_SIZE_485: usize = 3; -const IN_485: usize = 3; -const OUT_485: usize = 1; -fn aiur_fn_485( - inp: [G; IN_485], +const INPUT_SIZE_481: usize = 3; +const IN_481: usize = 3; +const OUT_481: usize = 1; +fn aiur_fn_481( + inp: [G; IN_481], record: &mut QueryRecord, io_buffer: &mut IOBuffer, unconstrained: bool, -) -> Result<[G; OUT_485], ExecError> { +) -> Result<[G; OUT_481], ExecError> { stacker::maybe_grow(64 * 1024, 4 * 1024 * 1024, || { let __v_0: G = inp[0]; let __v_1: G = inp[1]; let __v_2: G = inp[2]; - let __r_arr: [G; OUT_486] = { let __args: [G; IN_486] = [__v_0]; let __cu = unconstrained; if let Some(result) = record.function_queries[486].get_mut(&__args[..]) { if !__cu && *result.multiplicity == G::ZERO { aiur_fn_486(__args, record, io_buffer, false)? } else { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_486] = unsafe { *(result.output.as_ptr() as *const [G; OUT_486]) }; __ret } } else { aiur_fn_486(__args, record, io_buffer, __cu)? } }; + let __r_arr: [G; OUT_482] = { let __args: [G; IN_482] = [__v_0]; let __cu = unconstrained; if let Some(result) = record.function_queries[482].get_mut(&__args[..]) { if !__cu && *result.multiplicity == G::ZERO { aiur_fn_482(__args, record, io_buffer, false)? } else { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_482] = unsafe { *(result.output.as_ptr() as *const [G; OUT_482]) }; __ret } } else { aiur_fn_482(__args, record, io_buffer, __cu)? } }; let __v_3: G = __r_arr[0]; let __v_4: G = __r_arr[1]; - let __r_arr: [G; OUT_486] = { let __args: [G; IN_486] = [__v_1]; let __cu = unconstrained; if let Some(result) = record.function_queries[486].get_mut(&__args[..]) { if !__cu && *result.multiplicity == G::ZERO { aiur_fn_486(__args, record, io_buffer, false)? } else { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_486] = unsafe { *(result.output.as_ptr() as *const [G; OUT_486]) }; __ret } } else { aiur_fn_486(__args, record, io_buffer, __cu)? } }; + let __r_arr: [G; OUT_482] = { let __args: [G; IN_482] = [__v_1]; let __cu = unconstrained; if let Some(result) = record.function_queries[482].get_mut(&__args[..]) { if !__cu && *result.multiplicity == G::ZERO { aiur_fn_482(__args, record, io_buffer, false)? } else { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_482] = unsafe { *(result.output.as_ptr() as *const [G; OUT_482]) }; __ret } } else { aiur_fn_482(__args, record, io_buffer, __cu)? } }; let __v_5: G = __r_arr[0]; let __v_6: G = __r_arr[1]; match __v_4.as_canonical_u64() { 0u64 => { let __v_7: G = G::from_u64(0); - let __ret: [G; OUT_485] = [__v_7]; - if let Some(result) = record.function_queries[485].get_mut(&inp[..]) { debug_assert_eq!(result.output, &__ret[..]); if !unconstrained { *result.multiplicity += G::ONE; } } else { record.function_queries[485].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained)); }; + let __ret: [G; OUT_481] = [__v_7]; + if let Some(result) = record.function_queries[481].get_mut(&inp[..]) { debug_assert_eq!(result.output, &__ret[..]); if !unconstrained { *result.multiplicity += G::ONE; } } else { record.function_queries[481].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained)); }; return Ok(__ret); }, _ => { match __v_6.as_canonical_u64() { 0u64 => { let __v_7: G = G::from_u64(0); - let __ret: [G; OUT_485] = [__v_7]; - if let Some(result) = record.function_queries[485].get_mut(&inp[..]) { debug_assert_eq!(result.output, &__ret[..]); if !unconstrained { *result.multiplicity += G::ONE; } } else { record.function_queries[485].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained)); }; + let __ret: [G; OUT_481] = [__v_7]; + if let Some(result) = record.function_queries[481].get_mut(&inp[..]) { debug_assert_eq!(result.output, &__ret[..]); if !unconstrained { *result.multiplicity += G::ONE; } } else { record.function_queries[481].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained)); }; return Ok(__ret); }, _ => { - let __r_arr: [G; OUT_287] = { let __args: [G; IN_287] = [__v_3]; let __cu = unconstrained; if let Some(result) = record.function_queries[287].get_mut(&__args[..]) { if !__cu && *result.multiplicity == G::ZERO { aiur_fn_287(__args, record, io_buffer, false)? } else { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_287] = unsafe { *(result.output.as_ptr() as *const [G; OUT_287]) }; __ret } } else { aiur_fn_287(__args, record, io_buffer, __cu)? } }; + let __r_arr: [G; OUT_283] = { let __args: [G; IN_283] = [__v_3]; let __cu = unconstrained; if let Some(result) = record.function_queries[283].get_mut(&__args[..]) { if !__cu && *result.multiplicity == G::ZERO { aiur_fn_283(__args, record, io_buffer, false)? } else { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_283] = unsafe { *(result.output.as_ptr() as *const [G; OUT_283]) }; __ret } } else { aiur_fn_283(__args, record, io_buffer, __cu)? } }; let __v_7: G = __r_arr[0]; let __loaded: [G; 12] = { let __mq = record.memory_queries.get_mut(&12).ok_or(ExecError::InvalidMemorySize(12))?; let __ptr_u64 = __v_7.as_canonical_u64(); let __ptr_usize = usize::try_from(__ptr_u64).ok().ok_or(ExecError::PointerTooLarge(__ptr_u64))?; let (__args, __mult) = __mq.get_index_mut(__ptr_usize).ok_or(ExecError::UnboundPointer { ptr: __ptr_u64, size: 12 })?; if !unconstrained { *__mult += G::ONE; } let __arr: [G; 12] = __args[..12].try_into().unwrap(); __arr }; let __v_8: G = __loaded[0]; @@ -43192,7 +42908,7 @@ fn aiur_fn_485( let __v_17: G = __loaded[9]; let __v_18: G = __loaded[10]; let __v_19: G = __loaded[11]; - let __r_arr: [G; OUT_287] = { let __args: [G; IN_287] = [__v_5]; let __cu = unconstrained; if let Some(result) = record.function_queries[287].get_mut(&__args[..]) { if !__cu && *result.multiplicity == G::ZERO { aiur_fn_287(__args, record, io_buffer, false)? } else { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_287] = unsafe { *(result.output.as_ptr() as *const [G; OUT_287]) }; __ret } } else { aiur_fn_287(__args, record, io_buffer, __cu)? } }; + let __r_arr: [G; OUT_283] = { let __args: [G; IN_283] = [__v_5]; let __cu = unconstrained; if let Some(result) = record.function_queries[283].get_mut(&__args[..]) { if !__cu && *result.multiplicity == G::ZERO { aiur_fn_283(__args, record, io_buffer, false)? } else { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_283] = unsafe { *(result.output.as_ptr() as *const [G; OUT_283]) }; __ret } } else { aiur_fn_283(__args, record, io_buffer, __cu)? } }; let __v_20: G = __r_arr[0]; let __loaded: [G; 12] = { let __mq = record.memory_queries.get_mut(&12).ok_or(ExecError::InvalidMemorySize(12))?; let __ptr_u64 = __v_20.as_canonical_u64(); let __ptr_usize = usize::try_from(__ptr_u64).ok().ok_or(ExecError::PointerTooLarge(__ptr_u64))?; let (__args, __mult) = __mq.get_index_mut(__ptr_usize).ok_or(ExecError::UnboundPointer { ptr: __ptr_u64, size: 12 })?; if !unconstrained { *__mult += G::ONE; } let __arr: [G; 12] = __args[..12].try_into().unwrap(); __arr }; let __v_21: G = __loaded[0]; @@ -43207,27 +42923,27 @@ fn aiur_fn_485( let __v_30: G = __loaded[9]; let __v_31: G = __loaded[10]; let __v_32: G = __loaded[11]; - let __r_arr: [G; OUT_487] = { let __args: [G; IN_487] = [__v_0, __v_8, __v_9, __v_10, __v_11, __v_12, __v_13, __v_14, __v_15, __v_16, __v_17, __v_18, __v_19, __v_2]; let __cu = unconstrained; if let Some(result) = record.function_queries[487].get_mut(&__args[..]) { if !__cu && *result.multiplicity == G::ZERO { aiur_fn_487(__args, record, io_buffer, false)? } else { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_487] = unsafe { *(result.output.as_ptr() as *const [G; OUT_487]) }; __ret } } else { aiur_fn_487(__args, record, io_buffer, __cu)? } }; + let __r_arr: [G; OUT_483] = { let __args: [G; IN_483] = [__v_0, __v_8, __v_9, __v_10, __v_11, __v_12, __v_13, __v_14, __v_15, __v_16, __v_17, __v_18, __v_19, __v_2]; let __cu = unconstrained; if let Some(result) = record.function_queries[483].get_mut(&__args[..]) { if !__cu && *result.multiplicity == G::ZERO { aiur_fn_483(__args, record, io_buffer, false)? } else { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_483] = unsafe { *(result.output.as_ptr() as *const [G; OUT_483]) }; __ret } } else { aiur_fn_483(__args, record, io_buffer, __cu)? } }; let __v_33: G = __r_arr[0]; let __v_34: G = __r_arr[1]; - let __r_arr: [G; OUT_487] = { let __args: [G; IN_487] = [__v_1, __v_21, __v_22, __v_23, __v_24, __v_25, __v_26, __v_27, __v_28, __v_29, __v_30, __v_31, __v_32, __v_2]; let __cu = unconstrained; if let Some(result) = record.function_queries[487].get_mut(&__args[..]) { if !__cu && *result.multiplicity == G::ZERO { aiur_fn_487(__args, record, io_buffer, false)? } else { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_487] = unsafe { *(result.output.as_ptr() as *const [G; OUT_487]) }; __ret } } else { aiur_fn_487(__args, record, io_buffer, __cu)? } }; + let __r_arr: [G; OUT_483] = { let __args: [G; IN_483] = [__v_1, __v_21, __v_22, __v_23, __v_24, __v_25, __v_26, __v_27, __v_28, __v_29, __v_30, __v_31, __v_32, __v_2]; let __cu = unconstrained; if let Some(result) = record.function_queries[483].get_mut(&__args[..]) { if !__cu && *result.multiplicity == G::ZERO { aiur_fn_483(__args, record, io_buffer, false)? } else { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_483] = unsafe { *(result.output.as_ptr() as *const [G; OUT_483]) }; __ret } } else { aiur_fn_483(__args, record, io_buffer, __cu)? } }; let __v_35: G = __r_arr[0]; let __v_36: G = __r_arr[1]; match __v_33.as_canonical_u64() { 1u64 => { match __v_35.as_canonical_u64() { 1u64 => { - let __r_arr: [G; OUT_439] = { let __args: [G; IN_439] = [__v_34, __v_36, __v_2]; let __cu = unconstrained; if let Some(result) = record.function_queries[439].get_mut(&__args[..]) { if !__cu && *result.multiplicity == G::ZERO { aiur_fn_439(__args, record, io_buffer, false)? } else { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_439] = unsafe { *(result.output.as_ptr() as *const [G; OUT_439]) }; __ret } } else { aiur_fn_439(__args, record, io_buffer, __cu)? } }; + let __r_arr: [G; OUT_435] = { let __args: [G; IN_435] = [__v_34, __v_36, __v_2]; let __cu = unconstrained; if let Some(result) = record.function_queries[435].get_mut(&__args[..]) { if !__cu && *result.multiplicity == G::ZERO { aiur_fn_435(__args, record, io_buffer, false)? } else { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_435] = unsafe { *(result.output.as_ptr() as *const [G; OUT_435]) }; __ret } } else { aiur_fn_435(__args, record, io_buffer, __cu)? } }; let __v_37: G = __r_arr[0]; - let __ret: [G; OUT_485] = [__v_37]; - if let Some(result) = record.function_queries[485].get_mut(&inp[..]) { debug_assert_eq!(result.output, &__ret[..]); if !unconstrained { *result.multiplicity += G::ONE; } } else { record.function_queries[485].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained)); }; + let __ret: [G; OUT_481] = [__v_37]; + if let Some(result) = record.function_queries[481].get_mut(&inp[..]) { debug_assert_eq!(result.output, &__ret[..]); if !unconstrained { *result.multiplicity += G::ONE; } } else { record.function_queries[481].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained)); }; return Ok(__ret); }, _ => { - let __r_arr: [G; OUT_439] = { let __args: [G; IN_439] = [__v_34, __v_1, __v_2]; let __cu = unconstrained; if let Some(result) = record.function_queries[439].get_mut(&__args[..]) { if !__cu && *result.multiplicity == G::ZERO { aiur_fn_439(__args, record, io_buffer, false)? } else { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_439] = unsafe { *(result.output.as_ptr() as *const [G; OUT_439]) }; __ret } } else { aiur_fn_439(__args, record, io_buffer, __cu)? } }; + let __r_arr: [G; OUT_435] = { let __args: [G; IN_435] = [__v_34, __v_1, __v_2]; let __cu = unconstrained; if let Some(result) = record.function_queries[435].get_mut(&__args[..]) { if !__cu && *result.multiplicity == G::ZERO { aiur_fn_435(__args, record, io_buffer, false)? } else { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_435] = unsafe { *(result.output.as_ptr() as *const [G; OUT_435]) }; __ret } } else { aiur_fn_435(__args, record, io_buffer, __cu)? } }; let __v_37: G = __r_arr[0]; - let __ret: [G; OUT_485] = [__v_37]; - if let Some(result) = record.function_queries[485].get_mut(&inp[..]) { debug_assert_eq!(result.output, &__ret[..]); if !unconstrained { *result.multiplicity += G::ONE; } } else { record.function_queries[485].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained)); }; + let __ret: [G; OUT_481] = [__v_37]; + if let Some(result) = record.function_queries[481].get_mut(&inp[..]) { debug_assert_eq!(result.output, &__ret[..]); if !unconstrained { *result.multiplicity += G::ONE; } } else { record.function_queries[481].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained)); }; return Ok(__ret); }, } @@ -43235,16 +42951,16 @@ fn aiur_fn_485( 0u64 => { match __v_35.as_canonical_u64() { 1u64 => { - let __r_arr: [G; OUT_439] = { let __args: [G; IN_439] = [__v_0, __v_36, __v_2]; let __cu = unconstrained; if let Some(result) = record.function_queries[439].get_mut(&__args[..]) { if !__cu && *result.multiplicity == G::ZERO { aiur_fn_439(__args, record, io_buffer, false)? } else { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_439] = unsafe { *(result.output.as_ptr() as *const [G; OUT_439]) }; __ret } } else { aiur_fn_439(__args, record, io_buffer, __cu)? } }; + let __r_arr: [G; OUT_435] = { let __args: [G; IN_435] = [__v_0, __v_36, __v_2]; let __cu = unconstrained; if let Some(result) = record.function_queries[435].get_mut(&__args[..]) { if !__cu && *result.multiplicity == G::ZERO { aiur_fn_435(__args, record, io_buffer, false)? } else { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_435] = unsafe { *(result.output.as_ptr() as *const [G; OUT_435]) }; __ret } } else { aiur_fn_435(__args, record, io_buffer, __cu)? } }; let __v_37: G = __r_arr[0]; - let __ret: [G; OUT_485] = [__v_37]; - if let Some(result) = record.function_queries[485].get_mut(&inp[..]) { debug_assert_eq!(result.output, &__ret[..]); if !unconstrained { *result.multiplicity += G::ONE; } } else { record.function_queries[485].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained)); }; + let __ret: [G; OUT_481] = [__v_37]; + if let Some(result) = record.function_queries[481].get_mut(&inp[..]) { debug_assert_eq!(result.output, &__ret[..]); if !unconstrained { *result.multiplicity += G::ONE; } } else { record.function_queries[481].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained)); }; return Ok(__ret); }, _ => { let __v_37: G = G::from_u64(0); - let __ret: [G; OUT_485] = [__v_37]; - if let Some(result) = record.function_queries[485].get_mut(&inp[..]) { debug_assert_eq!(result.output, &__ret[..]); if !unconstrained { *result.multiplicity += G::ONE; } } else { record.function_queries[485].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained)); }; + let __ret: [G; OUT_481] = [__v_37]; + if let Some(result) = record.function_queries[481].get_mut(&inp[..]) { debug_assert_eq!(result.output, &__ret[..]); if !unconstrained { *result.multiplicity += G::ONE; } } else { record.function_queries[481].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained)); }; return Ok(__ret); }, } @@ -43260,15 +42976,15 @@ fn aiur_fn_485( }) } -const INPUT_SIZE_486: usize = 1; -const IN_486: usize = 1; -const OUT_486: usize = 2; -fn aiur_fn_486( - inp: [G; IN_486], +const INPUT_SIZE_482: usize = 1; +const IN_482: usize = 1; +const OUT_482: usize = 2; +fn aiur_fn_482( + inp: [G; IN_482], record: &mut QueryRecord, io_buffer: &mut IOBuffer, unconstrained: bool, -) -> Result<[G; OUT_486], ExecError> { +) -> Result<[G; OUT_482], ExecError> { stacker::maybe_grow(64 * 1024, 4 * 1024 * 1024, || { let __v_0: G = inp[0]; let __r_arr: [G; OUT_111] = { let __args: [G; IN_111] = [__v_0]; let __cu = unconstrained; if let Some(result) = record.function_queries[111].get_mut(&__args[..]) { if !__cu && *result.multiplicity == G::ZERO { aiur_fn_111(__args, record, io_buffer, false)? } else { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_111] = unsafe { *(result.output.as_ptr() as *const [G; OUT_111]) }; __ret } } else { aiur_fn_111(__args, record, io_buffer, __cu)? } }; @@ -43282,8 +42998,8 @@ fn aiur_fn_486( match __v_3.as_canonical_u64() { 2u64 => { let __v_7: G = G::from_u64(1); - let __ret: [G; OUT_486] = [__v_4, __v_7]; - if let Some(result) = record.function_queries[486].get_mut(&inp[..]) { debug_assert_eq!(result.output, &__ret[..]); if !unconstrained { *result.multiplicity += G::ONE; } } else { record.function_queries[486].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained)); }; + let __ret: [G; OUT_482] = [__v_4, __v_7]; + if let Some(result) = record.function_queries[482].get_mut(&inp[..]) { debug_assert_eq!(result.output, &__ret[..]); if !unconstrained { *result.multiplicity += G::ONE; } } else { record.function_queries[482].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained)); }; return Ok(__ret); }, _ => { @@ -43321,23 +43037,23 @@ fn aiur_fn_486( let __v_38: G = G::from_u64(0); let __v_39: G = { let __values: [G; 32] = [__v_7, __v_8, __v_9, __v_10, __v_11, __v_12, __v_13, __v_14, __v_15, __v_16, __v_17, __v_18, __v_19, __v_20, __v_21, __v_22, __v_23, __v_24, __v_25, __v_26, __v_27, __v_28, __v_29, __v_30, __v_31, __v_32, __v_33, __v_34, __v_35, __v_36, __v_37, __v_38]; let __mq = record.memory_queries.get_mut(&32).ok_or(ExecError::InvalidMemorySize(32))?; if let Some(result) = __mq.get_mut(&__values[..]) { if !unconstrained { *result.multiplicity += G::ONE; } result.output[0] } else { let __ptr = G::from_usize(__mq.len()); __mq.insert(&__values[..], &[__ptr], G::from_bool(!unconstrained)); __ptr } }; let __v_40: G = G::from_u64(0); - let __ret: [G; OUT_486] = [__v_39, __v_40]; - if let Some(result) = record.function_queries[486].get_mut(&inp[..]) { debug_assert_eq!(result.output, &__ret[..]); if !unconstrained { *result.multiplicity += G::ONE; } } else { record.function_queries[486].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained)); }; + let __ret: [G; OUT_482] = [__v_39, __v_40]; + if let Some(result) = record.function_queries[482].get_mut(&inp[..]) { debug_assert_eq!(result.output, &__ret[..]); if !unconstrained { *result.multiplicity += G::ONE; } } else { record.function_queries[482].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained)); }; return Ok(__ret); }, } }) } -const INPUT_SIZE_487: usize = 14; -const IN_487: usize = 14; -const OUT_487: usize = 2; -fn aiur_fn_487( - inp: [G; IN_487], +const INPUT_SIZE_483: usize = 14; +const IN_483: usize = 14; +const OUT_483: usize = 2; +fn aiur_fn_483( + inp: [G; IN_483], record: &mut QueryRecord, io_buffer: &mut IOBuffer, unconstrained: bool, -) -> Result<[G; OUT_487], ExecError> { +) -> Result<[G; OUT_483], ExecError> { stacker::maybe_grow(64 * 1024, 4 * 1024 * 1024, || { let __v_0: G = inp[0]; let __v_1: G = inp[1]; @@ -43355,154 +43071,154 @@ fn aiur_fn_487( let __v_13: G = inp[13]; match __v_1.as_canonical_u64() { 1u64 => { - let __r_arr: [G; OUT_484] = { let __args: [G; IN_484] = [__v_0]; let __cu = unconstrained; if let Some(result) = record.function_queries[484].get_mut(&__args[..]) { if !__cu && *result.multiplicity == G::ZERO { aiur_fn_484(__args, record, io_buffer, false)? } else { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_484] = unsafe { *(result.output.as_ptr() as *const [G; OUT_484]) }; __ret } } else { aiur_fn_484(__args, record, io_buffer, __cu)? } }; + let __r_arr: [G; OUT_480] = { let __args: [G; IN_480] = [__v_0]; let __cu = unconstrained; if let Some(result) = record.function_queries[480].get_mut(&__args[..]) { if !__cu && *result.multiplicity == G::ZERO { aiur_fn_480(__args, record, io_buffer, false)? } else { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_480] = unsafe { *(result.output.as_ptr() as *const [G; OUT_480]) }; __ret } } else { aiur_fn_480(__args, record, io_buffer, __cu)? } }; let __v_14: G = __r_arr[0]; let __v_15: G = __r_arr[1]; match __v_14.as_canonical_u64() { 1u64 => { let __v_16: G = G::from_u64(1); - let __r_arr: [G; OUT_424] = { let __args: [G; IN_424] = [__v_15, __v_13]; let __cu = unconstrained; if let Some(result) = record.function_queries[424].get_mut(&__args[..]) { if !__cu && *result.multiplicity == G::ZERO { aiur_fn_424(__args, record, io_buffer, false)? } else { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_424] = unsafe { *(result.output.as_ptr() as *const [G; OUT_424]) }; __ret } } else { aiur_fn_424(__args, record, io_buffer, __cu)? } }; + let __r_arr: [G; OUT_420] = { let __args: [G; IN_420] = [__v_15, __v_13]; let __cu = unconstrained; if let Some(result) = record.function_queries[420].get_mut(&__args[..]) { if !__cu && *result.multiplicity == G::ZERO { aiur_fn_420(__args, record, io_buffer, false)? } else { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_420] = unsafe { *(result.output.as_ptr() as *const [G; OUT_420]) }; __ret } } else { aiur_fn_420(__args, record, io_buffer, __cu)? } }; let __v_17: G = __r_arr[0]; - let __ret: [G; OUT_487] = [__v_16, __v_17]; - if let Some(result) = record.function_queries[487].get_mut(&inp[..]) { debug_assert_eq!(result.output, &__ret[..]); if !unconstrained { *result.multiplicity += G::ONE; } } else { record.function_queries[487].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained)); }; + let __ret: [G; OUT_483] = [__v_16, __v_17]; + if let Some(result) = record.function_queries[483].get_mut(&inp[..]) { debug_assert_eq!(result.output, &__ret[..]); if !unconstrained { *result.multiplicity += G::ONE; } } else { record.function_queries[483].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained)); }; return Ok(__ret); }, _ => { let __v_16: G = G::from_u64(0); - let __ret: [G; OUT_487] = [__v_16, __v_0]; - if let Some(result) = record.function_queries[487].get_mut(&inp[..]) { debug_assert_eq!(result.output, &__ret[..]); if !unconstrained { *result.multiplicity += G::ONE; } } else { record.function_queries[487].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained)); }; + let __ret: [G; OUT_483] = [__v_16, __v_0]; + if let Some(result) = record.function_queries[483].get_mut(&inp[..]) { debug_assert_eq!(result.output, &__ret[..]); if !unconstrained { *result.multiplicity += G::ONE; } } else { record.function_queries[483].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained)); }; return Ok(__ret); }, } }, 2u64 => { - let __r_arr: [G; OUT_484] = { let __args: [G; IN_484] = [__v_0]; let __cu = unconstrained; if let Some(result) = record.function_queries[484].get_mut(&__args[..]) { if !__cu && *result.multiplicity == G::ZERO { aiur_fn_484(__args, record, io_buffer, false)? } else { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_484] = unsafe { *(result.output.as_ptr() as *const [G; OUT_484]) }; __ret } } else { aiur_fn_484(__args, record, io_buffer, __cu)? } }; + let __r_arr: [G; OUT_480] = { let __args: [G; IN_480] = [__v_0]; let __cu = unconstrained; if let Some(result) = record.function_queries[480].get_mut(&__args[..]) { if !__cu && *result.multiplicity == G::ZERO { aiur_fn_480(__args, record, io_buffer, false)? } else { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_480] = unsafe { *(result.output.as_ptr() as *const [G; OUT_480]) }; __ret } } else { aiur_fn_480(__args, record, io_buffer, __cu)? } }; let __v_14: G = __r_arr[0]; let __v_15: G = __r_arr[1]; match __v_14.as_canonical_u64() { 1u64 => { let __v_16: G = G::from_u64(1); - let __r_arr: [G; OUT_424] = { let __args: [G; IN_424] = [__v_15, __v_13]; let __cu = unconstrained; if let Some(result) = record.function_queries[424].get_mut(&__args[..]) { if !__cu && *result.multiplicity == G::ZERO { aiur_fn_424(__args, record, io_buffer, false)? } else { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_424] = unsafe { *(result.output.as_ptr() as *const [G; OUT_424]) }; __ret } } else { aiur_fn_424(__args, record, io_buffer, __cu)? } }; + let __r_arr: [G; OUT_420] = { let __args: [G; IN_420] = [__v_15, __v_13]; let __cu = unconstrained; if let Some(result) = record.function_queries[420].get_mut(&__args[..]) { if !__cu && *result.multiplicity == G::ZERO { aiur_fn_420(__args, record, io_buffer, false)? } else { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_420] = unsafe { *(result.output.as_ptr() as *const [G; OUT_420]) }; __ret } } else { aiur_fn_420(__args, record, io_buffer, __cu)? } }; let __v_17: G = __r_arr[0]; - let __ret: [G; OUT_487] = [__v_16, __v_17]; - if let Some(result) = record.function_queries[487].get_mut(&inp[..]) { debug_assert_eq!(result.output, &__ret[..]); if !unconstrained { *result.multiplicity += G::ONE; } } else { record.function_queries[487].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained)); }; + let __ret: [G; OUT_483] = [__v_16, __v_17]; + if let Some(result) = record.function_queries[483].get_mut(&inp[..]) { debug_assert_eq!(result.output, &__ret[..]); if !unconstrained { *result.multiplicity += G::ONE; } } else { record.function_queries[483].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained)); }; return Ok(__ret); }, _ => { let __v_16: G = G::from_u64(0); - let __ret: [G; OUT_487] = [__v_16, __v_0]; - if let Some(result) = record.function_queries[487].get_mut(&inp[..]) { debug_assert_eq!(result.output, &__ret[..]); if !unconstrained { *result.multiplicity += G::ONE; } } else { record.function_queries[487].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained)); }; + let __ret: [G; OUT_483] = [__v_16, __v_0]; + if let Some(result) = record.function_queries[483].get_mut(&inp[..]) { debug_assert_eq!(result.output, &__ret[..]); if !unconstrained { *result.multiplicity += G::ONE; } } else { record.function_queries[483].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained)); }; return Ok(__ret); }, } }, _ => { let __v_14: G = G::from_u64(0); - let __ret: [G; OUT_487] = [__v_14, __v_0]; - if let Some(result) = record.function_queries[487].get_mut(&inp[..]) { debug_assert_eq!(result.output, &__ret[..]); if !unconstrained { *result.multiplicity += G::ONE; } } else { record.function_queries[487].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained)); }; + let __ret: [G; OUT_483] = [__v_14, __v_0]; + if let Some(result) = record.function_queries[483].get_mut(&inp[..]) { debug_assert_eq!(result.output, &__ret[..]); if !unconstrained { *result.multiplicity += G::ONE; } } else { record.function_queries[483].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained)); }; return Ok(__ret); }, } }) } -const INPUT_SIZE_488: usize = 2; -const IN_488: usize = 2; -const OUT_488: usize = 1; -fn aiur_fn_488( - inp: [G; IN_488], +const INPUT_SIZE_484: usize = 2; +const IN_484: usize = 2; +const OUT_484: usize = 1; +fn aiur_fn_484( + inp: [G; IN_484], record: &mut QueryRecord, io_buffer: &mut IOBuffer, unconstrained: bool, -) -> Result<[G; OUT_488], ExecError> { +) -> Result<[G; OUT_484], ExecError> { stacker::maybe_grow(64 * 1024, 4 * 1024 * 1024, || { let __v_0: G = inp[0]; let __v_1: G = inp[1]; - let __r_arr: [G; OUT_341] = { let __args: [G; IN_341] = [__v_0]; let __cu = unconstrained; if let Some(result) = record.function_queries[341].get_mut(&__args[..]) { if !__cu && *result.multiplicity == G::ZERO { aiur_fn_341(__args, record, io_buffer, false)? } else { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_341] = unsafe { *(result.output.as_ptr() as *const [G; OUT_341]) }; __ret } } else { aiur_fn_341(__args, record, io_buffer, __cu)? } }; + let __r_arr: [G; OUT_337] = { let __args: [G; IN_337] = [__v_0]; let __cu = unconstrained; if let Some(result) = record.function_queries[337].get_mut(&__args[..]) { if !__cu && *result.multiplicity == G::ZERO { aiur_fn_337(__args, record, io_buffer, false)? } else { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_337] = unsafe { *(result.output.as_ptr() as *const [G; OUT_337]) }; __ret } } else { aiur_fn_337(__args, record, io_buffer, __cu)? } }; let __v_2: G = __r_arr[0]; match __v_2.as_canonical_u64() { 0u64 => { let __v_3: G = G::from_u64(1); let __v_4: G = G::from_u64(1); let __v_5: G = { let __values: [G; 3] = [__v_3, __v_4, __v_4]; let __mq = record.memory_queries.get_mut(&3).ok_or(ExecError::InvalidMemorySize(3))?; if let Some(result) = __mq.get_mut(&__values[..]) { if !unconstrained { *result.multiplicity += G::ONE; } result.output[0] } else { let __ptr = G::from_usize(__mq.len()); __mq.insert(&__values[..], &[__ptr], G::from_bool(!unconstrained)); __ptr } }; - let __r_arr: [G; OUT_490] = { let __args: [G; IN_490] = [__v_0, __v_5]; let __cu = unconstrained; if let Some(result) = record.function_queries[490].get_mut(&__args[..]) { if !__cu && *result.multiplicity == G::ZERO { aiur_fn_490(__args, record, io_buffer, false)? } else { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_490] = unsafe { *(result.output.as_ptr() as *const [G; OUT_490]) }; __ret } } else { aiur_fn_490(__args, record, io_buffer, __cu)? } }; + let __r_arr: [G; OUT_486] = { let __args: [G; IN_486] = [__v_0, __v_5]; let __cu = unconstrained; if let Some(result) = record.function_queries[486].get_mut(&__args[..]) { if !__cu && *result.multiplicity == G::ZERO { aiur_fn_486(__args, record, io_buffer, false)? } else { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_486] = unsafe { *(result.output.as_ptr() as *const [G; OUT_486]) }; __ret } } else { aiur_fn_486(__args, record, io_buffer, __cu)? } }; let __v_6: G = __r_arr[0]; - let __ret: [G; OUT_488] = [__v_6]; - if let Some(result) = record.function_queries[488].get_mut(&inp[..]) { debug_assert_eq!(result.output, &__ret[..]); if !unconstrained { *result.multiplicity += G::ONE; } } else { record.function_queries[488].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained)); }; + let __ret: [G; OUT_484] = [__v_6]; + if let Some(result) = record.function_queries[484].get_mut(&inp[..]) { debug_assert_eq!(result.output, &__ret[..]); if !unconstrained { *result.multiplicity += G::ONE; } } else { record.function_queries[484].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained)); }; return Ok(__ret); }, _ => { - let __r_arr: [G; OUT_489] = { let __args: [G; IN_489] = [__v_0, __v_1, __v_2]; let __cu = unconstrained; if let Some(result) = record.function_queries[489].get_mut(&__args[..]) { if !__cu && *result.multiplicity == G::ZERO { aiur_fn_489(__args, record, io_buffer, false)? } else { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_489] = unsafe { *(result.output.as_ptr() as *const [G; OUT_489]) }; __ret } } else { aiur_fn_489(__args, record, io_buffer, __cu)? } }; + let __r_arr: [G; OUT_485] = { let __args: [G; IN_485] = [__v_0, __v_1, __v_2]; let __cu = unconstrained; if let Some(result) = record.function_queries[485].get_mut(&__args[..]) { if !__cu && *result.multiplicity == G::ZERO { aiur_fn_485(__args, record, io_buffer, false)? } else { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_485] = unsafe { *(result.output.as_ptr() as *const [G; OUT_485]) }; __ret } } else { aiur_fn_485(__args, record, io_buffer, __cu)? } }; let __v_3: G = __r_arr[0]; - let __ret: [G; OUT_488] = [__v_3]; - if let Some(result) = record.function_queries[488].get_mut(&inp[..]) { debug_assert_eq!(result.output, &__ret[..]); if !unconstrained { *result.multiplicity += G::ONE; } } else { record.function_queries[488].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained)); }; + let __ret: [G; OUT_484] = [__v_3]; + if let Some(result) = record.function_queries[484].get_mut(&inp[..]) { debug_assert_eq!(result.output, &__ret[..]); if !unconstrained { *result.multiplicity += G::ONE; } } else { record.function_queries[484].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained)); }; return Ok(__ret); }, } }) } -const INPUT_SIZE_489: usize = 3; -const IN_489: usize = 3; -const OUT_489: usize = 1; -fn aiur_fn_489( - inp: [G; IN_489], +const INPUT_SIZE_485: usize = 3; +const IN_485: usize = 3; +const OUT_485: usize = 1; +fn aiur_fn_485( + inp: [G; IN_485], record: &mut QueryRecord, io_buffer: &mut IOBuffer, unconstrained: bool, -) -> Result<[G; OUT_489], ExecError> { +) -> Result<[G; OUT_485], ExecError> { stacker::maybe_grow(64 * 1024, 4 * 1024 * 1024, || { let __v_0: G = inp[0]; let __v_1: G = inp[1]; let __v_2: G = inp[2]; let __v_3: G = G::from_u64(0); - let __r_arr: [G; OUT_355] = { let __args: [G; IN_355] = [__v_0, __v_3]; let __cu = unconstrained; if let Some(result) = record.function_queries[355].get_mut(&__args[..]) { if !__cu && *result.multiplicity == G::ZERO { aiur_fn_355(__args, record, io_buffer, false)? } else { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_355] = unsafe { *(result.output.as_ptr() as *const [G; OUT_355]) }; __ret } } else { aiur_fn_355(__args, record, io_buffer, __cu)? } }; + let __r_arr: [G; OUT_351] = { let __args: [G; IN_351] = [__v_0, __v_3]; let __cu = unconstrained; if let Some(result) = record.function_queries[351].get_mut(&__args[..]) { if !__cu && *result.multiplicity == G::ZERO { aiur_fn_351(__args, record, io_buffer, false)? } else { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_351] = unsafe { *(result.output.as_ptr() as *const [G; OUT_351]) }; __ret } } else { aiur_fn_351(__args, record, io_buffer, __cu)? } }; let __v_4: G = __r_arr[0]; - let __r_arr: [G; OUT_764] = { let __args: [G; IN_764] = [__v_1]; let __cu = unconstrained; if let Some(result) = record.function_queries[764].get_mut(&__args[..]) { if !__cu && *result.multiplicity == G::ZERO { aiur_fn_764(__args, record, io_buffer, false)? } else { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_764] = unsafe { *(result.output.as_ptr() as *const [G; OUT_764]) }; __ret } } else { aiur_fn_764(__args, record, io_buffer, __cu)? } }; + let __r_arr: [G; OUT_760] = { let __args: [G; IN_760] = [__v_1]; let __cu = unconstrained; if let Some(result) = record.function_queries[760].get_mut(&__args[..]) { if !__cu && *result.multiplicity == G::ZERO { aiur_fn_760(__args, record, io_buffer, false)? } else { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_760] = unsafe { *(result.output.as_ptr() as *const [G; OUT_760]) }; __ret } } else { aiur_fn_760(__args, record, io_buffer, __cu)? } }; let __v_5: G = __r_arr[0]; - let __r_arr: [G; OUT_345] = { let __args: [G; IN_345] = [__v_4, __v_5]; let __cu = unconstrained; if let Some(result) = record.function_queries[345].get_mut(&__args[..]) { if !__cu && *result.multiplicity == G::ZERO { aiur_fn_345(__args, record, io_buffer, false)? } else { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_345] = unsafe { *(result.output.as_ptr() as *const [G; OUT_345]) }; __ret } } else { aiur_fn_345(__args, record, io_buffer, __cu)? } }; + let __r_arr: [G; OUT_341] = { let __args: [G; IN_341] = [__v_4, __v_5]; let __cu = unconstrained; if let Some(result) = record.function_queries[341].get_mut(&__args[..]) { if !__cu && *result.multiplicity == G::ZERO { aiur_fn_341(__args, record, io_buffer, false)? } else { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_341] = unsafe { *(result.output.as_ptr() as *const [G; OUT_341]) }; __ret } } else { aiur_fn_341(__args, record, io_buffer, __cu)? } }; let __v_6: G = __r_arr[0]; match __v_6.as_canonical_u64() { 0u64 => { - let __r_arr: [G; OUT_354] = { let __args: [G; IN_354] = [__v_1, __v_2]; let __cu = unconstrained; if let Some(result) = record.function_queries[354].get_mut(&__args[..]) { if !__cu && *result.multiplicity == G::ZERO { aiur_fn_354(__args, record, io_buffer, false)? } else { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_354] = unsafe { *(result.output.as_ptr() as *const [G; OUT_354]) }; __ret } } else { aiur_fn_354(__args, record, io_buffer, __cu)? } }; + let __r_arr: [G; OUT_350] = { let __args: [G; IN_350] = [__v_1, __v_2]; let __cu = unconstrained; if let Some(result) = record.function_queries[350].get_mut(&__args[..]) { if !__cu && *result.multiplicity == G::ZERO { aiur_fn_350(__args, record, io_buffer, false)? } else { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_350] = unsafe { *(result.output.as_ptr() as *const [G; OUT_350]) }; __ret } } else { aiur_fn_350(__args, record, io_buffer, __cu)? } }; let __v_7: G = __r_arr[0]; - let __r_arr: [G; OUT_490] = { let __args: [G; IN_490] = [__v_0, __v_7]; let __cu = unconstrained; if let Some(result) = record.function_queries[490].get_mut(&__args[..]) { if !__cu && *result.multiplicity == G::ZERO { aiur_fn_490(__args, record, io_buffer, false)? } else { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_490] = unsafe { *(result.output.as_ptr() as *const [G; OUT_490]) }; __ret } } else { aiur_fn_490(__args, record, io_buffer, __cu)? } }; + let __r_arr: [G; OUT_486] = { let __args: [G; IN_486] = [__v_0, __v_7]; let __cu = unconstrained; if let Some(result) = record.function_queries[486].get_mut(&__args[..]) { if !__cu && *result.multiplicity == G::ZERO { aiur_fn_486(__args, record, io_buffer, false)? } else { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_486] = unsafe { *(result.output.as_ptr() as *const [G; OUT_486]) }; __ret } } else { aiur_fn_486(__args, record, io_buffer, __cu)? } }; let __v_8: G = __r_arr[0]; - let __ret: [G; OUT_489] = [__v_8]; - if let Some(result) = record.function_queries[489].get_mut(&inp[..]) { debug_assert_eq!(result.output, &__ret[..]); if !unconstrained { *result.multiplicity += G::ONE; } } else { record.function_queries[489].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained)); }; + let __ret: [G; OUT_485] = [__v_8]; + if let Some(result) = record.function_queries[485].get_mut(&inp[..]) { debug_assert_eq!(result.output, &__ret[..]); if !unconstrained { *result.multiplicity += G::ONE; } } else { record.function_queries[485].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained)); }; return Ok(__ret); }, _ => { let __v_7: G = G::from_u64(0); - let __r_arr: [G; OUT_363] = { let __args: [G; IN_363] = [__v_0, __v_6, __v_7]; let __cu = unconstrained; if let Some(result) = record.function_queries[363].get_mut(&__args[..]) { if !__cu && *result.multiplicity == G::ZERO { aiur_fn_363(__args, record, io_buffer, false)? } else { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_363] = unsafe { *(result.output.as_ptr() as *const [G; OUT_363]) }; __ret } } else { aiur_fn_363(__args, record, io_buffer, __cu)? } }; + let __r_arr: [G; OUT_359] = { let __args: [G; IN_359] = [__v_0, __v_6, __v_7]; let __cu = unconstrained; if let Some(result) = record.function_queries[359].get_mut(&__args[..]) { if !__cu && *result.multiplicity == G::ZERO { aiur_fn_359(__args, record, io_buffer, false)? } else { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_359] = unsafe { *(result.output.as_ptr() as *const [G; OUT_359]) }; __ret } } else { aiur_fn_359(__args, record, io_buffer, __cu)? } }; let __v_8: G = __r_arr[0]; - let __r_arr: [G; OUT_775] = { let __args: [G; IN_775] = [__v_1, __v_6]; let __cu = unconstrained; if let Some(result) = record.function_queries[775].get_mut(&__args[..]) { if !__cu && *result.multiplicity == G::ZERO { aiur_fn_775(__args, record, io_buffer, false)? } else { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_775] = unsafe { *(result.output.as_ptr() as *const [G; OUT_775]) }; __ret } } else { aiur_fn_775(__args, record, io_buffer, __cu)? } }; + let __r_arr: [G; OUT_771] = { let __args: [G; IN_771] = [__v_1, __v_6]; let __cu = unconstrained; if let Some(result) = record.function_queries[771].get_mut(&__args[..]) { if !__cu && *result.multiplicity == G::ZERO { aiur_fn_771(__args, record, io_buffer, false)? } else { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_771] = unsafe { *(result.output.as_ptr() as *const [G; OUT_771]) }; __ret } } else { aiur_fn_771(__args, record, io_buffer, __cu)? } }; let __v_9: G = __r_arr[0]; let __v_10: G = (__v_2 - __v_6); - let __r_arr: [G; OUT_354] = { let __args: [G; IN_354] = [__v_9, __v_10]; let __cu = unconstrained; if let Some(result) = record.function_queries[354].get_mut(&__args[..]) { if !__cu && *result.multiplicity == G::ZERO { aiur_fn_354(__args, record, io_buffer, false)? } else { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_354] = unsafe { *(result.output.as_ptr() as *const [G; OUT_354]) }; __ret } } else { aiur_fn_354(__args, record, io_buffer, __cu)? } }; + let __r_arr: [G; OUT_350] = { let __args: [G; IN_350] = [__v_9, __v_10]; let __cu = unconstrained; if let Some(result) = record.function_queries[350].get_mut(&__args[..]) { if !__cu && *result.multiplicity == G::ZERO { aiur_fn_350(__args, record, io_buffer, false)? } else { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_350] = unsafe { *(result.output.as_ptr() as *const [G; OUT_350]) }; __ret } } else { aiur_fn_350(__args, record, io_buffer, __cu)? } }; let __v_11: G = __r_arr[0]; - let __r_arr: [G; OUT_490] = { let __args: [G; IN_490] = [__v_8, __v_11]; let __cu = unconstrained; if let Some(result) = record.function_queries[490].get_mut(&__args[..]) { if !__cu && *result.multiplicity == G::ZERO { aiur_fn_490(__args, record, io_buffer, false)? } else { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_490] = unsafe { *(result.output.as_ptr() as *const [G; OUT_490]) }; __ret } } else { aiur_fn_490(__args, record, io_buffer, __cu)? } }; + let __r_arr: [G; OUT_486] = { let __args: [G; IN_486] = [__v_8, __v_11]; let __cu = unconstrained; if let Some(result) = record.function_queries[486].get_mut(&__args[..]) { if !__cu && *result.multiplicity == G::ZERO { aiur_fn_486(__args, record, io_buffer, false)? } else { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_486] = unsafe { *(result.output.as_ptr() as *const [G; OUT_486]) }; __ret } } else { aiur_fn_486(__args, record, io_buffer, __cu)? } }; let __v_12: G = __r_arr[0]; let __v_13: G = G::from_u64(0); - let __r_arr: [G; OUT_359] = { let __args: [G; IN_359] = [__v_12, __v_6, __v_13]; let __cu = unconstrained; if let Some(result) = record.function_queries[359].get_mut(&__args[..]) { if !__cu && *result.multiplicity == G::ZERO { aiur_fn_359(__args, record, io_buffer, false)? } else { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_359] = unsafe { *(result.output.as_ptr() as *const [G; OUT_359]) }; __ret } } else { aiur_fn_359(__args, record, io_buffer, __cu)? } }; + let __r_arr: [G; OUT_355] = { let __args: [G; IN_355] = [__v_12, __v_6, __v_13]; let __cu = unconstrained; if let Some(result) = record.function_queries[355].get_mut(&__args[..]) { if !__cu && *result.multiplicity == G::ZERO { aiur_fn_355(__args, record, io_buffer, false)? } else { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_355] = unsafe { *(result.output.as_ptr() as *const [G; OUT_355]) }; __ret } } else { aiur_fn_355(__args, record, io_buffer, __cu)? } }; let __v_14: G = __r_arr[0]; - let __ret: [G; OUT_489] = [__v_14]; - if let Some(result) = record.function_queries[489].get_mut(&inp[..]) { debug_assert_eq!(result.output, &__ret[..]); if !unconstrained { *result.multiplicity += G::ONE; } } else { record.function_queries[489].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained)); }; + let __ret: [G; OUT_485] = [__v_14]; + if let Some(result) = record.function_queries[485].get_mut(&inp[..]) { debug_assert_eq!(result.output, &__ret[..]); if !unconstrained { *result.multiplicity += G::ONE; } } else { record.function_queries[485].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained)); }; return Ok(__ret); }, } }) } -const INPUT_SIZE_490: usize = 2; -const IN_490: usize = 2; -const OUT_490: usize = 1; -fn aiur_fn_490( - inp: [G; IN_490], +const INPUT_SIZE_486: usize = 2; +const IN_486: usize = 2; +const OUT_486: usize = 1; +fn aiur_fn_486( + inp: [G; IN_486], record: &mut QueryRecord, io_buffer: &mut IOBuffer, unconstrained: bool, -) -> Result<[G; OUT_490], ExecError> { +) -> Result<[G; OUT_486], ExecError> { stacker::maybe_grow(64 * 1024, 4 * 1024 * 1024, || { let __v_0: G = inp[0]; let __v_1: G = inp[1]; @@ -43513,15 +43229,15 @@ fn aiur_fn_490( let __v_5: G = __loaded[3]; match __v_2.as_canonical_u64() { 0u64 => { - let __r_arr: [G; OUT_766] = { let __args: [G; IN_766] = [__v_1, __v_3]; let __cu = unconstrained; if let Some(result) = record.function_queries[766].get_mut(&__args[..]) { if !__cu && *result.multiplicity == G::ZERO { aiur_fn_766(__args, record, io_buffer, false)? } else { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_766] = unsafe { *(result.output.as_ptr() as *const [G; OUT_766]) }; __ret } } else { aiur_fn_766(__args, record, io_buffer, __cu)? } }; + let __r_arr: [G; OUT_762] = { let __args: [G; IN_762] = [__v_1, __v_3]; let __cu = unconstrained; if let Some(result) = record.function_queries[762].get_mut(&__args[..]) { if !__cu && *result.multiplicity == G::ZERO { aiur_fn_762(__args, record, io_buffer, false)? } else { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_762] = unsafe { *(result.output.as_ptr() as *const [G; OUT_762]) }; __ret } } else { aiur_fn_762(__args, record, io_buffer, __cu)? } }; let __v_6: G = __r_arr[0]; let __v_7: G = G::from_u64(1); let __v_8: G = (__v_3 + __v_7); let __v_9: G = G::from_u64(0); - let __r_arr: [G; OUT_359] = { let __args: [G; IN_359] = [__v_6, __v_8, __v_9]; let __cu = unconstrained; if let Some(result) = record.function_queries[359].get_mut(&__args[..]) { if !__cu && *result.multiplicity == G::ZERO { aiur_fn_359(__args, record, io_buffer, false)? } else { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_359] = unsafe { *(result.output.as_ptr() as *const [G; OUT_359]) }; __ret } } else { aiur_fn_359(__args, record, io_buffer, __cu)? } }; + let __r_arr: [G; OUT_355] = { let __args: [G; IN_355] = [__v_6, __v_8, __v_9]; let __cu = unconstrained; if let Some(result) = record.function_queries[355].get_mut(&__args[..]) { if !__cu && *result.multiplicity == G::ZERO { aiur_fn_355(__args, record, io_buffer, false)? } else { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_355] = unsafe { *(result.output.as_ptr() as *const [G; OUT_355]) }; __ret } } else { aiur_fn_355(__args, record, io_buffer, __cu)? } }; let __v_10: G = __r_arr[0]; - let __ret: [G; OUT_490] = [__v_10]; - if let Some(result) = record.function_queries[490].get_mut(&inp[..]) { debug_assert_eq!(result.output, &__ret[..]); if !unconstrained { *result.multiplicity += G::ONE; } } else { record.function_queries[490].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained)); }; + let __ret: [G; OUT_486] = [__v_10]; + if let Some(result) = record.function_queries[486].get_mut(&inp[..]) { debug_assert_eq!(result.output, &__ret[..]); if !unconstrained { *result.multiplicity += G::ONE; } } else { record.function_queries[486].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained)); }; return Ok(__ret); }, 1u64 => { @@ -43529,16 +43245,16 @@ fn aiur_fn_490( let __v_7: G = G::from_u64(1); let __v_8: G = G::from_u64(0); let __v_9: G = { let __values: [G; 3] = [__v_7, __v_3, __v_8]; let __mq = record.memory_queries.get_mut(&3).ok_or(ExecError::InvalidMemorySize(3))?; if let Some(result) = __mq.get_mut(&__values[..]) { if !unconstrained { *result.multiplicity += G::ONE; } result.output[0] } else { let __ptr = G::from_usize(__mq.len()); __mq.insert(&__values[..], &[__ptr], G::from_bool(!unconstrained)); __ptr } }; - let __r_arr: [G; OUT_333] = { let __args: [G; IN_333] = [__v_9]; let __cu = unconstrained; if let Some(result) = record.function_queries[333].get_mut(&__args[..]) { if !__cu && *result.multiplicity == G::ZERO { aiur_fn_333(__args, record, io_buffer, false)? } else { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_333] = unsafe { *(result.output.as_ptr() as *const [G; OUT_333]) }; __ret } } else { aiur_fn_333(__args, record, io_buffer, __cu)? } }; + let __r_arr: [G; OUT_329] = { let __args: [G; IN_329] = [__v_9]; let __cu = unconstrained; if let Some(result) = record.function_queries[329].get_mut(&__args[..]) { if !__cu && *result.multiplicity == G::ZERO { aiur_fn_329(__args, record, io_buffer, false)? } else { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_329] = unsafe { *(result.output.as_ptr() as *const [G; OUT_329]) }; __ret } } else { aiur_fn_329(__args, record, io_buffer, __cu)? } }; let __v_10: G = __r_arr[0]; let __v_11: G = G::from_u64(0); let __v_12: G = { let __values: [G; 4] = [__v_6, __v_10, __v_11, __v_11]; let __mq = record.memory_queries.get_mut(&4).ok_or(ExecError::InvalidMemorySize(4))?; if let Some(result) = __mq.get_mut(&__values[..]) { if !unconstrained { *result.multiplicity += G::ONE; } result.output[0] } else { let __ptr = G::from_usize(__mq.len()); __mq.insert(&__values[..], &[__ptr], G::from_bool(!unconstrained)); __ptr } }; - let __ret: [G; OUT_490] = [__v_12]; - if let Some(result) = record.function_queries[490].get_mut(&inp[..]) { debug_assert_eq!(result.output, &__ret[..]); if !unconstrained { *result.multiplicity += G::ONE; } } else { record.function_queries[490].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained)); }; + let __ret: [G; OUT_486] = [__v_12]; + if let Some(result) = record.function_queries[486].get_mut(&inp[..]) { debug_assert_eq!(result.output, &__ret[..]); if !unconstrained { *result.multiplicity += G::ONE; } } else { record.function_queries[486].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained)); }; return Ok(__ret); }, 2u64 => { - let __r_arr: [G; OUT_287] = { let __args: [G; IN_287] = [__v_3]; let __cu = unconstrained; if let Some(result) = record.function_queries[287].get_mut(&__args[..]) { if !__cu && *result.multiplicity == G::ZERO { aiur_fn_287(__args, record, io_buffer, false)? } else { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_287] = unsafe { *(result.output.as_ptr() as *const [G; OUT_287]) }; __ret } } else { aiur_fn_287(__args, record, io_buffer, __cu)? } }; + let __r_arr: [G; OUT_283] = { let __args: [G; IN_283] = [__v_3]; let __cu = unconstrained; if let Some(result) = record.function_queries[283].get_mut(&__args[..]) { if !__cu && *result.multiplicity == G::ZERO { aiur_fn_283(__args, record, io_buffer, false)? } else { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_283] = unsafe { *(result.output.as_ptr() as *const [G; OUT_283]) }; __ret } } else { aiur_fn_283(__args, record, io_buffer, __cu)? } }; let __v_6: G = __r_arr[0]; let __loaded: [G; 12] = { let __mq = record.memory_queries.get_mut(&12).ok_or(ExecError::InvalidMemorySize(12))?; let __ptr_u64 = __v_6.as_canonical_u64(); let __ptr_usize = usize::try_from(__ptr_u64).ok().ok_or(ExecError::PointerTooLarge(__ptr_u64))?; let (__args, __mult) = __mq.get_index_mut(__ptr_usize).ok_or(ExecError::UnboundPointer { ptr: __ptr_u64, size: 12 })?; if !unconstrained { *__mult += G::ONE; } let __arr: [G; 12] = __args[..12].try_into().unwrap(); __arr }; let __v_7: G = __loaded[0]; @@ -43553,91 +43269,91 @@ fn aiur_fn_490( let __v_16: G = __loaded[9]; let __v_17: G = __loaded[10]; let __v_18: G = __loaded[11]; - let __r_arr: [G; OUT_431] = { let __args: [G; IN_431] = [__v_7, __v_8, __v_9, __v_10, __v_11, __v_12, __v_13, __v_14, __v_15, __v_16, __v_17, __v_18]; let __cu = unconstrained; if let Some(result) = record.function_queries[431].get_mut(&__args[..]) { if !__cu && *result.multiplicity == G::ZERO { aiur_fn_431(__args, record, io_buffer, false)? } else { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_431] = unsafe { *(result.output.as_ptr() as *const [G; OUT_431]) }; __ret } } else { aiur_fn_431(__args, record, io_buffer, __cu)? } }; + let __r_arr: [G; OUT_427] = { let __args: [G; IN_427] = [__v_7, __v_8, __v_9, __v_10, __v_11, __v_12, __v_13, __v_14, __v_15, __v_16, __v_17, __v_18]; let __cu = unconstrained; if let Some(result) = record.function_queries[427].get_mut(&__args[..]) { if !__cu && *result.multiplicity == G::ZERO { aiur_fn_427(__args, record, io_buffer, false)? } else { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_427] = unsafe { *(result.output.as_ptr() as *const [G; OUT_427]) }; __ret } } else { aiur_fn_427(__args, record, io_buffer, __cu)? } }; let __v_19: G = __r_arr[0]; - let __r_arr: [G; OUT_764] = { let __args: [G; IN_764] = [__v_4]; let __cu = unconstrained; if let Some(result) = record.function_queries[764].get_mut(&__args[..]) { if !__cu && *result.multiplicity == G::ZERO { aiur_fn_764(__args, record, io_buffer, false)? } else { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_764] = unsafe { *(result.output.as_ptr() as *const [G; OUT_764]) }; __ret } } else { aiur_fn_764(__args, record, io_buffer, __cu)? } }; + let __r_arr: [G; OUT_760] = { let __args: [G; IN_760] = [__v_4]; let __cu = unconstrained; if let Some(result) = record.function_queries[760].get_mut(&__args[..]) { if !__cu && *result.multiplicity == G::ZERO { aiur_fn_760(__args, record, io_buffer, false)? } else { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_760] = unsafe { *(result.output.as_ptr() as *const [G; OUT_760]) }; __ret } } else { aiur_fn_760(__args, record, io_buffer, __cu)? } }; let __v_20: G = __r_arr[0]; - let __r_arr: [G; OUT_432] = { let __args: [G; IN_432] = [__v_7, __v_8, __v_9, __v_10, __v_11, __v_12, __v_13, __v_14, __v_15, __v_16, __v_17, __v_18]; let __cu = unconstrained; if let Some(result) = record.function_queries[432].get_mut(&__args[..]) { if !__cu && *result.multiplicity == G::ZERO { aiur_fn_432(__args, record, io_buffer, false)? } else { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_432] = unsafe { *(result.output.as_ptr() as *const [G; OUT_432]) }; __ret } } else { aiur_fn_432(__args, record, io_buffer, __cu)? } }; + let __r_arr: [G; OUT_428] = { let __args: [G; IN_428] = [__v_7, __v_8, __v_9, __v_10, __v_11, __v_12, __v_13, __v_14, __v_15, __v_16, __v_17, __v_18]; let __cu = unconstrained; if let Some(result) = record.function_queries[428].get_mut(&__args[..]) { if !__cu && *result.multiplicity == G::ZERO { aiur_fn_428(__args, record, io_buffer, false)? } else { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_428] = unsafe { *(result.output.as_ptr() as *const [G; OUT_428]) }; __ret } } else { aiur_fn_428(__args, record, io_buffer, __cu)? } }; let __v_21: G = __r_arr[0]; if (__v_20 != __v_19) { return Err(ExecError::AssertEqMismatch { lhs: __v_20.as_canonical_u64(), rhs: __v_19.as_canonical_u64(), msg: Some("Const applied to wrong number of universe levels".to_string()) }); } - let __r_arr: [G; OUT_336] = { let __args: [G; IN_336] = [__v_21, __v_4]; let __cu = unconstrained; if let Some(result) = record.function_queries[336].get_mut(&__args[..]) { if !__cu && *result.multiplicity == G::ZERO { aiur_fn_336(__args, record, io_buffer, false)? } else { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_336] = unsafe { *(result.output.as_ptr() as *const [G; OUT_336]) }; __ret } } else { aiur_fn_336(__args, record, io_buffer, __cu)? } }; + let __r_arr: [G; OUT_332] = { let __args: [G; IN_332] = [__v_21, __v_4]; let __cu = unconstrained; if let Some(result) = record.function_queries[332].get_mut(&__args[..]) { if !__cu && *result.multiplicity == G::ZERO { aiur_fn_332(__args, record, io_buffer, false)? } else { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_332] = unsafe { *(result.output.as_ptr() as *const [G; OUT_332]) }; __ret } } else { aiur_fn_332(__args, record, io_buffer, __cu)? } }; let __v_22: G = __r_arr[0]; - let __ret: [G; OUT_490] = [__v_22]; - if let Some(result) = record.function_queries[490].get_mut(&inp[..]) { debug_assert_eq!(result.output, &__ret[..]); if !unconstrained { *result.multiplicity += G::ONE; } } else { record.function_queries[490].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained)); }; + let __ret: [G; OUT_486] = [__v_22]; + if let Some(result) = record.function_queries[486].get_mut(&inp[..]) { debug_assert_eq!(result.output, &__ret[..]); if !unconstrained { *result.multiplicity += G::ONE; } } else { record.function_queries[486].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained)); }; return Ok(__ret); }, 3u64 => { let __r_arr: [G; OUT_111] = { let __args: [G; IN_111] = [__v_0]; let __cu = unconstrained; if let Some(result) = record.function_queries[111].get_mut(&__args[..]) { if !__cu && *result.multiplicity == G::ZERO { aiur_fn_111(__args, record, io_buffer, false)? } else { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_111] = unsafe { *(result.output.as_ptr() as *const [G; OUT_111]) }; __ret } } else { aiur_fn_111(__args, record, io_buffer, __cu)? } }; let __v_6: G = __r_arr[0]; let __v_7: G = __r_arr[1]; - let __r_arr: [G; OUT_488] = { let __args: [G; IN_488] = [__v_6, __v_1]; let __cu = unconstrained; if let Some(result) = record.function_queries[488].get_mut(&__args[..]) { if !__cu && *result.multiplicity == G::ZERO { aiur_fn_488(__args, record, io_buffer, false)? } else { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_488] = unsafe { *(result.output.as_ptr() as *const [G; OUT_488]) }; __ret } } else { aiur_fn_488(__args, record, io_buffer, __cu)? } }; + let __r_arr: [G; OUT_484] = { let __args: [G; IN_484] = [__v_6, __v_1]; let __cu = unconstrained; if let Some(result) = record.function_queries[484].get_mut(&__args[..]) { if !__cu && *result.multiplicity == G::ZERO { aiur_fn_484(__args, record, io_buffer, false)? } else { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_484] = unsafe { *(result.output.as_ptr() as *const [G; OUT_484]) }; __ret } } else { aiur_fn_484(__args, record, io_buffer, __cu)? } }; let __v_8: G = __r_arr[0]; let __v_9: G = G::from_u64(1); let __v_10: G = G::from_u64(1); let __v_11: G = { let __values: [G; 3] = [__v_9, __v_10, __v_10]; let __mq = record.memory_queries.get_mut(&3).ok_or(ExecError::InvalidMemorySize(3))?; if let Some(result) = __mq.get_mut(&__values[..]) { if !unconstrained { *result.multiplicity += G::ONE; } result.output[0] } else { let __ptr = G::from_usize(__mq.len()); __mq.insert(&__values[..], &[__ptr], G::from_bool(!unconstrained)); __ptr } }; - let __r_arr: [G; OUT_491] = { let __args: [G; IN_491] = [__v_8, __v_7, __v_11, __v_1]; let __cu = unconstrained; if let Some(result) = record.function_queries[491].get_mut(&__args[..]) { if !__cu && *result.multiplicity == G::ZERO { aiur_fn_491(__args, record, io_buffer, false)? } else { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_491] = unsafe { *(result.output.as_ptr() as *const [G; OUT_491]) }; __ret } } else { aiur_fn_491(__args, record, io_buffer, __cu)? } }; + let __r_arr: [G; OUT_487] = { let __args: [G; IN_487] = [__v_8, __v_7, __v_11, __v_1]; let __cu = unconstrained; if let Some(result) = record.function_queries[487].get_mut(&__args[..]) { if !__cu && *result.multiplicity == G::ZERO { aiur_fn_487(__args, record, io_buffer, false)? } else { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_487] = unsafe { *(result.output.as_ptr() as *const [G; OUT_487]) }; __ret } } else { aiur_fn_487(__args, record, io_buffer, __cu)? } }; let __v_12: G = __r_arr[0]; - let __ret: [G; OUT_490] = [__v_12]; - if let Some(result) = record.function_queries[490].get_mut(&inp[..]) { debug_assert_eq!(result.output, &__ret[..]); if !unconstrained { *result.multiplicity += G::ONE; } } else { record.function_queries[490].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained)); }; + let __ret: [G; OUT_486] = [__v_12]; + if let Some(result) = record.function_queries[486].get_mut(&inp[..]) { debug_assert_eq!(result.output, &__ret[..]); if !unconstrained { *result.multiplicity += G::ONE; } } else { record.function_queries[486].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained)); }; return Ok(__ret); }, 4u64 => { - let __r_arr: [G; OUT_499] = { let __args: [G; IN_499] = [__v_3, __v_1]; let __cu = unconstrained; if let Some(result) = record.function_queries[499].get_mut(&__args[..]) { if !__cu && *result.multiplicity == G::ZERO { aiur_fn_499(__args, record, io_buffer, false)? } else { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_499] = unsafe { *(result.output.as_ptr() as *const [G; OUT_499]) }; __ret } } else { aiur_fn_499(__args, record, io_buffer, __cu)? } }; + let __r_arr: [G; OUT_495] = { let __args: [G; IN_495] = [__v_3, __v_1]; let __cu = unconstrained; if let Some(result) = record.function_queries[495].get_mut(&__args[..]) { if !__cu && *result.multiplicity == G::ZERO { aiur_fn_495(__args, record, io_buffer, false)? } else { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_495] = unsafe { *(result.output.as_ptr() as *const [G; OUT_495]) }; __ret } } else { aiur_fn_495(__args, record, io_buffer, __cu)? } }; let __v_6: G = __r_arr[0]; let __v_7: G = G::from_u64(0); let __v_8: G = { let __values: [G; 3] = [__v_7, __v_3, __v_1]; let __mq = record.memory_queries.get_mut(&3).ok_or(ExecError::InvalidMemorySize(3))?; if let Some(result) = __mq.get_mut(&__values[..]) { if !unconstrained { *result.multiplicity += G::ONE; } result.output[0] } else { let __ptr = G::from_usize(__mq.len()); __mq.insert(&__values[..], &[__ptr], G::from_bool(!unconstrained)); __ptr } }; - let __r_arr: [G; OUT_488] = { let __args: [G; IN_488] = [__v_4, __v_8]; let __cu = unconstrained; if let Some(result) = record.function_queries[488].get_mut(&__args[..]) { if !__cu && *result.multiplicity == G::ZERO { aiur_fn_488(__args, record, io_buffer, false)? } else { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_488] = unsafe { *(result.output.as_ptr() as *const [G; OUT_488]) }; __ret } } else { aiur_fn_488(__args, record, io_buffer, __cu)? } }; + let __r_arr: [G; OUT_484] = { let __args: [G; IN_484] = [__v_4, __v_8]; let __cu = unconstrained; if let Some(result) = record.function_queries[484].get_mut(&__args[..]) { if !__cu && *result.multiplicity == G::ZERO { aiur_fn_484(__args, record, io_buffer, false)? } else { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_484] = unsafe { *(result.output.as_ptr() as *const [G; OUT_484]) }; __ret } } else { aiur_fn_484(__args, record, io_buffer, __cu)? } }; let __v_9: G = __r_arr[0]; let __v_10: G = G::from_u64(5); let __v_11: G = G::from_u64(0); let __v_12: G = { let __values: [G; 4] = [__v_10, __v_3, __v_9, __v_11]; let __mq = record.memory_queries.get_mut(&4).ok_or(ExecError::InvalidMemorySize(4))?; if let Some(result) = __mq.get_mut(&__values[..]) { if !unconstrained { *result.multiplicity += G::ONE; } result.output[0] } else { let __ptr = G::from_usize(__mq.len()); __mq.insert(&__values[..], &[__ptr], G::from_bool(!unconstrained)); __ptr } }; - let __ret: [G; OUT_490] = [__v_12]; - if let Some(result) = record.function_queries[490].get_mut(&inp[..]) { debug_assert_eq!(result.output, &__ret[..]); if !unconstrained { *result.multiplicity += G::ONE; } } else { record.function_queries[490].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained)); }; + let __ret: [G; OUT_486] = [__v_12]; + if let Some(result) = record.function_queries[486].get_mut(&inp[..]) { debug_assert_eq!(result.output, &__ret[..]); if !unconstrained { *result.multiplicity += G::ONE; } } else { record.function_queries[486].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained)); }; return Ok(__ret); }, 5u64 => { - let __r_arr: [G; OUT_499] = { let __args: [G; IN_499] = [__v_3, __v_1]; let __cu = unconstrained; if let Some(result) = record.function_queries[499].get_mut(&__args[..]) { if !__cu && *result.multiplicity == G::ZERO { aiur_fn_499(__args, record, io_buffer, false)? } else { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_499] = unsafe { *(result.output.as_ptr() as *const [G; OUT_499]) }; __ret } } else { aiur_fn_499(__args, record, io_buffer, __cu)? } }; + let __r_arr: [G; OUT_495] = { let __args: [G; IN_495] = [__v_3, __v_1]; let __cu = unconstrained; if let Some(result) = record.function_queries[495].get_mut(&__args[..]) { if !__cu && *result.multiplicity == G::ZERO { aiur_fn_495(__args, record, io_buffer, false)? } else { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_495] = unsafe { *(result.output.as_ptr() as *const [G; OUT_495]) }; __ret } } else { aiur_fn_495(__args, record, io_buffer, __cu)? } }; let __v_6: G = __r_arr[0]; let __v_7: G = G::from_u64(0); let __v_8: G = { let __values: [G; 3] = [__v_7, __v_3, __v_1]; let __mq = record.memory_queries.get_mut(&3).ok_or(ExecError::InvalidMemorySize(3))?; if let Some(result) = __mq.get_mut(&__values[..]) { if !unconstrained { *result.multiplicity += G::ONE; } result.output[0] } else { let __ptr = G::from_usize(__mq.len()); __mq.insert(&__values[..], &[__ptr], G::from_bool(!unconstrained)); __ptr } }; - let __r_arr: [G; OUT_499] = { let __args: [G; IN_499] = [__v_4, __v_8]; let __cu = unconstrained; if let Some(result) = record.function_queries[499].get_mut(&__args[..]) { if !__cu && *result.multiplicity == G::ZERO { aiur_fn_499(__args, record, io_buffer, false)? } else { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_499] = unsafe { *(result.output.as_ptr() as *const [G; OUT_499]) }; __ret } } else { aiur_fn_499(__args, record, io_buffer, __cu)? } }; + let __r_arr: [G; OUT_495] = { let __args: [G; IN_495] = [__v_4, __v_8]; let __cu = unconstrained; if let Some(result) = record.function_queries[495].get_mut(&__args[..]) { if !__cu && *result.multiplicity == G::ZERO { aiur_fn_495(__args, record, io_buffer, false)? } else { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_495] = unsafe { *(result.output.as_ptr() as *const [G; OUT_495]) }; __ret } } else { aiur_fn_495(__args, record, io_buffer, __cu)? } }; let __v_9: G = __r_arr[0]; let __v_10: G = G::from_u64(1); - let __r_arr: [G; OUT_332] = { let __args: [G; IN_332] = [__v_6, __v_9]; let __cu = unconstrained; if let Some(result) = record.function_queries[332].get_mut(&__args[..]) { if !__cu && *result.multiplicity == G::ZERO { aiur_fn_332(__args, record, io_buffer, false)? } else { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_332] = unsafe { *(result.output.as_ptr() as *const [G; OUT_332]) }; __ret } } else { aiur_fn_332(__args, record, io_buffer, __cu)? } }; + let __r_arr: [G; OUT_328] = { let __args: [G; IN_328] = [__v_6, __v_9]; let __cu = unconstrained; if let Some(result) = record.function_queries[328].get_mut(&__args[..]) { if !__cu && *result.multiplicity == G::ZERO { aiur_fn_328(__args, record, io_buffer, false)? } else { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_328] = unsafe { *(result.output.as_ptr() as *const [G; OUT_328]) }; __ret } } else { aiur_fn_328(__args, record, io_buffer, __cu)? } }; let __v_11: G = __r_arr[0]; let __v_12: G = G::from_u64(0); let __v_13: G = { let __values: [G; 4] = [__v_10, __v_11, __v_12, __v_12]; let __mq = record.memory_queries.get_mut(&4).ok_or(ExecError::InvalidMemorySize(4))?; if let Some(result) = __mq.get_mut(&__values[..]) { if !unconstrained { *result.multiplicity += G::ONE; } result.output[0] } else { let __ptr = G::from_usize(__mq.len()); __mq.insert(&__values[..], &[__ptr], G::from_bool(!unconstrained)); __ptr } }; - let __ret: [G; OUT_490] = [__v_13]; - if let Some(result) = record.function_queries[490].get_mut(&inp[..]) { debug_assert_eq!(result.output, &__ret[..]); if !unconstrained { *result.multiplicity += G::ONE; } } else { record.function_queries[490].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained)); }; + let __ret: [G; OUT_486] = [__v_13]; + if let Some(result) = record.function_queries[486].get_mut(&inp[..]) { debug_assert_eq!(result.output, &__ret[..]); if !unconstrained { *result.multiplicity += G::ONE; } } else { record.function_queries[486].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained)); }; return Ok(__ret); }, 6u64 => { - let __r_arr: [G; OUT_499] = { let __args: [G; IN_499] = [__v_3, __v_1]; let __cu = unconstrained; if let Some(result) = record.function_queries[499].get_mut(&__args[..]) { if !__cu && *result.multiplicity == G::ZERO { aiur_fn_499(__args, record, io_buffer, false)? } else { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_499] = unsafe { *(result.output.as_ptr() as *const [G; OUT_499]) }; __ret } } else { aiur_fn_499(__args, record, io_buffer, __cu)? } }; + let __r_arr: [G; OUT_495] = { let __args: [G; IN_495] = [__v_3, __v_1]; let __cu = unconstrained; if let Some(result) = record.function_queries[495].get_mut(&__args[..]) { if !__cu && *result.multiplicity == G::ZERO { aiur_fn_495(__args, record, io_buffer, false)? } else { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_495] = unsafe { *(result.output.as_ptr() as *const [G; OUT_495]) }; __ret } } else { aiur_fn_495(__args, record, io_buffer, __cu)? } }; let __v_6: G = __r_arr[0]; - let __r_arr: [G; OUT_500] = { let __args: [G; IN_500] = [__v_4, __v_3, __v_1]; let __cu = unconstrained; if let Some(result) = record.function_queries[500].get_mut(&__args[..]) { if !__cu && *result.multiplicity == G::ZERO { aiur_fn_500(__args, record, io_buffer, false)? } else { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_500] = unsafe { *(result.output.as_ptr() as *const [G; OUT_500]) }; __ret } } else { aiur_fn_500(__args, record, io_buffer, __cu)? } }; + let __r_arr: [G; OUT_496] = { let __args: [G; IN_496] = [__v_4, __v_3, __v_1]; let __cu = unconstrained; if let Some(result) = record.function_queries[496].get_mut(&__args[..]) { if !__cu && *result.multiplicity == G::ZERO { aiur_fn_496(__args, record, io_buffer, false)? } else { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_496] = unsafe { *(result.output.as_ptr() as *const [G; OUT_496]) }; __ret } } else { aiur_fn_496(__args, record, io_buffer, __cu)? } }; let __v_7: G = G::from_u64(0); - let __r_arr: [G; OUT_368] = { let __args: [G; IN_368] = [__v_5, __v_4, __v_7]; let __cu = unconstrained; if let Some(result) = record.function_queries[368].get_mut(&__args[..]) { if !__cu && *result.multiplicity == G::ZERO { aiur_fn_368(__args, record, io_buffer, false)? } else { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_368] = unsafe { *(result.output.as_ptr() as *const [G; OUT_368]) }; __ret } } else { aiur_fn_368(__args, record, io_buffer, __cu)? } }; + let __r_arr: [G; OUT_364] = { let __args: [G; IN_364] = [__v_5, __v_4, __v_7]; let __cu = unconstrained; if let Some(result) = record.function_queries[364].get_mut(&__args[..]) { if !__cu && *result.multiplicity == G::ZERO { aiur_fn_364(__args, record, io_buffer, false)? } else { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_364] = unsafe { *(result.output.as_ptr() as *const [G; OUT_364]) }; __ret } } else { aiur_fn_364(__args, record, io_buffer, __cu)? } }; let __v_8: G = __r_arr[0]; - let __r_arr: [G; OUT_488] = { let __args: [G; IN_488] = [__v_8, __v_1]; let __cu = unconstrained; if let Some(result) = record.function_queries[488].get_mut(&__args[..]) { if !__cu && *result.multiplicity == G::ZERO { aiur_fn_488(__args, record, io_buffer, false)? } else { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_488] = unsafe { *(result.output.as_ptr() as *const [G; OUT_488]) }; __ret } } else { aiur_fn_488(__args, record, io_buffer, __cu)? } }; + let __r_arr: [G; OUT_484] = { let __args: [G; IN_484] = [__v_8, __v_1]; let __cu = unconstrained; if let Some(result) = record.function_queries[484].get_mut(&__args[..]) { if !__cu && *result.multiplicity == G::ZERO { aiur_fn_484(__args, record, io_buffer, false)? } else { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_484] = unsafe { *(result.output.as_ptr() as *const [G; OUT_484]) }; __ret } } else { aiur_fn_484(__args, record, io_buffer, __cu)? } }; let __v_9: G = __r_arr[0]; - let __ret: [G; OUT_490] = [__v_9]; - if let Some(result) = record.function_queries[490].get_mut(&inp[..]) { debug_assert_eq!(result.output, &__ret[..]); if !unconstrained { *result.multiplicity += G::ONE; } } else { record.function_queries[490].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained)); }; + let __ret: [G; OUT_486] = [__v_9]; + if let Some(result) = record.function_queries[486].get_mut(&inp[..]) { debug_assert_eq!(result.output, &__ret[..]); if !unconstrained { *result.multiplicity += G::ONE; } } else { record.function_queries[486].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained)); }; return Ok(__ret); }, 7u64 => { - let __r_arr: [G; OUT_492] = { let __args: [G; IN_492] = [__v_3, __v_4]; let __cu = unconstrained; if let Some(result) = record.function_queries[492].get_mut(&__args[..]) { if !__cu && *result.multiplicity == G::ZERO { aiur_fn_492(__args, record, io_buffer, false)? } else { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_492] = unsafe { *(result.output.as_ptr() as *const [G; OUT_492]) }; __ret } } else { aiur_fn_492(__args, record, io_buffer, __cu)? } }; + let __r_arr: [G; OUT_488] = { let __args: [G; IN_488] = [__v_3, __v_4]; let __cu = unconstrained; if let Some(result) = record.function_queries[488].get_mut(&__args[..]) { if !__cu && *result.multiplicity == G::ZERO { aiur_fn_488(__args, record, io_buffer, false)? } else { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_488] = unsafe { *(result.output.as_ptr() as *const [G; OUT_488]) }; __ret } } else { aiur_fn_488(__args, record, io_buffer, __cu)? } }; let __v_6: G = __r_arr[0]; - let __ret: [G; OUT_490] = [__v_6]; - if let Some(result) = record.function_queries[490].get_mut(&inp[..]) { debug_assert_eq!(result.output, &__ret[..]); if !unconstrained { *result.multiplicity += G::ONE; } } else { record.function_queries[490].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained)); }; + let __ret: [G; OUT_486] = [__v_6]; + if let Some(result) = record.function_queries[486].get_mut(&inp[..]) { debug_assert_eq!(result.output, &__ret[..]); if !unconstrained { *result.multiplicity += G::ONE; } } else { record.function_queries[486].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained)); }; return Ok(__ret); }, 8u64 => { - let __r_arr: [G; OUT_498] = { let __args: [G; IN_498] = [__v_3, __v_4, __v_5, __v_1]; let __cu = unconstrained; if let Some(result) = record.function_queries[498].get_mut(&__args[..]) { if !__cu && *result.multiplicity == G::ZERO { aiur_fn_498(__args, record, io_buffer, false)? } else { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_498] = unsafe { *(result.output.as_ptr() as *const [G; OUT_498]) }; __ret } } else { aiur_fn_498(__args, record, io_buffer, __cu)? } }; + let __r_arr: [G; OUT_494] = { let __args: [G; IN_494] = [__v_3, __v_4, __v_5, __v_1]; let __cu = unconstrained; if let Some(result) = record.function_queries[494].get_mut(&__args[..]) { if !__cu && *result.multiplicity == G::ZERO { aiur_fn_494(__args, record, io_buffer, false)? } else { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_494] = unsafe { *(result.output.as_ptr() as *const [G; OUT_494]) }; __ret } } else { aiur_fn_494(__args, record, io_buffer, __cu)? } }; let __v_6: G = __r_arr[0]; - let __ret: [G; OUT_490] = [__v_6]; - if let Some(result) = record.function_queries[490].get_mut(&inp[..]) { debug_assert_eq!(result.output, &__ret[..]); if !unconstrained { *result.multiplicity += G::ONE; } } else { record.function_queries[490].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained)); }; + let __ret: [G; OUT_486] = [__v_6]; + if let Some(result) = record.function_queries[486].get_mut(&inp[..]) { debug_assert_eq!(result.output, &__ret[..]); if !unconstrained { *result.multiplicity += G::ONE; } } else { record.function_queries[486].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained)); }; return Ok(__ret); }, _ => { @@ -43647,15 +43363,15 @@ fn aiur_fn_490( }) } -const INPUT_SIZE_491: usize = 4; -const IN_491: usize = 4; -const OUT_491: usize = 1; -fn aiur_fn_491( - inp: [G; IN_491], +const INPUT_SIZE_487: usize = 4; +const IN_487: usize = 4; +const OUT_487: usize = 1; +fn aiur_fn_487( + inp: [G; IN_487], record: &mut QueryRecord, io_buffer: &mut IOBuffer, unconstrained: bool, -) -> Result<[G; OUT_491], ExecError> { +) -> Result<[G; OUT_487], ExecError> { stacker::maybe_grow(64 * 1024, 4 * 1024 * 1024, || { let __v_0: G = inp[0]; let __v_1: G = inp[1]; @@ -43667,20 +43383,20 @@ fn aiur_fn_491( let __v_6: G = __loaded[2]; match __v_4.as_canonical_u64() { 1u64 => { - let __r_arr: [G; OUT_764] = { let __args: [G; IN_764] = [__v_2]; let __cu = unconstrained; if let Some(result) = record.function_queries[764].get_mut(&__args[..]) { if !__cu && *result.multiplicity == G::ZERO { aiur_fn_764(__args, record, io_buffer, false)? } else { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_764] = unsafe { *(result.output.as_ptr() as *const [G; OUT_764]) }; __ret } } else { aiur_fn_764(__args, record, io_buffer, __cu)? } }; + let __r_arr: [G; OUT_760] = { let __args: [G; IN_760] = [__v_2]; let __cu = unconstrained; if let Some(result) = record.function_queries[760].get_mut(&__args[..]) { if !__cu && *result.multiplicity == G::ZERO { aiur_fn_760(__args, record, io_buffer, false)? } else { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_760] = unsafe { *(result.output.as_ptr() as *const [G; OUT_760]) }; __ret } } else { aiur_fn_760(__args, record, io_buffer, __cu)? } }; let __v_7: G = __r_arr[0]; match __v_7.as_canonical_u64() { 0u64 => { - let __ret: [G; OUT_491] = [__v_0]; - if let Some(result) = record.function_queries[491].get_mut(&inp[..]) { debug_assert_eq!(result.output, &__ret[..]); if !unconstrained { *result.multiplicity += G::ONE; } } else { record.function_queries[491].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained)); }; + let __ret: [G; OUT_487] = [__v_0]; + if let Some(result) = record.function_queries[487].get_mut(&inp[..]) { debug_assert_eq!(result.output, &__ret[..]); if !unconstrained { *result.multiplicity += G::ONE; } } else { record.function_queries[487].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained)); }; return Ok(__ret); }, _ => { let __v_8: G = G::from_u64(0); - let __r_arr: [G; OUT_372] = { let __args: [G; IN_372] = [__v_0, __v_2, __v_8]; let __cu = unconstrained; if let Some(result) = record.function_queries[372].get_mut(&__args[..]) { if !__cu && *result.multiplicity == G::ZERO { aiur_fn_372(__args, record, io_buffer, false)? } else { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_372] = unsafe { *(result.output.as_ptr() as *const [G; OUT_372]) }; __ret } } else { aiur_fn_372(__args, record, io_buffer, __cu)? } }; + let __r_arr: [G; OUT_368] = { let __args: [G; IN_368] = [__v_0, __v_2, __v_8]; let __cu = unconstrained; if let Some(result) = record.function_queries[368].get_mut(&__args[..]) { if !__cu && *result.multiplicity == G::ZERO { aiur_fn_368(__args, record, io_buffer, false)? } else { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_368] = unsafe { *(result.output.as_ptr() as *const [G; OUT_368]) }; __ret } } else { aiur_fn_368(__args, record, io_buffer, __cu)? } }; let __v_9: G = __r_arr[0]; - let __ret: [G; OUT_491] = [__v_9]; - if let Some(result) = record.function_queries[491].get_mut(&inp[..]) { debug_assert_eq!(result.output, &__ret[..]); if !unconstrained { *result.multiplicity += G::ONE; } } else { record.function_queries[491].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained)); }; + let __ret: [G; OUT_487] = [__v_9]; + if let Some(result) = record.function_queries[487].get_mut(&inp[..]) { debug_assert_eq!(result.output, &__ret[..]); if !unconstrained { *result.multiplicity += G::ONE; } } else { record.function_queries[487].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained)); }; return Ok(__ret); }, } @@ -43693,7 +43409,7 @@ fn aiur_fn_491( let __v_10: G = __loaded[3]; match __v_7.as_canonical_u64() { 5u64 => { - let __r_arr: [G; OUT_764] = { let __args: [G; IN_764] = [__v_2]; let __cu = unconstrained; if let Some(result) = record.function_queries[764].get_mut(&__args[..]) { if !__cu && *result.multiplicity == G::ZERO { aiur_fn_764(__args, record, io_buffer, false)? } else { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_764] = unsafe { *(result.output.as_ptr() as *const [G; OUT_764]) }; __ret } } else { aiur_fn_764(__args, record, io_buffer, __cu)? } }; + let __r_arr: [G; OUT_760] = { let __args: [G; IN_760] = [__v_2]; let __cu = unconstrained; if let Some(result) = record.function_queries[760].get_mut(&__args[..]) { if !__cu && *result.multiplicity == G::ZERO { aiur_fn_760(__args, record, io_buffer, false)? } else { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_760] = unsafe { *(result.output.as_ptr() as *const [G; OUT_760]) }; __ret } } else { aiur_fn_760(__args, record, io_buffer, __cu)? } }; let __v_11: G = __r_arr[0]; let __mc_out___mc_0: [G; 1] = '__mc_0: { match __v_11.as_canonical_u64() { 0u64 => { @@ -43701,24 +43417,24 @@ fn aiur_fn_491( }, _ => { let __v_12: G = G::from_u64(0); - let __r_arr: [G; OUT_372] = { let __args: [G; IN_372] = [__v_8, __v_2, __v_12]; let __cu = unconstrained; if let Some(result) = record.function_queries[372].get_mut(&__args[..]) { if !__cu && *result.multiplicity == G::ZERO { aiur_fn_372(__args, record, io_buffer, false)? } else { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_372] = unsafe { *(result.output.as_ptr() as *const [G; OUT_372]) }; __ret } } else { aiur_fn_372(__args, record, io_buffer, __cu)? } }; + let __r_arr: [G; OUT_368] = { let __args: [G; IN_368] = [__v_8, __v_2, __v_12]; let __cu = unconstrained; if let Some(result) = record.function_queries[368].get_mut(&__args[..]) { if !__cu && *result.multiplicity == G::ZERO { aiur_fn_368(__args, record, io_buffer, false)? } else { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_368] = unsafe { *(result.output.as_ptr() as *const [G; OUT_368]) }; __ret } } else { aiur_fn_368(__args, record, io_buffer, __cu)? } }; let __v_13: G = __r_arr[0]; break '__mc_0 [__v_13]; }, } }; let __v_12: G = __mc_out___mc_0[0]; - let __r_arr: [G; OUT_500] = { let __args: [G; IN_500] = [__v_5, __v_12, __v_3]; let __cu = unconstrained; if let Some(result) = record.function_queries[500].get_mut(&__args[..]) { if !__cu && *result.multiplicity == G::ZERO { aiur_fn_500(__args, record, io_buffer, false)? } else { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_500] = unsafe { *(result.output.as_ptr() as *const [G; OUT_500]) }; __ret } } else { aiur_fn_500(__args, record, io_buffer, __cu)? } }; + let __r_arr: [G; OUT_496] = { let __args: [G; IN_496] = [__v_5, __v_12, __v_3]; let __cu = unconstrained; if let Some(result) = record.function_queries[496].get_mut(&__args[..]) { if !__cu && *result.multiplicity == G::ZERO { aiur_fn_496(__args, record, io_buffer, false)? } else { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_496] = unsafe { *(result.output.as_ptr() as *const [G; OUT_496]) }; __ret } } else { aiur_fn_496(__args, record, io_buffer, __cu)? } }; let __v_13: G = G::from_u64(0); let __v_14: G = { let __values: [G; 3] = [__v_13, __v_5, __v_2]; let __mq = record.memory_queries.get_mut(&3).ok_or(ExecError::InvalidMemorySize(3))?; if let Some(result) = __mq.get_mut(&__values[..]) { if !unconstrained { *result.multiplicity += G::ONE; } result.output[0] } else { let __ptr = G::from_usize(__mq.len()); __mq.insert(&__values[..], &[__ptr], G::from_bool(!unconstrained)); __ptr } }; - let __r_arr: [G; OUT_491] = { let __args: [G; IN_491] = [__v_9, __v_6, __v_14, __v_3]; let __cu = unconstrained; if let Some(result) = record.function_queries[491].get_mut(&__args[..]) { if !__cu && *result.multiplicity == G::ZERO { aiur_fn_491(__args, record, io_buffer, false)? } else { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_491] = unsafe { *(result.output.as_ptr() as *const [G; OUT_491]) }; __ret } } else { aiur_fn_491(__args, record, io_buffer, __cu)? } }; + let __r_arr: [G; OUT_487] = { let __args: [G; IN_487] = [__v_9, __v_6, __v_14, __v_3]; let __cu = unconstrained; if let Some(result) = record.function_queries[487].get_mut(&__args[..]) { if !__cu && *result.multiplicity == G::ZERO { aiur_fn_487(__args, record, io_buffer, false)? } else { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_487] = unsafe { *(result.output.as_ptr() as *const [G; OUT_487]) }; __ret } } else { aiur_fn_487(__args, record, io_buffer, __cu)? } }; let __v_15: G = __r_arr[0]; - let __ret: [G; OUT_491] = [__v_15]; - if let Some(result) = record.function_queries[491].get_mut(&inp[..]) { debug_assert_eq!(result.output, &__ret[..]); if !unconstrained { *result.multiplicity += G::ONE; } } else { record.function_queries[491].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained)); }; + let __ret: [G; OUT_487] = [__v_15]; + if let Some(result) = record.function_queries[487].get_mut(&inp[..]) { debug_assert_eq!(result.output, &__ret[..]); if !unconstrained { *result.multiplicity += G::ONE; } } else { record.function_queries[487].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained)); }; return Ok(__ret); }, _ => { - let __r_arr: [G; OUT_764] = { let __args: [G; IN_764] = [__v_2]; let __cu = unconstrained; if let Some(result) = record.function_queries[764].get_mut(&__args[..]) { if !__cu && *result.multiplicity == G::ZERO { aiur_fn_764(__args, record, io_buffer, false)? } else { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_764] = unsafe { *(result.output.as_ptr() as *const [G; OUT_764]) }; __ret } } else { aiur_fn_764(__args, record, io_buffer, __cu)? } }; + let __r_arr: [G; OUT_760] = { let __args: [G; IN_760] = [__v_2]; let __cu = unconstrained; if let Some(result) = record.function_queries[760].get_mut(&__args[..]) { if !__cu && *result.multiplicity == G::ZERO { aiur_fn_760(__args, record, io_buffer, false)? } else { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_760] = unsafe { *(result.output.as_ptr() as *const [G; OUT_760]) }; __ret } } else { aiur_fn_760(__args, record, io_buffer, __cu)? } }; let __v_11: G = __r_arr[0]; let __mc_out___mc_1: [G; 1] = '__mc_1: { match __v_11.as_canonical_u64() { 0u64 => { @@ -43726,14 +43442,14 @@ fn aiur_fn_491( }, _ => { let __v_12: G = G::from_u64(0); - let __r_arr: [G; OUT_372] = { let __args: [G; IN_372] = [__v_0, __v_2, __v_12]; let __cu = unconstrained; if let Some(result) = record.function_queries[372].get_mut(&__args[..]) { if !__cu && *result.multiplicity == G::ZERO { aiur_fn_372(__args, record, io_buffer, false)? } else { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_372] = unsafe { *(result.output.as_ptr() as *const [G; OUT_372]) }; __ret } } else { aiur_fn_372(__args, record, io_buffer, __cu)? } }; + let __r_arr: [G; OUT_368] = { let __args: [G; IN_368] = [__v_0, __v_2, __v_12]; let __cu = unconstrained; if let Some(result) = record.function_queries[368].get_mut(&__args[..]) { if !__cu && *result.multiplicity == G::ZERO { aiur_fn_368(__args, record, io_buffer, false)? } else { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_368] = unsafe { *(result.output.as_ptr() as *const [G; OUT_368]) }; __ret } } else { aiur_fn_368(__args, record, io_buffer, __cu)? } }; let __v_13: G = __r_arr[0]; break '__mc_1 [__v_13]; }, } }; let __v_12: G = __mc_out___mc_1[0]; - let __r_arr: [G; OUT_418] = { let __args: [G; IN_418] = [__v_12, __v_3]; let __cu = unconstrained; if let Some(result) = record.function_queries[418].get_mut(&__args[..]) { if !__cu && *result.multiplicity == G::ZERO { aiur_fn_418(__args, record, io_buffer, false)? } else { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_418] = unsafe { *(result.output.as_ptr() as *const [G; OUT_418]) }; __ret } } else { aiur_fn_418(__args, record, io_buffer, __cu)? } }; + let __r_arr: [G; OUT_414] = { let __args: [G; IN_414] = [__v_12, __v_3]; let __cu = unconstrained; if let Some(result) = record.function_queries[414].get_mut(&__args[..]) { if !__cu && *result.multiplicity == G::ZERO { aiur_fn_414(__args, record, io_buffer, false)? } else { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_414] = unsafe { *(result.output.as_ptr() as *const [G; OUT_414]) }; __ret } } else { aiur_fn_414(__args, record, io_buffer, __cu)? } }; let __v_13: G = __r_arr[0]; let __loaded: [G; 4] = { let __mq = record.memory_queries.get_mut(&4).ok_or(ExecError::InvalidMemorySize(4))?; let __ptr_u64 = __v_13.as_canonical_u64(); let __ptr_usize = usize::try_from(__ptr_u64).ok().ok_or(ExecError::PointerTooLarge(__ptr_u64))?; let (__args, __mult) = __mq.get_index_mut(__ptr_usize).ok_or(ExecError::UnboundPointer { ptr: __ptr_u64, size: 4 })?; if !unconstrained { *__mult += G::ONE; } let __arr: [G; 4] = __args[..4].try_into().unwrap(); __arr }; let __v_14: G = __loaded[0]; @@ -43742,16 +43458,16 @@ fn aiur_fn_491( let __v_17: G = __loaded[3]; match __v_14.as_canonical_u64() { 5u64 => { - let __r_arr: [G; OUT_500] = { let __args: [G; IN_500] = [__v_5, __v_15, __v_3]; let __cu = unconstrained; if let Some(result) = record.function_queries[500].get_mut(&__args[..]) { if !__cu && *result.multiplicity == G::ZERO { aiur_fn_500(__args, record, io_buffer, false)? } else { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_500] = unsafe { *(result.output.as_ptr() as *const [G; OUT_500]) }; __ret } } else { aiur_fn_500(__args, record, io_buffer, __cu)? } }; + let __r_arr: [G; OUT_496] = { let __args: [G; IN_496] = [__v_5, __v_15, __v_3]; let __cu = unconstrained; if let Some(result) = record.function_queries[496].get_mut(&__args[..]) { if !__cu && *result.multiplicity == G::ZERO { aiur_fn_496(__args, record, io_buffer, false)? } else { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_496] = unsafe { *(result.output.as_ptr() as *const [G; OUT_496]) }; __ret } } else { aiur_fn_496(__args, record, io_buffer, __cu)? } }; let __v_18: G = G::from_u64(0); let __v_19: G = G::from_u64(1); let __v_20: G = G::from_u64(1); let __v_21: G = { let __values: [G; 3] = [__v_19, __v_20, __v_20]; let __mq = record.memory_queries.get_mut(&3).ok_or(ExecError::InvalidMemorySize(3))?; if let Some(result) = __mq.get_mut(&__values[..]) { if !unconstrained { *result.multiplicity += G::ONE; } result.output[0] } else { let __ptr = G::from_usize(__mq.len()); __mq.insert(&__values[..], &[__ptr], G::from_bool(!unconstrained)); __ptr } }; let __v_22: G = { let __values: [G; 3] = [__v_18, __v_5, __v_21]; let __mq = record.memory_queries.get_mut(&3).ok_or(ExecError::InvalidMemorySize(3))?; if let Some(result) = __mq.get_mut(&__values[..]) { if !unconstrained { *result.multiplicity += G::ONE; } result.output[0] } else { let __ptr = G::from_usize(__mq.len()); __mq.insert(&__values[..], &[__ptr], G::from_bool(!unconstrained)); __ptr } }; - let __r_arr: [G; OUT_491] = { let __args: [G; IN_491] = [__v_16, __v_6, __v_22, __v_3]; let __cu = unconstrained; if let Some(result) = record.function_queries[491].get_mut(&__args[..]) { if !__cu && *result.multiplicity == G::ZERO { aiur_fn_491(__args, record, io_buffer, false)? } else { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_491] = unsafe { *(result.output.as_ptr() as *const [G; OUT_491]) }; __ret } } else { aiur_fn_491(__args, record, io_buffer, __cu)? } }; + let __r_arr: [G; OUT_487] = { let __args: [G; IN_487] = [__v_16, __v_6, __v_22, __v_3]; let __cu = unconstrained; if let Some(result) = record.function_queries[487].get_mut(&__args[..]) { if !__cu && *result.multiplicity == G::ZERO { aiur_fn_487(__args, record, io_buffer, false)? } else { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_487] = unsafe { *(result.output.as_ptr() as *const [G; OUT_487]) }; __ret } } else { aiur_fn_487(__args, record, io_buffer, __cu)? } }; let __v_23: G = __r_arr[0]; - let __ret: [G; OUT_491] = [__v_23]; - if let Some(result) = record.function_queries[491].get_mut(&inp[..]) { debug_assert_eq!(result.output, &__ret[..]); if !unconstrained { *result.multiplicity += G::ONE; } } else { record.function_queries[491].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained)); }; + let __ret: [G; OUT_487] = [__v_23]; + if let Some(result) = record.function_queries[487].get_mut(&inp[..]) { debug_assert_eq!(result.output, &__ret[..]); if !unconstrained { *result.multiplicity += G::ONE; } } else { record.function_queries[487].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained)); }; return Ok(__ret); }, _ => { @@ -43768,43 +43484,43 @@ fn aiur_fn_491( }) } -const INPUT_SIZE_492: usize = 2; -const IN_492: usize = 2; -const OUT_492: usize = 1; -fn aiur_fn_492( - inp: [G; IN_492], +const INPUT_SIZE_488: usize = 2; +const IN_488: usize = 2; +const OUT_488: usize = 1; +fn aiur_fn_488( + inp: [G; IN_488], record: &mut QueryRecord, io_buffer: &mut IOBuffer, unconstrained: bool, -) -> Result<[G; OUT_492], ExecError> { +) -> Result<[G; OUT_488], ExecError> { stacker::maybe_grow(64 * 1024, 4 * 1024 * 1024, || { let __v_0: G = inp[0]; let __v_1: G = inp[1]; match __v_0.as_canonical_u64() { 0u64 => { let __v_2: G = G::from_u64(2); - let __r_arr: [G; OUT_382] = { let __args: [G; IN_382] = []; let __cu = unconstrained; if let Some(result) = record.function_queries[382].get_mut(&__args[..]) { if !__cu && *result.multiplicity == G::ZERO { aiur_fn_382(__args, record, io_buffer, false)? } else { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_382] = unsafe { *(result.output.as_ptr() as *const [G; OUT_382]) }; __ret } } else { aiur_fn_382(__args, record, io_buffer, __cu)? } }; + let __r_arr: [G; OUT_378] = { let __args: [G; IN_378] = []; let __cu = unconstrained; if let Some(result) = record.function_queries[378].get_mut(&__args[..]) { if !__cu && *result.multiplicity == G::ZERO { aiur_fn_378(__args, record, io_buffer, false)? } else { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_378] = unsafe { *(result.output.as_ptr() as *const [G; OUT_378]) }; __ret } } else { aiur_fn_378(__args, record, io_buffer, __cu)? } }; let __v_3: G = __r_arr[0]; let __v_4: G = G::from_u64(1); let __v_5: G = G::from_u64(1); let __v_6: G = { let __values: [G; 3] = [__v_4, __v_5, __v_5]; let __mq = record.memory_queries.get_mut(&3).ok_or(ExecError::InvalidMemorySize(3))?; if let Some(result) = __mq.get_mut(&__values[..]) { if !unconstrained { *result.multiplicity += G::ONE; } result.output[0] } else { let __ptr = G::from_usize(__mq.len()); __mq.insert(&__values[..], &[__ptr], G::from_bool(!unconstrained)); __ptr } }; let __v_7: G = G::from_u64(0); let __v_8: G = { let __values: [G; 4] = [__v_2, __v_3, __v_6, __v_7]; let __mq = record.memory_queries.get_mut(&4).ok_or(ExecError::InvalidMemorySize(4))?; if let Some(result) = __mq.get_mut(&__values[..]) { if !unconstrained { *result.multiplicity += G::ONE; } result.output[0] } else { let __ptr = G::from_usize(__mq.len()); __mq.insert(&__values[..], &[__ptr], G::from_bool(!unconstrained)); __ptr } }; - let __ret: [G; OUT_492] = [__v_8]; - if let Some(result) = record.function_queries[492].get_mut(&inp[..]) { debug_assert_eq!(result.output, &__ret[..]); if !unconstrained { *result.multiplicity += G::ONE; } } else { record.function_queries[492].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained)); }; + let __ret: [G; OUT_488] = [__v_8]; + if let Some(result) = record.function_queries[488].get_mut(&inp[..]) { debug_assert_eq!(result.output, &__ret[..]); if !unconstrained { *result.multiplicity += G::ONE; } } else { record.function_queries[488].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained)); }; return Ok(__ret); }, 1u64 => { let __v_2: G = G::from_u64(2); - let __r_arr: [G; OUT_218] = { let __args: [G; IN_218] = []; let __cu = unconstrained; if let Some(result) = record.function_queries[218].get_mut(&__args[..]) { if !__cu && *result.multiplicity == G::ZERO { aiur_fn_218(__args, record, io_buffer, false)? } else { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_218] = unsafe { *(result.output.as_ptr() as *const [G; OUT_218]) }; __ret } } else { aiur_fn_218(__args, record, io_buffer, __cu)? } }; + let __r_arr: [G; OUT_214] = { let __args: [G; IN_214] = []; let __cu = unconstrained; if let Some(result) = record.function_queries[214].get_mut(&__args[..]) { if !__cu && *result.multiplicity == G::ZERO { aiur_fn_214(__args, record, io_buffer, false)? } else { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_214] = unsafe { *(result.output.as_ptr() as *const [G; OUT_214]) }; __ret } } else { aiur_fn_214(__args, record, io_buffer, __cu)? } }; let __v_3: G = __r_arr[0]; let __v_4: G = G::from_u64(1); let __v_5: G = G::from_u64(1); let __v_6: G = { let __values: [G; 3] = [__v_4, __v_5, __v_5]; let __mq = record.memory_queries.get_mut(&3).ok_or(ExecError::InvalidMemorySize(3))?; if let Some(result) = __mq.get_mut(&__values[..]) { if !unconstrained { *result.multiplicity += G::ONE; } result.output[0] } else { let __ptr = G::from_usize(__mq.len()); __mq.insert(&__values[..], &[__ptr], G::from_bool(!unconstrained)); __ptr } }; let __v_7: G = G::from_u64(0); let __v_8: G = { let __values: [G; 4] = [__v_2, __v_3, __v_6, __v_7]; let __mq = record.memory_queries.get_mut(&4).ok_or(ExecError::InvalidMemorySize(4))?; if let Some(result) = __mq.get_mut(&__values[..]) { if !unconstrained { *result.multiplicity += G::ONE; } result.output[0] } else { let __ptr = G::from_usize(__mq.len()); __mq.insert(&__values[..], &[__ptr], G::from_bool(!unconstrained)); __ptr } }; - let __ret: [G; OUT_492] = [__v_8]; - if let Some(result) = record.function_queries[492].get_mut(&inp[..]) { debug_assert_eq!(result.output, &__ret[..]); if !unconstrained { *result.multiplicity += G::ONE; } } else { record.function_queries[492].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained)); }; + let __ret: [G; OUT_488] = [__v_8]; + if let Some(result) = record.function_queries[488].get_mut(&inp[..]) { debug_assert_eq!(result.output, &__ret[..]); if !unconstrained { *result.multiplicity += G::ONE; } } else { record.function_queries[488].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained)); }; return Ok(__ret); }, _ => { @@ -43814,23 +43530,23 @@ fn aiur_fn_492( }) } -const INPUT_SIZE_493: usize = 4; -const IN_493: usize = 4; -const OUT_493: usize = 1; -fn aiur_fn_493( - inp: [G; IN_493], +const INPUT_SIZE_489: usize = 4; +const IN_489: usize = 4; +const OUT_489: usize = 1; +fn aiur_fn_489( + inp: [G; IN_489], record: &mut QueryRecord, io_buffer: &mut IOBuffer, unconstrained: bool, -) -> Result<[G; OUT_493], ExecError> { +) -> Result<[G; OUT_489], ExecError> { stacker::maybe_grow(64 * 1024, 4 * 1024 * 1024, || { let __v_0: G = inp[0]; let __v_1: G = inp[1]; let __v_2: G = inp[2]; let __v_3: G = inp[3]; - let __r_arr: [G; OUT_336] = { let __args: [G; IN_336] = [__v_0, __v_1]; let __cu = unconstrained; if let Some(result) = record.function_queries[336].get_mut(&__args[..]) { if !__cu && *result.multiplicity == G::ZERO { aiur_fn_336(__args, record, io_buffer, false)? } else { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_336] = unsafe { *(result.output.as_ptr() as *const [G; OUT_336]) }; __ret } } else { aiur_fn_336(__args, record, io_buffer, __cu)? } }; + let __r_arr: [G; OUT_332] = { let __args: [G; IN_332] = [__v_0, __v_1]; let __cu = unconstrained; if let Some(result) = record.function_queries[332].get_mut(&__args[..]) { if !__cu && *result.multiplicity == G::ZERO { aiur_fn_332(__args, record, io_buffer, false)? } else { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_332] = unsafe { *(result.output.as_ptr() as *const [G; OUT_332]) }; __ret } } else { aiur_fn_332(__args, record, io_buffer, __cu)? } }; let __v_4: G = __r_arr[0]; - let __r_arr: [G; OUT_494] = { let __args: [G; IN_494] = [__v_4, __v_2, __v_3]; let __cu = unconstrained; if let Some(result) = record.function_queries[494].get_mut(&__args[..]) { if !__cu && *result.multiplicity == G::ZERO { aiur_fn_494(__args, record, io_buffer, false)? } else { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_494] = unsafe { *(result.output.as_ptr() as *const [G; OUT_494]) }; __ret } } else { aiur_fn_494(__args, record, io_buffer, __cu)? } }; + let __r_arr: [G; OUT_490] = { let __args: [G; IN_490] = [__v_4, __v_2, __v_3]; let __cu = unconstrained; if let Some(result) = record.function_queries[490].get_mut(&__args[..]) { if !__cu && *result.multiplicity == G::ZERO { aiur_fn_490(__args, record, io_buffer, false)? } else { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_490] = unsafe { *(result.output.as_ptr() as *const [G; OUT_490]) }; __ret } } else { aiur_fn_490(__args, record, io_buffer, __cu)? } }; let __v_5: G = __r_arr[0]; let __loaded: [G; 4] = { let __mq = record.memory_queries.get_mut(&4).ok_or(ExecError::InvalidMemorySize(4))?; let __ptr_u64 = __v_5.as_canonical_u64(); let __ptr_usize = usize::try_from(__ptr_u64).ok().ok_or(ExecError::PointerTooLarge(__ptr_u64))?; let (__args, __mult) = __mq.get_index_mut(__ptr_usize).ok_or(ExecError::UnboundPointer { ptr: __ptr_u64, size: 4 })?; if !unconstrained { *__mult += G::ONE; } let __arr: [G; 4] = __args[..4].try_into().unwrap(); __arr }; let __v_6: G = __loaded[0]; @@ -43842,10 +43558,10 @@ fn aiur_fn_493( let __v_10: G = G::from_u64(0); let __v_11: G = G::from_u64(0); let __v_12: G = { let __values: [G; 3] = [__v_10, __v_11, __v_11]; let __mq = record.memory_queries.get_mut(&3).ok_or(ExecError::InvalidMemorySize(3))?; if let Some(result) = __mq.get_mut(&__values[..]) { if !unconstrained { *result.multiplicity += G::ONE; } result.output[0] } else { let __ptr = G::from_usize(__mq.len()); __mq.insert(&__values[..], &[__ptr], G::from_bool(!unconstrained)); __ptr } }; - let __r_arr: [G; OUT_324] = { let __args: [G; IN_324] = [__v_7, __v_12]; let __cu = unconstrained; if let Some(result) = record.function_queries[324].get_mut(&__args[..]) { if !__cu && *result.multiplicity == G::ZERO { aiur_fn_324(__args, record, io_buffer, false)? } else { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_324] = unsafe { *(result.output.as_ptr() as *const [G; OUT_324]) }; __ret } } else { aiur_fn_324(__args, record, io_buffer, __cu)? } }; + let __r_arr: [G; OUT_320] = { let __args: [G; IN_320] = [__v_7, __v_12]; let __cu = unconstrained; if let Some(result) = record.function_queries[320].get_mut(&__args[..]) { if !__cu && *result.multiplicity == G::ZERO { aiur_fn_320(__args, record, io_buffer, false)? } else { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_320] = unsafe { *(result.output.as_ptr() as *const [G; OUT_320]) }; __ret } } else { aiur_fn_320(__args, record, io_buffer, __cu)? } }; let __v_13: G = __r_arr[0]; - let __ret: [G; OUT_493] = [__v_13]; - if let Some(result) = record.function_queries[493].get_mut(&inp[..]) { debug_assert_eq!(result.output, &__ret[..]); if !unconstrained { *result.multiplicity += G::ONE; } } else { record.function_queries[493].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained)); }; + let __ret: [G; OUT_489] = [__v_13]; + if let Some(result) = record.function_queries[489].get_mut(&inp[..]) { debug_assert_eq!(result.output, &__ret[..]); if !unconstrained { *result.multiplicity += G::ONE; } } else { record.function_queries[489].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained)); }; return Ok(__ret); }, _ => { @@ -43855,29 +43571,29 @@ fn aiur_fn_493( }) } -const INPUT_SIZE_494: usize = 3; -const IN_494: usize = 3; -const OUT_494: usize = 1; -fn aiur_fn_494( - inp: [G; IN_494], +const INPUT_SIZE_490: usize = 3; +const IN_490: usize = 3; +const OUT_490: usize = 1; +fn aiur_fn_490( + inp: [G; IN_490], record: &mut QueryRecord, io_buffer: &mut IOBuffer, unconstrained: bool, -) -> Result<[G; OUT_494], ExecError> { +) -> Result<[G; OUT_490], ExecError> { stacker::maybe_grow(64 * 1024, 4 * 1024 * 1024, || { let __v_0: G = inp[0]; let __v_1: G = inp[1]; let __v_2: G = inp[2]; match __v_1.as_canonical_u64() { 0u64 => { - let __r_arr: [G; OUT_418] = { let __args: [G; IN_418] = [__v_0, __v_2]; let __cu = unconstrained; if let Some(result) = record.function_queries[418].get_mut(&__args[..]) { if !__cu && *result.multiplicity == G::ZERO { aiur_fn_418(__args, record, io_buffer, false)? } else { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_418] = unsafe { *(result.output.as_ptr() as *const [G; OUT_418]) }; __ret } } else { aiur_fn_418(__args, record, io_buffer, __cu)? } }; + let __r_arr: [G; OUT_414] = { let __args: [G; IN_414] = [__v_0, __v_2]; let __cu = unconstrained; if let Some(result) = record.function_queries[414].get_mut(&__args[..]) { if !__cu && *result.multiplicity == G::ZERO { aiur_fn_414(__args, record, io_buffer, false)? } else { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_414] = unsafe { *(result.output.as_ptr() as *const [G; OUT_414]) }; __ret } } else { aiur_fn_414(__args, record, io_buffer, __cu)? } }; let __v_3: G = __r_arr[0]; - let __ret: [G; OUT_494] = [__v_3]; - if let Some(result) = record.function_queries[494].get_mut(&inp[..]) { debug_assert_eq!(result.output, &__ret[..]); if !unconstrained { *result.multiplicity += G::ONE; } } else { record.function_queries[494].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained)); }; + let __ret: [G; OUT_490] = [__v_3]; + if let Some(result) = record.function_queries[490].get_mut(&inp[..]) { debug_assert_eq!(result.output, &__ret[..]); if !unconstrained { *result.multiplicity += G::ONE; } } else { record.function_queries[490].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained)); }; return Ok(__ret); }, _ => { - let __r_arr: [G; OUT_418] = { let __args: [G; IN_418] = [__v_0, __v_2]; let __cu = unconstrained; if let Some(result) = record.function_queries[418].get_mut(&__args[..]) { if !__cu && *result.multiplicity == G::ZERO { aiur_fn_418(__args, record, io_buffer, false)? } else { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_418] = unsafe { *(result.output.as_ptr() as *const [G; OUT_418]) }; __ret } } else { aiur_fn_418(__args, record, io_buffer, __cu)? } }; + let __r_arr: [G; OUT_414] = { let __args: [G; IN_414] = [__v_0, __v_2]; let __cu = unconstrained; if let Some(result) = record.function_queries[414].get_mut(&__args[..]) { if !__cu && *result.multiplicity == G::ZERO { aiur_fn_414(__args, record, io_buffer, false)? } else { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_414] = unsafe { *(result.output.as_ptr() as *const [G; OUT_414]) }; __ret } } else { aiur_fn_414(__args, record, io_buffer, __cu)? } }; let __v_3: G = __r_arr[0]; let __loaded: [G; 4] = { let __mq = record.memory_queries.get_mut(&4).ok_or(ExecError::InvalidMemorySize(4))?; let __ptr_u64 = __v_3.as_canonical_u64(); let __ptr_usize = usize::try_from(__ptr_u64).ok().ok_or(ExecError::PointerTooLarge(__ptr_u64))?; let (__args, __mult) = __mq.get_index_mut(__ptr_usize).ok_or(ExecError::UnboundPointer { ptr: __ptr_u64, size: 4 })?; if !unconstrained { *__mult += G::ONE; } let __arr: [G; 4] = __args[..4].try_into().unwrap(); __arr }; let __v_4: G = __loaded[0]; @@ -43890,15 +43606,15 @@ fn aiur_fn_494( let __v_9: G = { let __values: [G; 3] = [__v_8, __v_5, __v_2]; let __mq = record.memory_queries.get_mut(&3).ok_or(ExecError::InvalidMemorySize(3))?; if let Some(result) = __mq.get_mut(&__values[..]) { if !unconstrained { *result.multiplicity += G::ONE; } result.output[0] } else { let __ptr = G::from_usize(__mq.len()); __mq.insert(&__values[..], &[__ptr], G::from_bool(!unconstrained)); __ptr } }; let __v_10: G = G::from_u64(1); let __v_11: G = (__v_1 - __v_10); - let __r_arr: [G; OUT_494] = { let __args: [G; IN_494] = [__v_6, __v_11, __v_9]; let __cu = unconstrained; if let Some(result) = record.function_queries[494].get_mut(&__args[..]) { if !__cu && *result.multiplicity == G::ZERO { aiur_fn_494(__args, record, io_buffer, false)? } else { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_494] = unsafe { *(result.output.as_ptr() as *const [G; OUT_494]) }; __ret } } else { aiur_fn_494(__args, record, io_buffer, __cu)? } }; + let __r_arr: [G; OUT_490] = { let __args: [G; IN_490] = [__v_6, __v_11, __v_9]; let __cu = unconstrained; if let Some(result) = record.function_queries[490].get_mut(&__args[..]) { if !__cu && *result.multiplicity == G::ZERO { aiur_fn_490(__args, record, io_buffer, false)? } else { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_490] = unsafe { *(result.output.as_ptr() as *const [G; OUT_490]) }; __ret } } else { aiur_fn_490(__args, record, io_buffer, __cu)? } }; let __v_12: G = __r_arr[0]; - let __ret: [G; OUT_494] = [__v_12]; - if let Some(result) = record.function_queries[494].get_mut(&inp[..]) { debug_assert_eq!(result.output, &__ret[..]); if !unconstrained { *result.multiplicity += G::ONE; } } else { record.function_queries[494].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained)); }; + let __ret: [G; OUT_490] = [__v_12]; + if let Some(result) = record.function_queries[490].get_mut(&inp[..]) { debug_assert_eq!(result.output, &__ret[..]); if !unconstrained { *result.multiplicity += G::ONE; } } else { record.function_queries[490].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained)); }; return Ok(__ret); }, _ => { - let __ret: [G; OUT_494] = [__v_3]; - if let Some(result) = record.function_queries[494].get_mut(&inp[..]) { debug_assert_eq!(result.output, &__ret[..]); if !unconstrained { *result.multiplicity += G::ONE; } } else { record.function_queries[494].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained)); }; + let __ret: [G; OUT_490] = [__v_3]; + if let Some(result) = record.function_queries[490].get_mut(&inp[..]) { debug_assert_eq!(result.output, &__ret[..]); if !unconstrained { *result.multiplicity += G::ONE; } } else { record.function_queries[490].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained)); }; return Ok(__ret); }, } @@ -43907,54 +43623,54 @@ fn aiur_fn_494( }) } -const INPUT_SIZE_495: usize = 3; -const IN_495: usize = 3; -const OUT_495: usize = 0; -fn aiur_fn_495( - inp: [G; IN_495], +const INPUT_SIZE_491: usize = 3; +const IN_491: usize = 3; +const OUT_491: usize = 0; +fn aiur_fn_491( + inp: [G; IN_491], record: &mut QueryRecord, io_buffer: &mut IOBuffer, unconstrained: bool, -) -> Result<[G; OUT_495], ExecError> { +) -> Result<[G; OUT_491], ExecError> { stacker::maybe_grow(64 * 1024, 4 * 1024 * 1024, || { let __v_0: G = inp[0]; let __v_1: G = inp[1]; let __v_2: G = inp[2]; match __v_0.as_canonical_u64() { 0u64 => { - let __ret: [G; OUT_495] = []; - if let Some(result) = record.function_queries[495].get_mut(&inp[..]) { debug_assert_eq!(result.output, &__ret[..]); if !unconstrained { *result.multiplicity += G::ONE; } } else { record.function_queries[495].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained)); }; + let __ret: [G; OUT_491] = []; + if let Some(result) = record.function_queries[491].get_mut(&inp[..]) { debug_assert_eq!(result.output, &__ret[..]); if !unconstrained { *result.multiplicity += G::ONE; } } else { record.function_queries[491].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained)); }; return Ok(__ret); }, _ => { - let __r_arr: [G; OUT_499] = { let __args: [G; IN_499] = [__v_1, __v_2]; let __cu = unconstrained; if let Some(result) = record.function_queries[499].get_mut(&__args[..]) { if !__cu && *result.multiplicity == G::ZERO { aiur_fn_499(__args, record, io_buffer, false)? } else { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_499] = unsafe { *(result.output.as_ptr() as *const [G; OUT_499]) }; __ret } } else { aiur_fn_499(__args, record, io_buffer, __cu)? } }; + let __r_arr: [G; OUT_495] = { let __args: [G; IN_495] = [__v_1, __v_2]; let __cu = unconstrained; if let Some(result) = record.function_queries[495].get_mut(&__args[..]) { if !__cu && *result.multiplicity == G::ZERO { aiur_fn_495(__args, record, io_buffer, false)? } else { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_495] = unsafe { *(result.output.as_ptr() as *const [G; OUT_495]) }; __ret } } else { aiur_fn_495(__args, record, io_buffer, __cu)? } }; let __v_3: G = __r_arr[0]; let __v_4: G = G::from_u64(0); let __v_5: G = G::from_u64(0); let __v_6: G = { let __values: [G; 3] = [__v_4, __v_5, __v_5]; let __mq = record.memory_queries.get_mut(&3).ok_or(ExecError::InvalidMemorySize(3))?; if let Some(result) = __mq.get_mut(&__values[..]) { if !unconstrained { *result.multiplicity += G::ONE; } result.output[0] } else { let __ptr = G::from_usize(__mq.len()); __mq.insert(&__values[..], &[__ptr], G::from_bool(!unconstrained)); __ptr } }; - let __r_arr: [G; OUT_324] = { let __args: [G; IN_324] = [__v_3, __v_6]; let __cu = unconstrained; if let Some(result) = record.function_queries[324].get_mut(&__args[..]) { if !__cu && *result.multiplicity == G::ZERO { aiur_fn_324(__args, record, io_buffer, false)? } else { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_324] = unsafe { *(result.output.as_ptr() as *const [G; OUT_324]) }; __ret } } else { aiur_fn_324(__args, record, io_buffer, __cu)? } }; + let __r_arr: [G; OUT_320] = { let __args: [G; IN_320] = [__v_3, __v_6]; let __cu = unconstrained; if let Some(result) = record.function_queries[320].get_mut(&__args[..]) { if !__cu && *result.multiplicity == G::ZERO { aiur_fn_320(__args, record, io_buffer, false)? } else { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_320] = unsafe { *(result.output.as_ptr() as *const [G; OUT_320]) }; __ret } } else { aiur_fn_320(__args, record, io_buffer, __cu)? } }; let __v_7: G = __r_arr[0]; let __v_8: G = G::from_u64(1); if (__v_7 != __v_8) { return Err(ExecError::AssertEqMismatch { lhs: __v_7.as_canonical_u64(), rhs: __v_8.as_canonical_u64(), msg: Some("projection on a Prop structure: field is not a Prop".to_string()) }); } - let __ret: [G; OUT_495] = []; - if let Some(result) = record.function_queries[495].get_mut(&inp[..]) { debug_assert_eq!(result.output, &__ret[..]); if !unconstrained { *result.multiplicity += G::ONE; } } else { record.function_queries[495].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained)); }; + let __ret: [G; OUT_491] = []; + if let Some(result) = record.function_queries[491].get_mut(&inp[..]) { debug_assert_eq!(result.output, &__ret[..]); if !unconstrained { *result.multiplicity += G::ONE; } } else { record.function_queries[491].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained)); }; return Ok(__ret); }, } }) } -const INPUT_SIZE_496: usize = 4; -const IN_496: usize = 4; -const OUT_496: usize = 0; -fn aiur_fn_496( - inp: [G; IN_496], +const INPUT_SIZE_492: usize = 4; +const IN_492: usize = 4; +const OUT_492: usize = 0; +fn aiur_fn_492( + inp: [G; IN_492], record: &mut QueryRecord, io_buffer: &mut IOBuffer, unconstrained: bool, -) -> Result<[G; OUT_496], ExecError> { +) -> Result<[G; OUT_492], ExecError> { stacker::maybe_grow(64 * 1024, 4 * 1024 * 1024, || { let __v_0: G = inp[0]; let __v_1: G = inp[1]; @@ -43962,33 +43678,33 @@ fn aiur_fn_496( let __v_3: G = inp[3]; match __v_0.as_canonical_u64() { 0u64 => { - let __ret: [G; OUT_496] = []; - if let Some(result) = record.function_queries[496].get_mut(&inp[..]) { debug_assert_eq!(result.output, &__ret[..]); if !unconstrained { *result.multiplicity += G::ONE; } } else { record.function_queries[496].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained)); }; + let __ret: [G; OUT_492] = []; + if let Some(result) = record.function_queries[492].get_mut(&inp[..]) { debug_assert_eq!(result.output, &__ret[..]); if !unconstrained { *result.multiplicity += G::ONE; } } else { record.function_queries[492].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained)); }; return Ok(__ret); }, _ => { - let __r_arr: [G; OUT_499] = { let __args: [G; IN_499] = [__v_1, __v_3]; let __cu = unconstrained; if let Some(result) = record.function_queries[499].get_mut(&__args[..]) { if !__cu && *result.multiplicity == G::ZERO { aiur_fn_499(__args, record, io_buffer, false)? } else { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_499] = unsafe { *(result.output.as_ptr() as *const [G; OUT_499]) }; __ret } } else { aiur_fn_499(__args, record, io_buffer, __cu)? } }; + let __r_arr: [G; OUT_495] = { let __args: [G; IN_495] = [__v_1, __v_3]; let __cu = unconstrained; if let Some(result) = record.function_queries[495].get_mut(&__args[..]) { if !__cu && *result.multiplicity == G::ZERO { aiur_fn_495(__args, record, io_buffer, false)? } else { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_495] = unsafe { *(result.output.as_ptr() as *const [G; OUT_495]) }; __ret } } else { aiur_fn_495(__args, record, io_buffer, __cu)? } }; let __v_4: G = __r_arr[0]; let __v_5: G = G::from_u64(0); let __v_6: G = G::from_u64(0); let __v_7: G = { let __values: [G; 3] = [__v_5, __v_6, __v_6]; let __mq = record.memory_queries.get_mut(&3).ok_or(ExecError::InvalidMemorySize(3))?; if let Some(result) = __mq.get_mut(&__values[..]) { if !unconstrained { *result.multiplicity += G::ONE; } result.output[0] } else { let __ptr = G::from_usize(__mq.len()); __mq.insert(&__values[..], &[__ptr], G::from_bool(!unconstrained)); __ptr } }; - let __r_arr: [G; OUT_324] = { let __args: [G; IN_324] = [__v_4, __v_7]; let __cu = unconstrained; if let Some(result) = record.function_queries[324].get_mut(&__args[..]) { if !__cu && *result.multiplicity == G::ZERO { aiur_fn_324(__args, record, io_buffer, false)? } else { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_324] = unsafe { *(result.output.as_ptr() as *const [G; OUT_324]) }; __ret } } else { aiur_fn_324(__args, record, io_buffer, __cu)? } }; + let __r_arr: [G; OUT_320] = { let __args: [G; IN_320] = [__v_4, __v_7]; let __cu = unconstrained; if let Some(result) = record.function_queries[320].get_mut(&__args[..]) { if !__cu && *result.multiplicity == G::ZERO { aiur_fn_320(__args, record, io_buffer, false)? } else { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_320] = unsafe { *(result.output.as_ptr() as *const [G; OUT_320]) }; __ret } } else { aiur_fn_320(__args, record, io_buffer, __cu)? } }; let __v_8: G = __r_arr[0]; match __v_8.as_canonical_u64() { 1u64 => { - let __ret: [G; OUT_496] = []; - if let Some(result) = record.function_queries[496].get_mut(&inp[..]) { debug_assert_eq!(result.output, &__ret[..]); if !unconstrained { *result.multiplicity += G::ONE; } } else { record.function_queries[496].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained)); }; + let __ret: [G; OUT_492] = []; + if let Some(result) = record.function_queries[492].get_mut(&inp[..]) { debug_assert_eq!(result.output, &__ret[..]); if !unconstrained { *result.multiplicity += G::ONE; } } else { record.function_queries[492].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained)); }; return Ok(__ret); }, _ => { - let __r_arr: [G; OUT_341] = { let __args: [G; IN_341] = [__v_2]; let __cu = unconstrained; if let Some(result) = record.function_queries[341].get_mut(&__args[..]) { if !__cu && *result.multiplicity == G::ZERO { aiur_fn_341(__args, record, io_buffer, false)? } else { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_341] = unsafe { *(result.output.as_ptr() as *const [G; OUT_341]) }; __ret } } else { aiur_fn_341(__args, record, io_buffer, __cu)? } }; + let __r_arr: [G; OUT_337] = { let __args: [G; IN_337] = [__v_2]; let __cu = unconstrained; if let Some(result) = record.function_queries[337].get_mut(&__args[..]) { if !__cu && *result.multiplicity == G::ZERO { aiur_fn_337(__args, record, io_buffer, false)? } else { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_337] = unsafe { *(result.output.as_ptr() as *const [G; OUT_337]) }; __ret } } else { aiur_fn_337(__args, record, io_buffer, __cu)? } }; let __v_9: G = __r_arr[0]; let __v_10: G = G::from_u64(0); if (__v_9 != __v_10) { return Err(ExecError::AssertEqMismatch { lhs: __v_9.as_canonical_u64(), rhs: __v_10.as_canonical_u64(), msg: Some("projection on a Prop structure: later fields depend on a data field".to_string()) }); } - let __ret: [G; OUT_496] = []; - if let Some(result) = record.function_queries[496].get_mut(&inp[..]) { debug_assert_eq!(result.output, &__ret[..]); if !unconstrained { *result.multiplicity += G::ONE; } } else { record.function_queries[496].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained)); }; + let __ret: [G; OUT_492] = []; + if let Some(result) = record.function_queries[492].get_mut(&inp[..]) { debug_assert_eq!(result.output, &__ret[..]); if !unconstrained { *result.multiplicity += G::ONE; } } else { record.function_queries[492].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained)); }; return Ok(__ret); }, } @@ -43997,15 +43713,15 @@ fn aiur_fn_496( }) } -const INPUT_SIZE_497: usize = 7; -const IN_497: usize = 7; -const OUT_497: usize = 1; -fn aiur_fn_497( - inp: [G; IN_497], +const INPUT_SIZE_493: usize = 7; +const IN_493: usize = 7; +const OUT_493: usize = 1; +fn aiur_fn_493( + inp: [G; IN_493], record: &mut QueryRecord, io_buffer: &mut IOBuffer, unconstrained: bool, -) -> Result<[G; OUT_497], ExecError> { +) -> Result<[G; OUT_493], ExecError> { stacker::maybe_grow(64 * 1024, 4 * 1024 * 1024, || { let __v_0: G = inp[0]; let __v_1: G = inp[1]; @@ -44024,24 +43740,24 @@ fn aiur_fn_497( let __v_11: G = (__v_1 - __v_2); match __v_11.as_canonical_u64() { 0u64 => { - let __r_arr: [G; OUT_495] = { let __args: [G; IN_495] = [__v_5, __v_8, __v_6]; let __cu = unconstrained; if let Some(result) = record.function_queries[495].get_mut(&__args[..]) { if !__cu && *result.multiplicity == G::ZERO { aiur_fn_495(__args, record, io_buffer, false)? } else { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_495] = unsafe { *(result.output.as_ptr() as *const [G; OUT_495]) }; __ret } } else { aiur_fn_495(__args, record, io_buffer, __cu)? } }; - let __ret: [G; OUT_497] = [__v_8]; - if let Some(result) = record.function_queries[497].get_mut(&inp[..]) { debug_assert_eq!(result.output, &__ret[..]); if !unconstrained { *result.multiplicity += G::ONE; } } else { record.function_queries[497].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained)); }; + let __r_arr: [G; OUT_491] = { let __args: [G; IN_491] = [__v_5, __v_8, __v_6]; let __cu = unconstrained; if let Some(result) = record.function_queries[491].get_mut(&__args[..]) { if !__cu && *result.multiplicity == G::ZERO { aiur_fn_491(__args, record, io_buffer, false)? } else { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_491] = unsafe { *(result.output.as_ptr() as *const [G; OUT_491]) }; __ret } } else { aiur_fn_491(__args, record, io_buffer, __cu)? } }; + let __ret: [G; OUT_493] = [__v_8]; + if let Some(result) = record.function_queries[493].get_mut(&inp[..]) { debug_assert_eq!(result.output, &__ret[..]); if !unconstrained { *result.multiplicity += G::ONE; } } else { record.function_queries[493].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained)); }; return Ok(__ret); }, _ => { - let __r_arr: [G; OUT_496] = { let __args: [G; IN_496] = [__v_5, __v_8, __v_9, __v_6]; let __cu = unconstrained; if let Some(result) = record.function_queries[496].get_mut(&__args[..]) { if !__cu && *result.multiplicity == G::ZERO { aiur_fn_496(__args, record, io_buffer, false)? } else { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_496] = unsafe { *(result.output.as_ptr() as *const [G; OUT_496]) }; __ret } } else { aiur_fn_496(__args, record, io_buffer, __cu)? } }; + let __r_arr: [G; OUT_492] = { let __args: [G; IN_492] = [__v_5, __v_8, __v_9, __v_6]; let __cu = unconstrained; if let Some(result) = record.function_queries[492].get_mut(&__args[..]) { if !__cu && *result.multiplicity == G::ZERO { aiur_fn_492(__args, record, io_buffer, false)? } else { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_492] = unsafe { *(result.output.as_ptr() as *const [G; OUT_492]) }; __ret } } else { aiur_fn_492(__args, record, io_buffer, __cu)? } }; let __v_12: G = G::from_u64(8); let __v_13: G = { let __values: [G; 4] = [__v_12, __v_3, __v_2, __v_4]; let __mq = record.memory_queries.get_mut(&4).ok_or(ExecError::InvalidMemorySize(4))?; if let Some(result) = __mq.get_mut(&__values[..]) { if !unconstrained { *result.multiplicity += G::ONE; } result.output[0] } else { let __ptr = G::from_usize(__mq.len()); __mq.insert(&__values[..], &[__ptr], G::from_bool(!unconstrained)); __ptr } }; let __v_14: G = G::from_u64(0); - let __r_arr: [G; OUT_368] = { let __args: [G; IN_368] = [__v_9, __v_13, __v_14]; let __cu = unconstrained; if let Some(result) = record.function_queries[368].get_mut(&__args[..]) { if !__cu && *result.multiplicity == G::ZERO { aiur_fn_368(__args, record, io_buffer, false)? } else { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_368] = unsafe { *(result.output.as_ptr() as *const [G; OUT_368]) }; __ret } } else { aiur_fn_368(__args, record, io_buffer, __cu)? } }; + let __r_arr: [G; OUT_364] = { let __args: [G; IN_364] = [__v_9, __v_13, __v_14]; let __cu = unconstrained; if let Some(result) = record.function_queries[364].get_mut(&__args[..]) { if !__cu && *result.multiplicity == G::ZERO { aiur_fn_364(__args, record, io_buffer, false)? } else { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_364] = unsafe { *(result.output.as_ptr() as *const [G; OUT_364]) }; __ret } } else { aiur_fn_364(__args, record, io_buffer, __cu)? } }; let __v_15: G = __r_arr[0]; let __v_16: G = G::from_u64(1); let __v_17: G = (__v_2 + __v_16); - let __r_arr: [G; OUT_497] = { let __args: [G; IN_497] = [__v_15, __v_1, __v_17, __v_3, __v_4, __v_5, __v_6]; let __cu = unconstrained; if let Some(result) = record.function_queries[497].get_mut(&__args[..]) { if !__cu && *result.multiplicity == G::ZERO { aiur_fn_497(__args, record, io_buffer, false)? } else { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_497] = unsafe { *(result.output.as_ptr() as *const [G; OUT_497]) }; __ret } } else { aiur_fn_497(__args, record, io_buffer, __cu)? } }; + let __r_arr: [G; OUT_493] = { let __args: [G; IN_493] = [__v_15, __v_1, __v_17, __v_3, __v_4, __v_5, __v_6]; let __cu = unconstrained; if let Some(result) = record.function_queries[493].get_mut(&__args[..]) { if !__cu && *result.multiplicity == G::ZERO { aiur_fn_493(__args, record, io_buffer, false)? } else { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_493] = unsafe { *(result.output.as_ptr() as *const [G; OUT_493]) }; __ret } } else { aiur_fn_493(__args, record, io_buffer, __cu)? } }; let __v_18: G = __r_arr[0]; - let __ret: [G; OUT_497] = [__v_18]; - if let Some(result) = record.function_queries[497].get_mut(&inp[..]) { debug_assert_eq!(result.output, &__ret[..]); if !unconstrained { *result.multiplicity += G::ONE; } } else { record.function_queries[497].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained)); }; + let __ret: [G; OUT_493] = [__v_18]; + if let Some(result) = record.function_queries[493].get_mut(&inp[..]) { debug_assert_eq!(result.output, &__ret[..]); if !unconstrained { *result.multiplicity += G::ONE; } } else { record.function_queries[493].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained)); }; return Ok(__ret); }, } @@ -44053,23 +43769,23 @@ fn aiur_fn_497( }) } -const INPUT_SIZE_498: usize = 4; -const IN_498: usize = 4; -const OUT_498: usize = 1; -fn aiur_fn_498( - inp: [G; IN_498], +const INPUT_SIZE_494: usize = 4; +const IN_494: usize = 4; +const OUT_494: usize = 1; +fn aiur_fn_494( + inp: [G; IN_494], record: &mut QueryRecord, io_buffer: &mut IOBuffer, unconstrained: bool, -) -> Result<[G; OUT_498], ExecError> { +) -> Result<[G; OUT_494], ExecError> { stacker::maybe_grow(64 * 1024, 4 * 1024 * 1024, || { let __v_0: G = inp[0]; let __v_1: G = inp[1]; let __v_2: G = inp[2]; let __v_3: G = inp[3]; - let __r_arr: [G; OUT_488] = { let __args: [G; IN_488] = [__v_2, __v_3]; let __cu = unconstrained; if let Some(result) = record.function_queries[488].get_mut(&__args[..]) { if !__cu && *result.multiplicity == G::ZERO { aiur_fn_488(__args, record, io_buffer, false)? } else { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_488] = unsafe { *(result.output.as_ptr() as *const [G; OUT_488]) }; __ret } } else { aiur_fn_488(__args, record, io_buffer, __cu)? } }; + let __r_arr: [G; OUT_484] = { let __args: [G; IN_484] = [__v_2, __v_3]; let __cu = unconstrained; if let Some(result) = record.function_queries[484].get_mut(&__args[..]) { if !__cu && *result.multiplicity == G::ZERO { aiur_fn_484(__args, record, io_buffer, false)? } else { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_484] = unsafe { *(result.output.as_ptr() as *const [G; OUT_484]) }; __ret } } else { aiur_fn_484(__args, record, io_buffer, __cu)? } }; let __v_4: G = __r_arr[0]; - let __r_arr: [G; OUT_418] = { let __args: [G; IN_418] = [__v_4, __v_3]; let __cu = unconstrained; if let Some(result) = record.function_queries[418].get_mut(&__args[..]) { if !__cu && *result.multiplicity == G::ZERO { aiur_fn_418(__args, record, io_buffer, false)? } else { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_418] = unsafe { *(result.output.as_ptr() as *const [G; OUT_418]) }; __ret } } else { aiur_fn_418(__args, record, io_buffer, __cu)? } }; + let __r_arr: [G; OUT_414] = { let __args: [G; IN_414] = [__v_4, __v_3]; let __cu = unconstrained; if let Some(result) = record.function_queries[414].get_mut(&__args[..]) { if !__cu && *result.multiplicity == G::ZERO { aiur_fn_414(__args, record, io_buffer, false)? } else { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_414] = unsafe { *(result.output.as_ptr() as *const [G; OUT_414]) }; __ret } } else { aiur_fn_414(__args, record, io_buffer, __cu)? } }; let __v_5: G = __r_arr[0]; let __r_arr: [G; OUT_111] = { let __args: [G; IN_111] = [__v_5]; let __cu = unconstrained; if let Some(result) = record.function_queries[111].get_mut(&__args[..]) { if !__cu && *result.multiplicity == G::ZERO { aiur_fn_111(__args, record, io_buffer, false)? } else { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_111] = unsafe { *(result.output.as_ptr() as *const [G; OUT_111]) }; __ret } } else { aiur_fn_111(__args, record, io_buffer, __cu)? } }; let __v_6: G = __r_arr[0]; @@ -44081,7 +43797,7 @@ fn aiur_fn_498( let __v_11: G = __loaded[3]; match __v_8.as_canonical_u64() { 2u64 => { - let __r_arr: [G; OUT_287] = { let __args: [G; IN_287] = [__v_9]; let __cu = unconstrained; if let Some(result) = record.function_queries[287].get_mut(&__args[..]) { if !__cu && *result.multiplicity == G::ZERO { aiur_fn_287(__args, record, io_buffer, false)? } else { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_287] = unsafe { *(result.output.as_ptr() as *const [G; OUT_287]) }; __ret } } else { aiur_fn_287(__args, record, io_buffer, __cu)? } }; + let __r_arr: [G; OUT_283] = { let __args: [G; IN_283] = [__v_9]; let __cu = unconstrained; if let Some(result) = record.function_queries[283].get_mut(&__args[..]) { if !__cu && *result.multiplicity == G::ZERO { aiur_fn_283(__args, record, io_buffer, false)? } else { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_283] = unsafe { *(result.output.as_ptr() as *const [G; OUT_283]) }; __ret } } else { aiur_fn_283(__args, record, io_buffer, __cu)? } }; let __v_12: G = __r_arr[0]; let __loaded: [G; 12] = { let __mq = record.memory_queries.get_mut(&12).ok_or(ExecError::InvalidMemorySize(12))?; let __ptr_u64 = __v_12.as_canonical_u64(); let __ptr_usize = usize::try_from(__ptr_u64).ok().ok_or(ExecError::PointerTooLarge(__ptr_u64))?; let (__args, __mult) = __mq.get_index_mut(__ptr_usize).ok_or(ExecError::UnboundPointer { ptr: __ptr_u64, size: 12 })?; if !unconstrained { *__mult += G::ONE; } let __arr: [G; 12] = __args[..12].try_into().unwrap(); __arr }; let __v_13: G = __loaded[0]; @@ -44102,7 +43818,7 @@ fn aiur_fn_498( match __v_13.as_canonical_u64() { 5u64 => { let __v_25: G = G::from_u64(0); - let __r_arr: [G; OUT_290] = { let __args: [G; IN_290] = [__v_20, __v_21, __v_25]; let __cu = unconstrained; if let Some(result) = record.function_queries[290].get_mut(&__args[..]) { if !__cu && *result.multiplicity == G::ZERO { aiur_fn_290(__args, record, io_buffer, false)? } else { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_290] = unsafe { *(result.output.as_ptr() as *const [G; OUT_290]) }; __ret } } else { aiur_fn_290(__args, record, io_buffer, __cu)? } }; + let __r_arr: [G; OUT_286] = { let __args: [G; IN_286] = [__v_20, __v_21, __v_25]; let __cu = unconstrained; if let Some(result) = record.function_queries[286].get_mut(&__args[..]) { if !__cu && *result.multiplicity == G::ZERO { aiur_fn_286(__args, record, io_buffer, false)? } else { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_286] = unsafe { *(result.output.as_ptr() as *const [G; OUT_286]) }; __ret } } else { aiur_fn_286(__args, record, io_buffer, __cu)? } }; let __v_26: G = __r_arr[0]; let __loaded: [G; 12] = { let __mq = record.memory_queries.get_mut(&12).ok_or(ExecError::InvalidMemorySize(12))?; let __ptr_u64 = __v_26.as_canonical_u64(); let __ptr_usize = usize::try_from(__ptr_u64).ok().ok_or(ExecError::PointerTooLarge(__ptr_u64))?; let (__args, __mult) = __mq.get_index_mut(__ptr_usize).ok_or(ExecError::UnboundPointer { ptr: __ptr_u64, size: 12 })?; if !unconstrained { *__mult += G::ONE; } let __arr: [G; 12] = __args[..12].try_into().unwrap(); __arr }; let __v_27: G = __loaded[0]; @@ -44123,18 +43839,18 @@ fn aiur_fn_498( } match __v_27.as_canonical_u64() { 6u64 => { - let __r_arr: [G; OUT_336] = { let __args: [G; IN_336] = [__v_29, __v_10]; let __cu = unconstrained; if let Some(result) = record.function_queries[336].get_mut(&__args[..]) { if !__cu && *result.multiplicity == G::ZERO { aiur_fn_336(__args, record, io_buffer, false)? } else { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_336] = unsafe { *(result.output.as_ptr() as *const [G; OUT_336]) }; __ret } } else { aiur_fn_336(__args, record, io_buffer, __cu)? } }; + let __r_arr: [G; OUT_332] = { let __args: [G; IN_332] = [__v_29, __v_10]; let __cu = unconstrained; if let Some(result) = record.function_queries[332].get_mut(&__args[..]) { if !__cu && *result.multiplicity == G::ZERO { aiur_fn_332(__args, record, io_buffer, false)? } else { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_332] = unsafe { *(result.output.as_ptr() as *const [G; OUT_332]) }; __ret } } else { aiur_fn_332(__args, record, io_buffer, __cu)? } }; let __v_40: G = __r_arr[0]; - let __r_arr: [G; OUT_436] = { let __args: [G; IN_436] = [__v_40, __v_7, __v_16]; let __cu = unconstrained; if let Some(result) = record.function_queries[436].get_mut(&__args[..]) { if !__cu && *result.multiplicity == G::ZERO { aiur_fn_436(__args, record, io_buffer, false)? } else { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_436] = unsafe { *(result.output.as_ptr() as *const [G; OUT_436]) }; __ret } } else { aiur_fn_436(__args, record, io_buffer, __cu)? } }; + let __r_arr: [G; OUT_432] = { let __args: [G; IN_432] = [__v_40, __v_7, __v_16]; let __cu = unconstrained; if let Some(result) = record.function_queries[432].get_mut(&__args[..]) { if !__cu && *result.multiplicity == G::ZERO { aiur_fn_432(__args, record, io_buffer, false)? } else { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_432] = unsafe { *(result.output.as_ptr() as *const [G; OUT_432]) }; __ret } } else { aiur_fn_432(__args, record, io_buffer, __cu)? } }; let __v_41: G = __r_arr[0]; let __v_42: G = (__v_16 + __v_17); - let __r_arr: [G; OUT_493] = { let __args: [G; IN_493] = [__v_15, __v_10, __v_42, __v_3]; let __cu = unconstrained; if let Some(result) = record.function_queries[493].get_mut(&__args[..]) { if !__cu && *result.multiplicity == G::ZERO { aiur_fn_493(__args, record, io_buffer, false)? } else { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_493] = unsafe { *(result.output.as_ptr() as *const [G; OUT_493]) }; __ret } } else { aiur_fn_493(__args, record, io_buffer, __cu)? } }; + let __r_arr: [G; OUT_489] = { let __args: [G; IN_489] = [__v_15, __v_10, __v_42, __v_3]; let __cu = unconstrained; if let Some(result) = record.function_queries[489].get_mut(&__args[..]) { if !__cu && *result.multiplicity == G::ZERO { aiur_fn_489(__args, record, io_buffer, false)? } else { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_489] = unsafe { *(result.output.as_ptr() as *const [G; OUT_489]) }; __ret } } else { aiur_fn_489(__args, record, io_buffer, __cu)? } }; let __v_43: G = __r_arr[0]; let __v_44: G = G::from_u64(0); - let __r_arr: [G; OUT_497] = { let __args: [G; IN_497] = [__v_41, __v_1, __v_44, __v_0, __v_2, __v_43, __v_3]; let __cu = unconstrained; if let Some(result) = record.function_queries[497].get_mut(&__args[..]) { if !__cu && *result.multiplicity == G::ZERO { aiur_fn_497(__args, record, io_buffer, false)? } else { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_497] = unsafe { *(result.output.as_ptr() as *const [G; OUT_497]) }; __ret } } else { aiur_fn_497(__args, record, io_buffer, __cu)? } }; + let __r_arr: [G; OUT_493] = { let __args: [G; IN_493] = [__v_41, __v_1, __v_44, __v_0, __v_2, __v_43, __v_3]; let __cu = unconstrained; if let Some(result) = record.function_queries[493].get_mut(&__args[..]) { if !__cu && *result.multiplicity == G::ZERO { aiur_fn_493(__args, record, io_buffer, false)? } else { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_493] = unsafe { *(result.output.as_ptr() as *const [G; OUT_493]) }; __ret } } else { aiur_fn_493(__args, record, io_buffer, __cu)? } }; let __v_45: G = __r_arr[0]; - let __ret: [G; OUT_498] = [__v_45]; - if let Some(result) = record.function_queries[498].get_mut(&inp[..]) { debug_assert_eq!(result.output, &__ret[..]); if !unconstrained { *result.multiplicity += G::ONE; } } else { record.function_queries[498].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained)); }; + let __ret: [G; OUT_494] = [__v_45]; + if let Some(result) = record.function_queries[494].get_mut(&inp[..]) { debug_assert_eq!(result.output, &__ret[..]); if !unconstrained { *result.multiplicity += G::ONE; } } else { record.function_queries[494].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained)); }; return Ok(__ret); }, _ => { @@ -44154,21 +43870,21 @@ fn aiur_fn_498( }) } -const INPUT_SIZE_499: usize = 2; -const IN_499: usize = 2; -const OUT_499: usize = 1; -fn aiur_fn_499( - inp: [G; IN_499], +const INPUT_SIZE_495: usize = 2; +const IN_495: usize = 2; +const OUT_495: usize = 1; +fn aiur_fn_495( + inp: [G; IN_495], record: &mut QueryRecord, io_buffer: &mut IOBuffer, unconstrained: bool, -) -> Result<[G; OUT_499], ExecError> { +) -> Result<[G; OUT_495], ExecError> { stacker::maybe_grow(64 * 1024, 4 * 1024 * 1024, || { let __v_0: G = inp[0]; let __v_1: G = inp[1]; - let __r_arr: [G; OUT_488] = { let __args: [G; IN_488] = [__v_0, __v_1]; let __cu = unconstrained; if let Some(result) = record.function_queries[488].get_mut(&__args[..]) { if !__cu && *result.multiplicity == G::ZERO { aiur_fn_488(__args, record, io_buffer, false)? } else { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_488] = unsafe { *(result.output.as_ptr() as *const [G; OUT_488]) }; __ret } } else { aiur_fn_488(__args, record, io_buffer, __cu)? } }; + let __r_arr: [G; OUT_484] = { let __args: [G; IN_484] = [__v_0, __v_1]; let __cu = unconstrained; if let Some(result) = record.function_queries[484].get_mut(&__args[..]) { if !__cu && *result.multiplicity == G::ZERO { aiur_fn_484(__args, record, io_buffer, false)? } else { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_484] = unsafe { *(result.output.as_ptr() as *const [G; OUT_484]) }; __ret } } else { aiur_fn_484(__args, record, io_buffer, __cu)? } }; let __v_2: G = __r_arr[0]; - let __r_arr: [G; OUT_418] = { let __args: [G; IN_418] = [__v_2, __v_1]; let __cu = unconstrained; if let Some(result) = record.function_queries[418].get_mut(&__args[..]) { if !__cu && *result.multiplicity == G::ZERO { aiur_fn_418(__args, record, io_buffer, false)? } else { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_418] = unsafe { *(result.output.as_ptr() as *const [G; OUT_418]) }; __ret } } else { aiur_fn_418(__args, record, io_buffer, __cu)? } }; + let __r_arr: [G; OUT_414] = { let __args: [G; IN_414] = [__v_2, __v_1]; let __cu = unconstrained; if let Some(result) = record.function_queries[414].get_mut(&__args[..]) { if !__cu && *result.multiplicity == G::ZERO { aiur_fn_414(__args, record, io_buffer, false)? } else { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_414] = unsafe { *(result.output.as_ptr() as *const [G; OUT_414]) }; __ret } } else { aiur_fn_414(__args, record, io_buffer, __cu)? } }; let __v_3: G = __r_arr[0]; let __loaded: [G; 4] = { let __mq = record.memory_queries.get_mut(&4).ok_or(ExecError::InvalidMemorySize(4))?; let __ptr_u64 = __v_3.as_canonical_u64(); let __ptr_usize = usize::try_from(__ptr_u64).ok().ok_or(ExecError::PointerTooLarge(__ptr_u64))?; let (__args, __mult) = __mq.get_index_mut(__ptr_usize).ok_or(ExecError::UnboundPointer { ptr: __ptr_u64, size: 4 })?; if !unconstrained { *__mult += G::ONE; } let __arr: [G; 4] = __args[..4].try_into().unwrap(); __arr }; let __v_4: G = __loaded[0]; @@ -44177,8 +43893,8 @@ fn aiur_fn_499( let __v_7: G = __loaded[3]; match __v_4.as_canonical_u64() { 1u64 => { - let __ret: [G; OUT_499] = [__v_5]; - if let Some(result) = record.function_queries[499].get_mut(&inp[..]) { debug_assert_eq!(result.output, &__ret[..]); if !unconstrained { *result.multiplicity += G::ONE; } } else { record.function_queries[499].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained)); }; + let __ret: [G; OUT_495] = [__v_5]; + if let Some(result) = record.function_queries[495].get_mut(&inp[..]) { debug_assert_eq!(result.output, &__ret[..]); if !unconstrained { *result.multiplicity += G::ONE; } } else { record.function_queries[495].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained)); }; return Ok(__ret); }, _ => { @@ -44188,42 +43904,42 @@ fn aiur_fn_499( }) } -const INPUT_SIZE_500: usize = 3; -const IN_500: usize = 3; -const OUT_500: usize = 0; -fn aiur_fn_500( - inp: [G; IN_500], +const INPUT_SIZE_496: usize = 3; +const IN_496: usize = 3; +const OUT_496: usize = 0; +fn aiur_fn_496( + inp: [G; IN_496], record: &mut QueryRecord, io_buffer: &mut IOBuffer, unconstrained: bool, -) -> Result<[G; OUT_500], ExecError> { +) -> Result<[G; OUT_496], ExecError> { stacker::maybe_grow(64 * 1024, 4 * 1024 * 1024, || { let __v_0: G = inp[0]; let __v_1: G = inp[1]; let __v_2: G = inp[2]; - let __r_arr: [G; OUT_488] = { let __args: [G; IN_488] = [__v_0, __v_2]; let __cu = unconstrained; if let Some(result) = record.function_queries[488].get_mut(&__args[..]) { if !__cu && *result.multiplicity == G::ZERO { aiur_fn_488(__args, record, io_buffer, false)? } else { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_488] = unsafe { *(result.output.as_ptr() as *const [G; OUT_488]) }; __ret } } else { aiur_fn_488(__args, record, io_buffer, __cu)? } }; + let __r_arr: [G; OUT_484] = { let __args: [G; IN_484] = [__v_0, __v_2]; let __cu = unconstrained; if let Some(result) = record.function_queries[484].get_mut(&__args[..]) { if !__cu && *result.multiplicity == G::ZERO { aiur_fn_484(__args, record, io_buffer, false)? } else { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_484] = unsafe { *(result.output.as_ptr() as *const [G; OUT_484]) }; __ret } } else { aiur_fn_484(__args, record, io_buffer, __cu)? } }; let __v_3: G = __r_arr[0]; - let __r_arr: [G; OUT_439] = { let __args: [G; IN_439] = [__v_3, __v_1, __v_2]; let __cu = unconstrained; if let Some(result) = record.function_queries[439].get_mut(&__args[..]) { if !__cu && *result.multiplicity == G::ZERO { aiur_fn_439(__args, record, io_buffer, false)? } else { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_439] = unsafe { *(result.output.as_ptr() as *const [G; OUT_439]) }; __ret } } else { aiur_fn_439(__args, record, io_buffer, __cu)? } }; + let __r_arr: [G; OUT_435] = { let __args: [G; IN_435] = [__v_3, __v_1, __v_2]; let __cu = unconstrained; if let Some(result) = record.function_queries[435].get_mut(&__args[..]) { if !__cu && *result.multiplicity == G::ZERO { aiur_fn_435(__args, record, io_buffer, false)? } else { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_435] = unsafe { *(result.output.as_ptr() as *const [G; OUT_435]) }; __ret } } else { aiur_fn_435(__args, record, io_buffer, __cu)? } }; let __v_4: G = __r_arr[0]; let __v_5: G = G::from_u64(1); if (__v_4 != __v_5) { return Err(ExecError::AssertEqMismatch { lhs: __v_4.as_canonical_u64(), rhs: __v_5.as_canonical_u64(), msg: Some("inferred type is not def-eq to the expected type".to_string()) }); } - let __ret: [G; OUT_500] = []; - if let Some(result) = record.function_queries[500].get_mut(&inp[..]) { debug_assert_eq!(result.output, &__ret[..]); if !unconstrained { *result.multiplicity += G::ONE; } } else { record.function_queries[500].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained)); }; + let __ret: [G; OUT_496] = []; + if let Some(result) = record.function_queries[496].get_mut(&inp[..]) { debug_assert_eq!(result.output, &__ret[..]); if !unconstrained { *result.multiplicity += G::ONE; } } else { record.function_queries[496].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained)); }; return Ok(__ret); }) } -const INPUT_SIZE_501: usize = 0; -const IN_501: usize = 0; -const OUT_501: usize = 1; -fn aiur_fn_501( - inp: [G; IN_501], +const INPUT_SIZE_497: usize = 0; +const IN_497: usize = 0; +const OUT_497: usize = 1; +fn aiur_fn_497( + inp: [G; IN_497], record: &mut QueryRecord, io_buffer: &mut IOBuffer, unconstrained: bool, -) -> Result<[G; OUT_501], ExecError> { +) -> Result<[G; OUT_497], ExecError> { stacker::maybe_grow(64 * 1024, 4 * 1024 * 1024, || { let __v_0: G = G::from_u64(69); let __v_1: G = G::from_u64(96); @@ -44258,21 +43974,21 @@ fn aiur_fn_501( let __v_30: G = G::from_u64(47); let __v_31: G = G::from_u64(219); let __v_32: G = { let __values: [G; 32] = [__v_0, __v_1, __v_2, __v_3, __v_4, __v_5, __v_6, __v_7, __v_8, __v_9, __v_10, __v_11, __v_12, __v_13, __v_14, __v_15, __v_16, __v_17, __v_18, __v_19, __v_20, __v_21, __v_22, __v_23, __v_24, __v_25, __v_26, __v_27, __v_28, __v_29, __v_30, __v_31]; let __mq = record.memory_queries.get_mut(&32).ok_or(ExecError::InvalidMemorySize(32))?; if let Some(result) = __mq.get_mut(&__values[..]) { if !unconstrained { *result.multiplicity += G::ONE; } result.output[0] } else { let __ptr = G::from_usize(__mq.len()); __mq.insert(&__values[..], &[__ptr], G::from_bool(!unconstrained)); __ptr } }; - let __ret: [G; OUT_501] = [__v_32]; - if let Some(result) = record.function_queries[501].get_mut(&inp[..]) { debug_assert_eq!(result.output, &__ret[..]); if !unconstrained { *result.multiplicity += G::ONE; } } else { record.function_queries[501].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained)); }; + let __ret: [G; OUT_497] = [__v_32]; + if let Some(result) = record.function_queries[497].get_mut(&inp[..]) { debug_assert_eq!(result.output, &__ret[..]); if !unconstrained { *result.multiplicity += G::ONE; } } else { record.function_queries[497].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained)); }; return Ok(__ret); }) } -const INPUT_SIZE_502: usize = 0; -const IN_502: usize = 0; -const OUT_502: usize = 1; -fn aiur_fn_502( - inp: [G; IN_502], +const INPUT_SIZE_498: usize = 0; +const IN_498: usize = 0; +const OUT_498: usize = 1; +fn aiur_fn_498( + inp: [G; IN_498], record: &mut QueryRecord, io_buffer: &mut IOBuffer, unconstrained: bool, -) -> Result<[G; OUT_502], ExecError> { +) -> Result<[G; OUT_498], ExecError> { stacker::maybe_grow(64 * 1024, 4 * 1024 * 1024, || { let __v_0: G = G::from_u64(163); let __v_1: G = G::from_u64(245); @@ -44307,21 +44023,21 @@ fn aiur_fn_502( let __v_30: G = G::from_u64(51); let __v_31: G = G::from_u64(118); let __v_32: G = { let __values: [G; 32] = [__v_0, __v_1, __v_2, __v_3, __v_4, __v_5, __v_6, __v_7, __v_8, __v_9, __v_10, __v_11, __v_12, __v_13, __v_14, __v_15, __v_16, __v_17, __v_18, __v_19, __v_20, __v_21, __v_22, __v_23, __v_24, __v_25, __v_26, __v_27, __v_28, __v_29, __v_30, __v_31]; let __mq = record.memory_queries.get_mut(&32).ok_or(ExecError::InvalidMemorySize(32))?; if let Some(result) = __mq.get_mut(&__values[..]) { if !unconstrained { *result.multiplicity += G::ONE; } result.output[0] } else { let __ptr = G::from_usize(__mq.len()); __mq.insert(&__values[..], &[__ptr], G::from_bool(!unconstrained)); __ptr } }; - let __ret: [G; OUT_502] = [__v_32]; - if let Some(result) = record.function_queries[502].get_mut(&inp[..]) { debug_assert_eq!(result.output, &__ret[..]); if !unconstrained { *result.multiplicity += G::ONE; } } else { record.function_queries[502].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained)); }; + let __ret: [G; OUT_498] = [__v_32]; + if let Some(result) = record.function_queries[498].get_mut(&inp[..]) { debug_assert_eq!(result.output, &__ret[..]); if !unconstrained { *result.multiplicity += G::ONE; } } else { record.function_queries[498].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained)); }; return Ok(__ret); }) } -const INPUT_SIZE_503: usize = 0; -const IN_503: usize = 0; -const OUT_503: usize = 1; -fn aiur_fn_503( - inp: [G; IN_503], +const INPUT_SIZE_499: usize = 0; +const IN_499: usize = 0; +const OUT_499: usize = 1; +fn aiur_fn_499( + inp: [G; IN_499], record: &mut QueryRecord, io_buffer: &mut IOBuffer, unconstrained: bool, -) -> Result<[G; OUT_503], ExecError> { +) -> Result<[G; OUT_499], ExecError> { stacker::maybe_grow(64 * 1024, 4 * 1024 * 1024, || { let __v_0: G = G::from_u64(46); let __v_1: G = G::from_u64(163); @@ -44356,21 +44072,21 @@ fn aiur_fn_503( let __v_30: G = G::from_u64(126); let __v_31: G = G::from_u64(143); let __v_32: G = { let __values: [G; 32] = [__v_0, __v_1, __v_2, __v_3, __v_4, __v_5, __v_6, __v_7, __v_8, __v_9, __v_10, __v_11, __v_12, __v_13, __v_14, __v_15, __v_16, __v_17, __v_18, __v_19, __v_20, __v_21, __v_22, __v_23, __v_24, __v_25, __v_26, __v_27, __v_28, __v_29, __v_30, __v_31]; let __mq = record.memory_queries.get_mut(&32).ok_or(ExecError::InvalidMemorySize(32))?; if let Some(result) = __mq.get_mut(&__values[..]) { if !unconstrained { *result.multiplicity += G::ONE; } result.output[0] } else { let __ptr = G::from_usize(__mq.len()); __mq.insert(&__values[..], &[__ptr], G::from_bool(!unconstrained)); __ptr } }; - let __ret: [G; OUT_503] = [__v_32]; - if let Some(result) = record.function_queries[503].get_mut(&inp[..]) { debug_assert_eq!(result.output, &__ret[..]); if !unconstrained { *result.multiplicity += G::ONE; } } else { record.function_queries[503].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained)); }; + let __ret: [G; OUT_499] = [__v_32]; + if let Some(result) = record.function_queries[499].get_mut(&inp[..]) { debug_assert_eq!(result.output, &__ret[..]); if !unconstrained { *result.multiplicity += G::ONE; } } else { record.function_queries[499].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained)); }; return Ok(__ret); }) } -const INPUT_SIZE_504: usize = 0; -const IN_504: usize = 0; -const OUT_504: usize = 1; -fn aiur_fn_504( - inp: [G; IN_504], +const INPUT_SIZE_500: usize = 0; +const IN_500: usize = 0; +const OUT_500: usize = 1; +fn aiur_fn_500( + inp: [G; IN_500], record: &mut QueryRecord, io_buffer: &mut IOBuffer, unconstrained: bool, -) -> Result<[G; OUT_504], ExecError> { +) -> Result<[G; OUT_500], ExecError> { stacker::maybe_grow(64 * 1024, 4 * 1024 * 1024, || { let __v_0: G = G::from_u64(15); let __v_1: G = G::from_u64(158); @@ -44405,21 +44121,21 @@ fn aiur_fn_504( let __v_30: G = G::from_u64(131); let __v_31: G = G::from_u64(129); let __v_32: G = { let __values: [G; 32] = [__v_0, __v_1, __v_2, __v_3, __v_4, __v_5, __v_6, __v_7, __v_8, __v_9, __v_10, __v_11, __v_12, __v_13, __v_14, __v_15, __v_16, __v_17, __v_18, __v_19, __v_20, __v_21, __v_22, __v_23, __v_24, __v_25, __v_26, __v_27, __v_28, __v_29, __v_30, __v_31]; let __mq = record.memory_queries.get_mut(&32).ok_or(ExecError::InvalidMemorySize(32))?; if let Some(result) = __mq.get_mut(&__values[..]) { if !unconstrained { *result.multiplicity += G::ONE; } result.output[0] } else { let __ptr = G::from_usize(__mq.len()); __mq.insert(&__values[..], &[__ptr], G::from_bool(!unconstrained)); __ptr } }; - let __ret: [G; OUT_504] = [__v_32]; - if let Some(result) = record.function_queries[504].get_mut(&inp[..]) { debug_assert_eq!(result.output, &__ret[..]); if !unconstrained { *result.multiplicity += G::ONE; } } else { record.function_queries[504].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained)); }; + let __ret: [G; OUT_500] = [__v_32]; + if let Some(result) = record.function_queries[500].get_mut(&inp[..]) { debug_assert_eq!(result.output, &__ret[..]); if !unconstrained { *result.multiplicity += G::ONE; } } else { record.function_queries[500].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained)); }; return Ok(__ret); }) } -const INPUT_SIZE_505: usize = 0; -const IN_505: usize = 0; -const OUT_505: usize = 1; -fn aiur_fn_505( - inp: [G; IN_505], +const INPUT_SIZE_501: usize = 0; +const IN_501: usize = 0; +const OUT_501: usize = 1; +fn aiur_fn_501( + inp: [G; IN_501], record: &mut QueryRecord, io_buffer: &mut IOBuffer, unconstrained: bool, -) -> Result<[G; OUT_505], ExecError> { +) -> Result<[G; OUT_501], ExecError> { stacker::maybe_grow(64 * 1024, 4 * 1024 * 1024, || { let __v_0: G = G::from_u64(4); let __v_1: G = G::from_u64(113); @@ -44454,21 +44170,21 @@ fn aiur_fn_505( let __v_30: G = G::from_u64(87); let __v_31: G = G::from_u64(149); let __v_32: G = { let __values: [G; 32] = [__v_0, __v_1, __v_2, __v_3, __v_4, __v_5, __v_6, __v_7, __v_8, __v_9, __v_10, __v_11, __v_12, __v_13, __v_14, __v_15, __v_16, __v_17, __v_18, __v_19, __v_20, __v_21, __v_22, __v_23, __v_24, __v_25, __v_26, __v_27, __v_28, __v_29, __v_30, __v_31]; let __mq = record.memory_queries.get_mut(&32).ok_or(ExecError::InvalidMemorySize(32))?; if let Some(result) = __mq.get_mut(&__values[..]) { if !unconstrained { *result.multiplicity += G::ONE; } result.output[0] } else { let __ptr = G::from_usize(__mq.len()); __mq.insert(&__values[..], &[__ptr], G::from_bool(!unconstrained)); __ptr } }; - let __ret: [G; OUT_505] = [__v_32]; - if let Some(result) = record.function_queries[505].get_mut(&inp[..]) { debug_assert_eq!(result.output, &__ret[..]); if !unconstrained { *result.multiplicity += G::ONE; } } else { record.function_queries[505].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained)); }; + let __ret: [G; OUT_501] = [__v_32]; + if let Some(result) = record.function_queries[501].get_mut(&inp[..]) { debug_assert_eq!(result.output, &__ret[..]); if !unconstrained { *result.multiplicity += G::ONE; } } else { record.function_queries[501].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained)); }; return Ok(__ret); }) } -const INPUT_SIZE_506: usize = 0; -const IN_506: usize = 0; -const OUT_506: usize = 1; -fn aiur_fn_506( - inp: [G; IN_506], +const INPUT_SIZE_502: usize = 0; +const IN_502: usize = 0; +const OUT_502: usize = 1; +fn aiur_fn_502( + inp: [G; IN_502], record: &mut QueryRecord, io_buffer: &mut IOBuffer, unconstrained: bool, -) -> Result<[G; OUT_506], ExecError> { +) -> Result<[G; OUT_502], ExecError> { stacker::maybe_grow(64 * 1024, 4 * 1024 * 1024, || { let __v_0: G = G::from_u64(4); let __v_1: G = G::from_u64(42); @@ -44503,21 +44219,21 @@ fn aiur_fn_506( let __v_30: G = G::from_u64(142); let __v_31: G = G::from_u64(179); let __v_32: G = { let __values: [G; 32] = [__v_0, __v_1, __v_2, __v_3, __v_4, __v_5, __v_6, __v_7, __v_8, __v_9, __v_10, __v_11, __v_12, __v_13, __v_14, __v_15, __v_16, __v_17, __v_18, __v_19, __v_20, __v_21, __v_22, __v_23, __v_24, __v_25, __v_26, __v_27, __v_28, __v_29, __v_30, __v_31]; let __mq = record.memory_queries.get_mut(&32).ok_or(ExecError::InvalidMemorySize(32))?; if let Some(result) = __mq.get_mut(&__values[..]) { if !unconstrained { *result.multiplicity += G::ONE; } result.output[0] } else { let __ptr = G::from_usize(__mq.len()); __mq.insert(&__values[..], &[__ptr], G::from_bool(!unconstrained)); __ptr } }; - let __ret: [G; OUT_506] = [__v_32]; - if let Some(result) = record.function_queries[506].get_mut(&inp[..]) { debug_assert_eq!(result.output, &__ret[..]); if !unconstrained { *result.multiplicity += G::ONE; } } else { record.function_queries[506].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained)); }; + let __ret: [G; OUT_502] = [__v_32]; + if let Some(result) = record.function_queries[502].get_mut(&inp[..]) { debug_assert_eq!(result.output, &__ret[..]); if !unconstrained { *result.multiplicity += G::ONE; } } else { record.function_queries[502].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained)); }; return Ok(__ret); }) } -const INPUT_SIZE_507: usize = 0; -const IN_507: usize = 0; -const OUT_507: usize = 1; -fn aiur_fn_507( - inp: [G; IN_507], +const INPUT_SIZE_503: usize = 0; +const IN_503: usize = 0; +const OUT_503: usize = 1; +fn aiur_fn_503( + inp: [G; IN_503], record: &mut QueryRecord, io_buffer: &mut IOBuffer, unconstrained: bool, -) -> Result<[G; OUT_507], ExecError> { +) -> Result<[G; OUT_503], ExecError> { stacker::maybe_grow(64 * 1024, 4 * 1024 * 1024, || { let __v_0: G = G::from_u64(125); let __v_1: G = G::from_u64(175); @@ -44552,21 +44268,21 @@ fn aiur_fn_507( let __v_30: G = G::from_u64(175); let __v_31: G = G::from_u64(221); let __v_32: G = { let __values: [G; 32] = [__v_0, __v_1, __v_2, __v_3, __v_4, __v_5, __v_6, __v_7, __v_8, __v_9, __v_10, __v_11, __v_12, __v_13, __v_14, __v_15, __v_16, __v_17, __v_18, __v_19, __v_20, __v_21, __v_22, __v_23, __v_24, __v_25, __v_26, __v_27, __v_28, __v_29, __v_30, __v_31]; let __mq = record.memory_queries.get_mut(&32).ok_or(ExecError::InvalidMemorySize(32))?; if let Some(result) = __mq.get_mut(&__values[..]) { if !unconstrained { *result.multiplicity += G::ONE; } result.output[0] } else { let __ptr = G::from_usize(__mq.len()); __mq.insert(&__values[..], &[__ptr], G::from_bool(!unconstrained)); __ptr } }; - let __ret: [G; OUT_507] = [__v_32]; - if let Some(result) = record.function_queries[507].get_mut(&inp[..]) { debug_assert_eq!(result.output, &__ret[..]); if !unconstrained { *result.multiplicity += G::ONE; } } else { record.function_queries[507].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained)); }; + let __ret: [G; OUT_503] = [__v_32]; + if let Some(result) = record.function_queries[503].get_mut(&inp[..]) { debug_assert_eq!(result.output, &__ret[..]); if !unconstrained { *result.multiplicity += G::ONE; } } else { record.function_queries[503].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained)); }; return Ok(__ret); }) } -const INPUT_SIZE_508: usize = 0; -const IN_508: usize = 0; -const OUT_508: usize = 1; -fn aiur_fn_508( - inp: [G; IN_508], +const INPUT_SIZE_504: usize = 0; +const IN_504: usize = 0; +const OUT_504: usize = 1; +fn aiur_fn_504( + inp: [G; IN_504], record: &mut QueryRecord, io_buffer: &mut IOBuffer, unconstrained: bool, -) -> Result<[G; OUT_508], ExecError> { +) -> Result<[G; OUT_504], ExecError> { stacker::maybe_grow(64 * 1024, 4 * 1024 * 1024, || { let __v_0: G = G::from_u64(248); let __v_1: G = G::from_u64(49); @@ -44601,21 +44317,21 @@ fn aiur_fn_508( let __v_30: G = G::from_u64(58); let __v_31: G = G::from_u64(16); let __v_32: G = { let __values: [G; 32] = [__v_0, __v_1, __v_2, __v_3, __v_4, __v_5, __v_6, __v_7, __v_8, __v_9, __v_10, __v_11, __v_12, __v_13, __v_14, __v_15, __v_16, __v_17, __v_18, __v_19, __v_20, __v_21, __v_22, __v_23, __v_24, __v_25, __v_26, __v_27, __v_28, __v_29, __v_30, __v_31]; let __mq = record.memory_queries.get_mut(&32).ok_or(ExecError::InvalidMemorySize(32))?; if let Some(result) = __mq.get_mut(&__values[..]) { if !unconstrained { *result.multiplicity += G::ONE; } result.output[0] } else { let __ptr = G::from_usize(__mq.len()); __mq.insert(&__values[..], &[__ptr], G::from_bool(!unconstrained)); __ptr } }; - let __ret: [G; OUT_508] = [__v_32]; - if let Some(result) = record.function_queries[508].get_mut(&inp[..]) { debug_assert_eq!(result.output, &__ret[..]); if !unconstrained { *result.multiplicity += G::ONE; } } else { record.function_queries[508].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained)); }; + let __ret: [G; OUT_504] = [__v_32]; + if let Some(result) = record.function_queries[504].get_mut(&inp[..]) { debug_assert_eq!(result.output, &__ret[..]); if !unconstrained { *result.multiplicity += G::ONE; } } else { record.function_queries[504].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained)); }; return Ok(__ret); }) } -const INPUT_SIZE_509: usize = 0; -const IN_509: usize = 0; -const OUT_509: usize = 1; -fn aiur_fn_509( - inp: [G; IN_509], +const INPUT_SIZE_505: usize = 0; +const IN_505: usize = 0; +const OUT_505: usize = 1; +fn aiur_fn_505( + inp: [G; IN_505], record: &mut QueryRecord, io_buffer: &mut IOBuffer, unconstrained: bool, -) -> Result<[G; OUT_509], ExecError> { +) -> Result<[G; OUT_505], ExecError> { stacker::maybe_grow(64 * 1024, 4 * 1024 * 1024, || { let __v_0: G = G::from_u64(122); let __v_1: G = G::from_u64(236); @@ -44650,21 +44366,21 @@ fn aiur_fn_509( let __v_30: G = G::from_u64(173); let __v_31: G = G::from_u64(194); let __v_32: G = { let __values: [G; 32] = [__v_0, __v_1, __v_2, __v_3, __v_4, __v_5, __v_6, __v_7, __v_8, __v_9, __v_10, __v_11, __v_12, __v_13, __v_14, __v_15, __v_16, __v_17, __v_18, __v_19, __v_20, __v_21, __v_22, __v_23, __v_24, __v_25, __v_26, __v_27, __v_28, __v_29, __v_30, __v_31]; let __mq = record.memory_queries.get_mut(&32).ok_or(ExecError::InvalidMemorySize(32))?; if let Some(result) = __mq.get_mut(&__values[..]) { if !unconstrained { *result.multiplicity += G::ONE; } result.output[0] } else { let __ptr = G::from_usize(__mq.len()); __mq.insert(&__values[..], &[__ptr], G::from_bool(!unconstrained)); __ptr } }; - let __ret: [G; OUT_509] = [__v_32]; - if let Some(result) = record.function_queries[509].get_mut(&inp[..]) { debug_assert_eq!(result.output, &__ret[..]); if !unconstrained { *result.multiplicity += G::ONE; } } else { record.function_queries[509].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained)); }; + let __ret: [G; OUT_505] = [__v_32]; + if let Some(result) = record.function_queries[505].get_mut(&inp[..]) { debug_assert_eq!(result.output, &__ret[..]); if !unconstrained { *result.multiplicity += G::ONE; } } else { record.function_queries[505].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained)); }; return Ok(__ret); }) } -const INPUT_SIZE_510: usize = 0; -const IN_510: usize = 0; -const OUT_510: usize = 1; -fn aiur_fn_510( - inp: [G; IN_510], +const INPUT_SIZE_506: usize = 0; +const IN_506: usize = 0; +const OUT_506: usize = 1; +fn aiur_fn_506( + inp: [G; IN_506], record: &mut QueryRecord, io_buffer: &mut IOBuffer, unconstrained: bool, -) -> Result<[G; OUT_510], ExecError> { +) -> Result<[G; OUT_506], ExecError> { stacker::maybe_grow(64 * 1024, 4 * 1024 * 1024, || { let __v_0: G = G::from_u64(230); let __v_1: G = G::from_u64(235); @@ -44699,21 +44415,21 @@ fn aiur_fn_510( let __v_30: G = G::from_u64(160); let __v_31: G = G::from_u64(164); let __v_32: G = { let __values: [G; 32] = [__v_0, __v_1, __v_2, __v_3, __v_4, __v_5, __v_6, __v_7, __v_8, __v_9, __v_10, __v_11, __v_12, __v_13, __v_14, __v_15, __v_16, __v_17, __v_18, __v_19, __v_20, __v_21, __v_22, __v_23, __v_24, __v_25, __v_26, __v_27, __v_28, __v_29, __v_30, __v_31]; let __mq = record.memory_queries.get_mut(&32).ok_or(ExecError::InvalidMemorySize(32))?; if let Some(result) = __mq.get_mut(&__values[..]) { if !unconstrained { *result.multiplicity += G::ONE; } result.output[0] } else { let __ptr = G::from_usize(__mq.len()); __mq.insert(&__values[..], &[__ptr], G::from_bool(!unconstrained)); __ptr } }; - let __ret: [G; OUT_510] = [__v_32]; - if let Some(result) = record.function_queries[510].get_mut(&inp[..]) { debug_assert_eq!(result.output, &__ret[..]); if !unconstrained { *result.multiplicity += G::ONE; } } else { record.function_queries[510].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained)); }; + let __ret: [G; OUT_506] = [__v_32]; + if let Some(result) = record.function_queries[506].get_mut(&inp[..]) { debug_assert_eq!(result.output, &__ret[..]); if !unconstrained { *result.multiplicity += G::ONE; } } else { record.function_queries[506].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained)); }; return Ok(__ret); }) } -const INPUT_SIZE_511: usize = 0; -const IN_511: usize = 0; -const OUT_511: usize = 1; -fn aiur_fn_511( - inp: [G; IN_511], +const INPUT_SIZE_507: usize = 0; +const IN_507: usize = 0; +const OUT_507: usize = 1; +fn aiur_fn_507( + inp: [G; IN_507], record: &mut QueryRecord, io_buffer: &mut IOBuffer, unconstrained: bool, -) -> Result<[G; OUT_511], ExecError> { +) -> Result<[G; OUT_507], ExecError> { stacker::maybe_grow(64 * 1024, 4 * 1024 * 1024, || { let __v_0: G = G::from_u64(108); let __v_1: G = G::from_u64(155); @@ -44748,21 +44464,21 @@ fn aiur_fn_511( let __v_30: G = G::from_u64(173); let __v_31: G = G::from_u64(206); let __v_32: G = { let __values: [G; 32] = [__v_0, __v_1, __v_2, __v_3, __v_4, __v_5, __v_6, __v_7, __v_8, __v_9, __v_10, __v_11, __v_12, __v_13, __v_14, __v_15, __v_16, __v_17, __v_18, __v_19, __v_20, __v_21, __v_22, __v_23, __v_24, __v_25, __v_26, __v_27, __v_28, __v_29, __v_30, __v_31]; let __mq = record.memory_queries.get_mut(&32).ok_or(ExecError::InvalidMemorySize(32))?; if let Some(result) = __mq.get_mut(&__values[..]) { if !unconstrained { *result.multiplicity += G::ONE; } result.output[0] } else { let __ptr = G::from_usize(__mq.len()); __mq.insert(&__values[..], &[__ptr], G::from_bool(!unconstrained)); __ptr } }; - let __ret: [G; OUT_511] = [__v_32]; - if let Some(result) = record.function_queries[511].get_mut(&inp[..]) { debug_assert_eq!(result.output, &__ret[..]); if !unconstrained { *result.multiplicity += G::ONE; } } else { record.function_queries[511].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained)); }; + let __ret: [G; OUT_507] = [__v_32]; + if let Some(result) = record.function_queries[507].get_mut(&inp[..]) { debug_assert_eq!(result.output, &__ret[..]); if !unconstrained { *result.multiplicity += G::ONE; } } else { record.function_queries[507].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained)); }; return Ok(__ret); }) } -const INPUT_SIZE_512: usize = 0; -const IN_512: usize = 0; -const OUT_512: usize = 1; -fn aiur_fn_512( - inp: [G; IN_512], +const INPUT_SIZE_508: usize = 0; +const IN_508: usize = 0; +const OUT_508: usize = 1; +fn aiur_fn_508( + inp: [G; IN_508], record: &mut QueryRecord, io_buffer: &mut IOBuffer, unconstrained: bool, -) -> Result<[G; OUT_512], ExecError> { +) -> Result<[G; OUT_508], ExecError> { stacker::maybe_grow(64 * 1024, 4 * 1024 * 1024, || { let __v_0: G = G::from_u64(15); let __v_1: G = G::from_u64(83); @@ -44797,21 +44513,21 @@ fn aiur_fn_512( let __v_30: G = G::from_u64(244); let __v_31: G = G::from_u64(248); let __v_32: G = { let __values: [G; 32] = [__v_0, __v_1, __v_2, __v_3, __v_4, __v_5, __v_6, __v_7, __v_8, __v_9, __v_10, __v_11, __v_12, __v_13, __v_14, __v_15, __v_16, __v_17, __v_18, __v_19, __v_20, __v_21, __v_22, __v_23, __v_24, __v_25, __v_26, __v_27, __v_28, __v_29, __v_30, __v_31]; let __mq = record.memory_queries.get_mut(&32).ok_or(ExecError::InvalidMemorySize(32))?; if let Some(result) = __mq.get_mut(&__values[..]) { if !unconstrained { *result.multiplicity += G::ONE; } result.output[0] } else { let __ptr = G::from_usize(__mq.len()); __mq.insert(&__values[..], &[__ptr], G::from_bool(!unconstrained)); __ptr } }; - let __ret: [G; OUT_512] = [__v_32]; - if let Some(result) = record.function_queries[512].get_mut(&inp[..]) { debug_assert_eq!(result.output, &__ret[..]); if !unconstrained { *result.multiplicity += G::ONE; } } else { record.function_queries[512].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained)); }; + let __ret: [G; OUT_508] = [__v_32]; + if let Some(result) = record.function_queries[508].get_mut(&inp[..]) { debug_assert_eq!(result.output, &__ret[..]); if !unconstrained { *result.multiplicity += G::ONE; } } else { record.function_queries[508].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained)); }; return Ok(__ret); }) } -const INPUT_SIZE_513: usize = 0; -const IN_513: usize = 0; -const OUT_513: usize = 1; -fn aiur_fn_513( - inp: [G; IN_513], +const INPUT_SIZE_509: usize = 0; +const IN_509: usize = 0; +const OUT_509: usize = 1; +fn aiur_fn_509( + inp: [G; IN_509], record: &mut QueryRecord, io_buffer: &mut IOBuffer, unconstrained: bool, -) -> Result<[G; OUT_513], ExecError> { +) -> Result<[G; OUT_509], ExecError> { stacker::maybe_grow(64 * 1024, 4 * 1024 * 1024, || { let __v_0: G = G::from_u64(14); let __v_1: G = G::from_u64(95); @@ -44846,21 +44562,21 @@ fn aiur_fn_513( let __v_30: G = G::from_u64(63); let __v_31: G = G::from_u64(174); let __v_32: G = { let __values: [G; 32] = [__v_0, __v_1, __v_2, __v_3, __v_4, __v_5, __v_6, __v_7, __v_8, __v_9, __v_10, __v_11, __v_12, __v_13, __v_14, __v_15, __v_16, __v_17, __v_18, __v_19, __v_20, __v_21, __v_22, __v_23, __v_24, __v_25, __v_26, __v_27, __v_28, __v_29, __v_30, __v_31]; let __mq = record.memory_queries.get_mut(&32).ok_or(ExecError::InvalidMemorySize(32))?; if let Some(result) = __mq.get_mut(&__values[..]) { if !unconstrained { *result.multiplicity += G::ONE; } result.output[0] } else { let __ptr = G::from_usize(__mq.len()); __mq.insert(&__values[..], &[__ptr], G::from_bool(!unconstrained)); __ptr } }; - let __ret: [G; OUT_513] = [__v_32]; - if let Some(result) = record.function_queries[513].get_mut(&inp[..]) { debug_assert_eq!(result.output, &__ret[..]); if !unconstrained { *result.multiplicity += G::ONE; } } else { record.function_queries[513].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained)); }; + let __ret: [G; OUT_509] = [__v_32]; + if let Some(result) = record.function_queries[509].get_mut(&inp[..]) { debug_assert_eq!(result.output, &__ret[..]); if !unconstrained { *result.multiplicity += G::ONE; } } else { record.function_queries[509].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained)); }; return Ok(__ret); }) } -const INPUT_SIZE_514: usize = 0; -const IN_514: usize = 0; -const OUT_514: usize = 1; -fn aiur_fn_514( - inp: [G; IN_514], +const INPUT_SIZE_510: usize = 0; +const IN_510: usize = 0; +const OUT_510: usize = 1; +fn aiur_fn_510( + inp: [G; IN_510], record: &mut QueryRecord, io_buffer: &mut IOBuffer, unconstrained: bool, -) -> Result<[G; OUT_514], ExecError> { +) -> Result<[G; OUT_510], ExecError> { stacker::maybe_grow(64 * 1024, 4 * 1024 * 1024, || { let __v_0: G = G::from_u64(206); let __v_1: G = G::from_u64(19); @@ -44895,98 +44611,98 @@ fn aiur_fn_514( let __v_30: G = G::from_u64(16); let __v_31: G = G::from_u64(140); let __v_32: G = { let __values: [G; 32] = [__v_0, __v_1, __v_2, __v_3, __v_4, __v_5, __v_6, __v_7, __v_8, __v_9, __v_10, __v_11, __v_12, __v_13, __v_14, __v_15, __v_16, __v_17, __v_18, __v_19, __v_20, __v_21, __v_22, __v_23, __v_24, __v_25, __v_26, __v_27, __v_28, __v_29, __v_30, __v_31]; let __mq = record.memory_queries.get_mut(&32).ok_or(ExecError::InvalidMemorySize(32))?; if let Some(result) = __mq.get_mut(&__values[..]) { if !unconstrained { *result.multiplicity += G::ONE; } result.output[0] } else { let __ptr = G::from_usize(__mq.len()); __mq.insert(&__values[..], &[__ptr], G::from_bool(!unconstrained)); __ptr } }; - let __ret: [G; OUT_514] = [__v_32]; - if let Some(result) = record.function_queries[514].get_mut(&inp[..]) { debug_assert_eq!(result.output, &__ret[..]); if !unconstrained { *result.multiplicity += G::ONE; } } else { record.function_queries[514].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained)); }; + let __ret: [G; OUT_510] = [__v_32]; + if let Some(result) = record.function_queries[510].get_mut(&inp[..]) { debug_assert_eq!(result.output, &__ret[..]); if !unconstrained { *result.multiplicity += G::ONE; } } else { record.function_queries[510].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained)); }; return Ok(__ret); }) } -const INPUT_SIZE_515: usize = 1; -const IN_515: usize = 1; -const OUT_515: usize = 1; -fn aiur_fn_515( - inp: [G; IN_515], +const INPUT_SIZE_511: usize = 1; +const IN_511: usize = 1; +const OUT_511: usize = 1; +fn aiur_fn_511( + inp: [G; IN_511], record: &mut QueryRecord, io_buffer: &mut IOBuffer, unconstrained: bool, -) -> Result<[G; OUT_515], ExecError> { +) -> Result<[G; OUT_511], ExecError> { stacker::maybe_grow(64 * 1024, 4 * 1024 * 1024, || { let __v_0: G = inp[0]; - let __r_arr: [G; OUT_501] = { let __args: [G; IN_501] = []; let __cu = unconstrained; if let Some(result) = record.function_queries[501].get_mut(&__args[..]) { if !__cu && *result.multiplicity == G::ZERO { aiur_fn_501(__args, record, io_buffer, false)? } else { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_501] = unsafe { *(result.output.as_ptr() as *const [G; OUT_501]) }; __ret } } else { aiur_fn_501(__args, record, io_buffer, __cu)? } }; + let __r_arr: [G; OUT_497] = { let __args: [G; IN_497] = []; let __cu = unconstrained; if let Some(result) = record.function_queries[497].get_mut(&__args[..]) { if !__cu && *result.multiplicity == G::ZERO { aiur_fn_497(__args, record, io_buffer, false)? } else { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_497] = unsafe { *(result.output.as_ptr() as *const [G; OUT_497]) }; __ret } } else { aiur_fn_497(__args, record, io_buffer, __cu)? } }; let __v_1: G = __r_arr[0]; let __r_arr: [G; OUT_1] = { let __args: [G; IN_1] = [__v_0, __v_1]; let __cu = unconstrained; if let Some(result) = record.function_queries[1].get_mut(&__args[..]) { if !__cu && *result.multiplicity == G::ZERO { aiur_fn_1(__args, record, io_buffer, false)? } else { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_1] = unsafe { *(result.output.as_ptr() as *const [G; OUT_1]) }; __ret } } else { aiur_fn_1(__args, record, io_buffer, __cu)? } }; let __v_2: G = __r_arr[0]; match __v_2.as_canonical_u64() { 1u64 => { let __v_3: G = G::from_u64(1); - let __ret: [G; OUT_515] = [__v_3]; - if let Some(result) = record.function_queries[515].get_mut(&inp[..]) { debug_assert_eq!(result.output, &__ret[..]); if !unconstrained { *result.multiplicity += G::ONE; } } else { record.function_queries[515].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained)); }; + let __ret: [G; OUT_511] = [__v_3]; + if let Some(result) = record.function_queries[511].get_mut(&inp[..]) { debug_assert_eq!(result.output, &__ret[..]); if !unconstrained { *result.multiplicity += G::ONE; } } else { record.function_queries[511].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained)); }; return Ok(__ret); }, _ => { - let __r_arr: [G; OUT_502] = { let __args: [G; IN_502] = []; let __cu = unconstrained; if let Some(result) = record.function_queries[502].get_mut(&__args[..]) { if !__cu && *result.multiplicity == G::ZERO { aiur_fn_502(__args, record, io_buffer, false)? } else { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_502] = unsafe { *(result.output.as_ptr() as *const [G; OUT_502]) }; __ret } } else { aiur_fn_502(__args, record, io_buffer, __cu)? } }; + let __r_arr: [G; OUT_498] = { let __args: [G; IN_498] = []; let __cu = unconstrained; if let Some(result) = record.function_queries[498].get_mut(&__args[..]) { if !__cu && *result.multiplicity == G::ZERO { aiur_fn_498(__args, record, io_buffer, false)? } else { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_498] = unsafe { *(result.output.as_ptr() as *const [G; OUT_498]) }; __ret } } else { aiur_fn_498(__args, record, io_buffer, __cu)? } }; let __v_3: G = __r_arr[0]; let __r_arr: [G; OUT_1] = { let __args: [G; IN_1] = [__v_0, __v_3]; let __cu = unconstrained; if let Some(result) = record.function_queries[1].get_mut(&__args[..]) { if !__cu && *result.multiplicity == G::ZERO { aiur_fn_1(__args, record, io_buffer, false)? } else { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_1] = unsafe { *(result.output.as_ptr() as *const [G; OUT_1]) }; __ret } } else { aiur_fn_1(__args, record, io_buffer, __cu)? } }; let __v_4: G = __r_arr[0]; match __v_4.as_canonical_u64() { 1u64 => { let __v_5: G = G::from_u64(1); - let __ret: [G; OUT_515] = [__v_5]; - if let Some(result) = record.function_queries[515].get_mut(&inp[..]) { debug_assert_eq!(result.output, &__ret[..]); if !unconstrained { *result.multiplicity += G::ONE; } } else { record.function_queries[515].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained)); }; + let __ret: [G; OUT_511] = [__v_5]; + if let Some(result) = record.function_queries[511].get_mut(&inp[..]) { debug_assert_eq!(result.output, &__ret[..]); if !unconstrained { *result.multiplicity += G::ONE; } } else { record.function_queries[511].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained)); }; return Ok(__ret); }, _ => { - let __r_arr: [G; OUT_503] = { let __args: [G; IN_503] = []; let __cu = unconstrained; if let Some(result) = record.function_queries[503].get_mut(&__args[..]) { if !__cu && *result.multiplicity == G::ZERO { aiur_fn_503(__args, record, io_buffer, false)? } else { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_503] = unsafe { *(result.output.as_ptr() as *const [G; OUT_503]) }; __ret } } else { aiur_fn_503(__args, record, io_buffer, __cu)? } }; + let __r_arr: [G; OUT_499] = { let __args: [G; IN_499] = []; let __cu = unconstrained; if let Some(result) = record.function_queries[499].get_mut(&__args[..]) { if !__cu && *result.multiplicity == G::ZERO { aiur_fn_499(__args, record, io_buffer, false)? } else { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_499] = unsafe { *(result.output.as_ptr() as *const [G; OUT_499]) }; __ret } } else { aiur_fn_499(__args, record, io_buffer, __cu)? } }; let __v_5: G = __r_arr[0]; let __r_arr: [G; OUT_1] = { let __args: [G; IN_1] = [__v_0, __v_5]; let __cu = unconstrained; if let Some(result) = record.function_queries[1].get_mut(&__args[..]) { if !__cu && *result.multiplicity == G::ZERO { aiur_fn_1(__args, record, io_buffer, false)? } else { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_1] = unsafe { *(result.output.as_ptr() as *const [G; OUT_1]) }; __ret } } else { aiur_fn_1(__args, record, io_buffer, __cu)? } }; let __v_6: G = __r_arr[0]; match __v_6.as_canonical_u64() { 1u64 => { let __v_7: G = G::from_u64(1); - let __ret: [G; OUT_515] = [__v_7]; - if let Some(result) = record.function_queries[515].get_mut(&inp[..]) { debug_assert_eq!(result.output, &__ret[..]); if !unconstrained { *result.multiplicity += G::ONE; } } else { record.function_queries[515].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained)); }; + let __ret: [G; OUT_511] = [__v_7]; + if let Some(result) = record.function_queries[511].get_mut(&inp[..]) { debug_assert_eq!(result.output, &__ret[..]); if !unconstrained { *result.multiplicity += G::ONE; } } else { record.function_queries[511].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained)); }; return Ok(__ret); }, _ => { - let __r_arr: [G; OUT_513] = { let __args: [G; IN_513] = []; let __cu = unconstrained; if let Some(result) = record.function_queries[513].get_mut(&__args[..]) { if !__cu && *result.multiplicity == G::ZERO { aiur_fn_513(__args, record, io_buffer, false)? } else { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_513] = unsafe { *(result.output.as_ptr() as *const [G; OUT_513]) }; __ret } } else { aiur_fn_513(__args, record, io_buffer, __cu)? } }; + let __r_arr: [G; OUT_509] = { let __args: [G; IN_509] = []; let __cu = unconstrained; if let Some(result) = record.function_queries[509].get_mut(&__args[..]) { if !__cu && *result.multiplicity == G::ZERO { aiur_fn_509(__args, record, io_buffer, false)? } else { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_509] = unsafe { *(result.output.as_ptr() as *const [G; OUT_509]) }; __ret } } else { aiur_fn_509(__args, record, io_buffer, __cu)? } }; let __v_7: G = __r_arr[0]; let __r_arr: [G; OUT_1] = { let __args: [G; IN_1] = [__v_0, __v_7]; let __cu = unconstrained; if let Some(result) = record.function_queries[1].get_mut(&__args[..]) { if !__cu && *result.multiplicity == G::ZERO { aiur_fn_1(__args, record, io_buffer, false)? } else { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_1] = unsafe { *(result.output.as_ptr() as *const [G; OUT_1]) }; __ret } } else { aiur_fn_1(__args, record, io_buffer, __cu)? } }; let __v_8: G = __r_arr[0]; match __v_8.as_canonical_u64() { 1u64 => { let __v_9: G = G::from_u64(1); - let __ret: [G; OUT_515] = [__v_9]; - if let Some(result) = record.function_queries[515].get_mut(&inp[..]) { debug_assert_eq!(result.output, &__ret[..]); if !unconstrained { *result.multiplicity += G::ONE; } } else { record.function_queries[515].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained)); }; + let __ret: [G; OUT_511] = [__v_9]; + if let Some(result) = record.function_queries[511].get_mut(&inp[..]) { debug_assert_eq!(result.output, &__ret[..]); if !unconstrained { *result.multiplicity += G::ONE; } } else { record.function_queries[511].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained)); }; return Ok(__ret); }, _ => { - let __r_arr: [G; OUT_512] = { let __args: [G; IN_512] = []; let __cu = unconstrained; if let Some(result) = record.function_queries[512].get_mut(&__args[..]) { if !__cu && *result.multiplicity == G::ZERO { aiur_fn_512(__args, record, io_buffer, false)? } else { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_512] = unsafe { *(result.output.as_ptr() as *const [G; OUT_512]) }; __ret } } else { aiur_fn_512(__args, record, io_buffer, __cu)? } }; + let __r_arr: [G; OUT_508] = { let __args: [G; IN_508] = []; let __cu = unconstrained; if let Some(result) = record.function_queries[508].get_mut(&__args[..]) { if !__cu && *result.multiplicity == G::ZERO { aiur_fn_508(__args, record, io_buffer, false)? } else { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_508] = unsafe { *(result.output.as_ptr() as *const [G; OUT_508]) }; __ret } } else { aiur_fn_508(__args, record, io_buffer, __cu)? } }; let __v_9: G = __r_arr[0]; let __r_arr: [G; OUT_1] = { let __args: [G; IN_1] = [__v_0, __v_9]; let __cu = unconstrained; if let Some(result) = record.function_queries[1].get_mut(&__args[..]) { if !__cu && *result.multiplicity == G::ZERO { aiur_fn_1(__args, record, io_buffer, false)? } else { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_1] = unsafe { *(result.output.as_ptr() as *const [G; OUT_1]) }; __ret } } else { aiur_fn_1(__args, record, io_buffer, __cu)? } }; let __v_10: G = __r_arr[0]; match __v_10.as_canonical_u64() { 1u64 => { let __v_11: G = G::from_u64(1); - let __ret: [G; OUT_515] = [__v_11]; - if let Some(result) = record.function_queries[515].get_mut(&inp[..]) { debug_assert_eq!(result.output, &__ret[..]); if !unconstrained { *result.multiplicity += G::ONE; } } else { record.function_queries[515].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained)); }; + let __ret: [G; OUT_511] = [__v_11]; + if let Some(result) = record.function_queries[511].get_mut(&inp[..]) { debug_assert_eq!(result.output, &__ret[..]); if !unconstrained { *result.multiplicity += G::ONE; } } else { record.function_queries[511].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained)); }; return Ok(__ret); }, _ => { - let __r_arr: [G; OUT_514] = { let __args: [G; IN_514] = []; let __cu = unconstrained; if let Some(result) = record.function_queries[514].get_mut(&__args[..]) { if !__cu && *result.multiplicity == G::ZERO { aiur_fn_514(__args, record, io_buffer, false)? } else { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_514] = unsafe { *(result.output.as_ptr() as *const [G; OUT_514]) }; __ret } } else { aiur_fn_514(__args, record, io_buffer, __cu)? } }; + let __r_arr: [G; OUT_510] = { let __args: [G; IN_510] = []; let __cu = unconstrained; if let Some(result) = record.function_queries[510].get_mut(&__args[..]) { if !__cu && *result.multiplicity == G::ZERO { aiur_fn_510(__args, record, io_buffer, false)? } else { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_510] = unsafe { *(result.output.as_ptr() as *const [G; OUT_510]) }; __ret } } else { aiur_fn_510(__args, record, io_buffer, __cu)? } }; let __v_11: G = __r_arr[0]; let __r_arr: [G; OUT_1] = { let __args: [G; IN_1] = [__v_0, __v_11]; let __cu = unconstrained; if let Some(result) = record.function_queries[1].get_mut(&__args[..]) { if !__cu && *result.multiplicity == G::ZERO { aiur_fn_1(__args, record, io_buffer, false)? } else { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_1] = unsafe { *(result.output.as_ptr() as *const [G; OUT_1]) }; __ret } } else { aiur_fn_1(__args, record, io_buffer, __cu)? } }; let __v_12: G = __r_arr[0]; match __v_12.as_canonical_u64() { 1u64 => { let __v_13: G = G::from_u64(1); - let __ret: [G; OUT_515] = [__v_13]; - if let Some(result) = record.function_queries[515].get_mut(&inp[..]) { debug_assert_eq!(result.output, &__ret[..]); if !unconstrained { *result.multiplicity += G::ONE; } } else { record.function_queries[515].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained)); }; + let __ret: [G; OUT_511] = [__v_13]; + if let Some(result) = record.function_queries[511].get_mut(&inp[..]) { debug_assert_eq!(result.output, &__ret[..]); if !unconstrained { *result.multiplicity += G::ONE; } } else { record.function_queries[511].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained)); }; return Ok(__ret); }, _ => { let __v_13: G = G::from_u64(0); - let __ret: [G; OUT_515] = [__v_13]; - if let Some(result) = record.function_queries[515].get_mut(&inp[..]) { debug_assert_eq!(result.output, &__ret[..]); if !unconstrained { *result.multiplicity += G::ONE; } } else { record.function_queries[515].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained)); }; + let __ret: [G; OUT_511] = [__v_13]; + if let Some(result) = record.function_queries[511].get_mut(&inp[..]) { debug_assert_eq!(result.output, &__ret[..]); if !unconstrained { *result.multiplicity += G::ONE; } } else { record.function_queries[511].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained)); }; return Ok(__ret); }, } @@ -45003,56 +44719,56 @@ fn aiur_fn_515( }) } -const INPUT_SIZE_516: usize = 1; -const IN_516: usize = 1; -const OUT_516: usize = 1; -fn aiur_fn_516( - inp: [G; IN_516], +const INPUT_SIZE_512: usize = 1; +const IN_512: usize = 1; +const OUT_512: usize = 1; +fn aiur_fn_512( + inp: [G; IN_512], record: &mut QueryRecord, io_buffer: &mut IOBuffer, unconstrained: bool, -) -> Result<[G; OUT_516], ExecError> { +) -> Result<[G; OUT_512], ExecError> { stacker::maybe_grow(64 * 1024, 4 * 1024 * 1024, || { let __v_0: G = inp[0]; - let __r_arr: [G; OUT_513] = { let __args: [G; IN_513] = []; let __cu = unconstrained; if let Some(result) = record.function_queries[513].get_mut(&__args[..]) { if !__cu && *result.multiplicity == G::ZERO { aiur_fn_513(__args, record, io_buffer, false)? } else { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_513] = unsafe { *(result.output.as_ptr() as *const [G; OUT_513]) }; __ret } } else { aiur_fn_513(__args, record, io_buffer, __cu)? } }; + let __r_arr: [G; OUT_509] = { let __args: [G; IN_509] = []; let __cu = unconstrained; if let Some(result) = record.function_queries[509].get_mut(&__args[..]) { if !__cu && *result.multiplicity == G::ZERO { aiur_fn_509(__args, record, io_buffer, false)? } else { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_509] = unsafe { *(result.output.as_ptr() as *const [G; OUT_509]) }; __ret } } else { aiur_fn_509(__args, record, io_buffer, __cu)? } }; let __v_1: G = __r_arr[0]; let __r_arr: [G; OUT_1] = { let __args: [G; IN_1] = [__v_0, __v_1]; let __cu = unconstrained; if let Some(result) = record.function_queries[1].get_mut(&__args[..]) { if !__cu && *result.multiplicity == G::ZERO { aiur_fn_1(__args, record, io_buffer, false)? } else { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_1] = unsafe { *(result.output.as_ptr() as *const [G; OUT_1]) }; __ret } } else { aiur_fn_1(__args, record, io_buffer, __cu)? } }; let __v_2: G = __r_arr[0]; match __v_2.as_canonical_u64() { 1u64 => { let __v_3: G = G::from_u64(1); - let __ret: [G; OUT_516] = [__v_3]; - if let Some(result) = record.function_queries[516].get_mut(&inp[..]) { debug_assert_eq!(result.output, &__ret[..]); if !unconstrained { *result.multiplicity += G::ONE; } } else { record.function_queries[516].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained)); }; + let __ret: [G; OUT_512] = [__v_3]; + if let Some(result) = record.function_queries[512].get_mut(&inp[..]) { debug_assert_eq!(result.output, &__ret[..]); if !unconstrained { *result.multiplicity += G::ONE; } } else { record.function_queries[512].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained)); }; return Ok(__ret); }, _ => { - let __r_arr: [G; OUT_512] = { let __args: [G; IN_512] = []; let __cu = unconstrained; if let Some(result) = record.function_queries[512].get_mut(&__args[..]) { if !__cu && *result.multiplicity == G::ZERO { aiur_fn_512(__args, record, io_buffer, false)? } else { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_512] = unsafe { *(result.output.as_ptr() as *const [G; OUT_512]) }; __ret } } else { aiur_fn_512(__args, record, io_buffer, __cu)? } }; + let __r_arr: [G; OUT_508] = { let __args: [G; IN_508] = []; let __cu = unconstrained; if let Some(result) = record.function_queries[508].get_mut(&__args[..]) { if !__cu && *result.multiplicity == G::ZERO { aiur_fn_508(__args, record, io_buffer, false)? } else { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_508] = unsafe { *(result.output.as_ptr() as *const [G; OUT_508]) }; __ret } } else { aiur_fn_508(__args, record, io_buffer, __cu)? } }; let __v_3: G = __r_arr[0]; let __r_arr: [G; OUT_1] = { let __args: [G; IN_1] = [__v_0, __v_3]; let __cu = unconstrained; if let Some(result) = record.function_queries[1].get_mut(&__args[..]) { if !__cu && *result.multiplicity == G::ZERO { aiur_fn_1(__args, record, io_buffer, false)? } else { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_1] = unsafe { *(result.output.as_ptr() as *const [G; OUT_1]) }; __ret } } else { aiur_fn_1(__args, record, io_buffer, __cu)? } }; let __v_4: G = __r_arr[0]; match __v_4.as_canonical_u64() { 1u64 => { let __v_5: G = G::from_u64(1); - let __ret: [G; OUT_516] = [__v_5]; - if let Some(result) = record.function_queries[516].get_mut(&inp[..]) { debug_assert_eq!(result.output, &__ret[..]); if !unconstrained { *result.multiplicity += G::ONE; } } else { record.function_queries[516].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained)); }; + let __ret: [G; OUT_512] = [__v_5]; + if let Some(result) = record.function_queries[512].get_mut(&inp[..]) { debug_assert_eq!(result.output, &__ret[..]); if !unconstrained { *result.multiplicity += G::ONE; } } else { record.function_queries[512].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained)); }; return Ok(__ret); }, _ => { - let __r_arr: [G; OUT_514] = { let __args: [G; IN_514] = []; let __cu = unconstrained; if let Some(result) = record.function_queries[514].get_mut(&__args[..]) { if !__cu && *result.multiplicity == G::ZERO { aiur_fn_514(__args, record, io_buffer, false)? } else { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_514] = unsafe { *(result.output.as_ptr() as *const [G; OUT_514]) }; __ret } } else { aiur_fn_514(__args, record, io_buffer, __cu)? } }; + let __r_arr: [G; OUT_510] = { let __args: [G; IN_510] = []; let __cu = unconstrained; if let Some(result) = record.function_queries[510].get_mut(&__args[..]) { if !__cu && *result.multiplicity == G::ZERO { aiur_fn_510(__args, record, io_buffer, false)? } else { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_510] = unsafe { *(result.output.as_ptr() as *const [G; OUT_510]) }; __ret } } else { aiur_fn_510(__args, record, io_buffer, __cu)? } }; let __v_5: G = __r_arr[0]; let __r_arr: [G; OUT_1] = { let __args: [G; IN_1] = [__v_0, __v_5]; let __cu = unconstrained; if let Some(result) = record.function_queries[1].get_mut(&__args[..]) { if !__cu && *result.multiplicity == G::ZERO { aiur_fn_1(__args, record, io_buffer, false)? } else { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_1] = unsafe { *(result.output.as_ptr() as *const [G; OUT_1]) }; __ret } } else { aiur_fn_1(__args, record, io_buffer, __cu)? } }; let __v_6: G = __r_arr[0]; match __v_6.as_canonical_u64() { 1u64 => { let __v_7: G = G::from_u64(1); - let __ret: [G; OUT_516] = [__v_7]; - if let Some(result) = record.function_queries[516].get_mut(&inp[..]) { debug_assert_eq!(result.output, &__ret[..]); if !unconstrained { *result.multiplicity += G::ONE; } } else { record.function_queries[516].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained)); }; + let __ret: [G; OUT_512] = [__v_7]; + if let Some(result) = record.function_queries[512].get_mut(&inp[..]) { debug_assert_eq!(result.output, &__ret[..]); if !unconstrained { *result.multiplicity += G::ONE; } } else { record.function_queries[512].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained)); }; return Ok(__ret); }, _ => { let __v_7: G = G::from_u64(0); - let __ret: [G; OUT_516] = [__v_7]; - if let Some(result) = record.function_queries[516].get_mut(&inp[..]) { debug_assert_eq!(result.output, &__ret[..]); if !unconstrained { *result.multiplicity += G::ONE; } } else { record.function_queries[516].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained)); }; + let __ret: [G; OUT_512] = [__v_7]; + if let Some(result) = record.function_queries[512].get_mut(&inp[..]) { debug_assert_eq!(result.output, &__ret[..]); if !unconstrained { *result.multiplicity += G::ONE; } } else { record.function_queries[512].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained)); }; return Ok(__ret); }, } @@ -45063,15 +44779,15 @@ fn aiur_fn_516( }) } -const INPUT_SIZE_517: usize = 1; -const IN_517: usize = 1; -const OUT_517: usize = 3; -fn aiur_fn_517( - inp: [G; IN_517], +const INPUT_SIZE_513: usize = 1; +const IN_513: usize = 1; +const OUT_513: usize = 3; +fn aiur_fn_513( + inp: [G; IN_513], record: &mut QueryRecord, io_buffer: &mut IOBuffer, unconstrained: bool, -) -> Result<[G; OUT_517], ExecError> { +) -> Result<[G; OUT_513], ExecError> { stacker::maybe_grow(64 * 1024, 4 * 1024 * 1024, || { let __v_0: G = inp[0]; let __loaded: [G; 4] = { let __mq = record.memory_queries.get_mut(&4).ok_or(ExecError::InvalidMemorySize(4))?; let __ptr_u64 = __v_0.as_canonical_u64(); let __ptr_usize = usize::try_from(__ptr_u64).ok().ok_or(ExecError::PointerTooLarge(__ptr_u64))?; let (__args, __mult) = __mq.get_index_mut(__ptr_usize).ok_or(ExecError::UnboundPointer { ptr: __ptr_u64, size: 4 })?; if !unconstrained { *__mult += G::ONE; } let __arr: [G; 4] = __args[..4].try_into().unwrap(); __arr }; @@ -45104,8 +44820,8 @@ fn aiur_fn_517( let __v_16: G = G::from_u64(1); let __v_17: G = G::from_u64(1); let __v_18: G = { let __values: [G; 10] = [__v_16, __v_17, __v_17, __v_17, __v_17, __v_17, __v_17, __v_17, __v_17, __v_17]; let __mq = record.memory_queries.get_mut(&10).ok_or(ExecError::InvalidMemorySize(10))?; if let Some(result) = __mq.get_mut(&__values[..]) { if !unconstrained { *result.multiplicity += G::ONE; } result.output[0] } else { let __ptr = G::from_usize(__mq.len()); __mq.insert(&__values[..], &[__ptr], G::from_bool(!unconstrained)); __ptr } }; - let __ret: [G; OUT_517] = [__v_14, __v_15, __v_18]; - if let Some(result) = record.function_queries[517].get_mut(&inp[..]) { debug_assert_eq!(result.output, &__ret[..]); if !unconstrained { *result.multiplicity += G::ONE; } } else { record.function_queries[517].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained)); }; + let __ret: [G; OUT_513] = [__v_14, __v_15, __v_18]; + if let Some(result) = record.function_queries[513].get_mut(&inp[..]) { debug_assert_eq!(result.output, &__ret[..]); if !unconstrained { *result.multiplicity += G::ONE; } } else { record.function_queries[513].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained)); }; return Ok(__ret); }, _ => { @@ -45119,8 +44835,8 @@ fn aiur_fn_517( match __v_15.as_canonical_u64() { 0u64 => { let __v_18: G = G::from_u64(1); - let __ret: [G; OUT_517] = [__v_18, __v_12, __v_16]; - if let Some(result) = record.function_queries[517].get_mut(&inp[..]) { debug_assert_eq!(result.output, &__ret[..]); if !unconstrained { *result.multiplicity += G::ONE; } } else { record.function_queries[517].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained)); }; + let __ret: [G; OUT_513] = [__v_18, __v_12, __v_16]; + if let Some(result) = record.function_queries[513].get_mut(&inp[..]) { debug_assert_eq!(result.output, &__ret[..]); if !unconstrained { *result.multiplicity += G::ONE; } } else { record.function_queries[513].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained)); }; return Ok(__ret); }, _ => { @@ -45129,8 +44845,8 @@ fn aiur_fn_517( let __v_20: G = G::from_u64(1); let __v_21: G = G::from_u64(1); let __v_22: G = { let __values: [G; 10] = [__v_20, __v_21, __v_21, __v_21, __v_21, __v_21, __v_21, __v_21, __v_21, __v_21]; let __mq = record.memory_queries.get_mut(&10).ok_or(ExecError::InvalidMemorySize(10))?; if let Some(result) = __mq.get_mut(&__values[..]) { if !unconstrained { *result.multiplicity += G::ONE; } result.output[0] } else { let __ptr = G::from_usize(__mq.len()); __mq.insert(&__values[..], &[__ptr], G::from_bool(!unconstrained)); __ptr } }; - let __ret: [G; OUT_517] = [__v_18, __v_19, __v_22]; - if let Some(result) = record.function_queries[517].get_mut(&inp[..]) { debug_assert_eq!(result.output, &__ret[..]); if !unconstrained { *result.multiplicity += G::ONE; } } else { record.function_queries[517].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained)); }; + let __ret: [G; OUT_513] = [__v_18, __v_19, __v_22]; + if let Some(result) = record.function_queries[513].get_mut(&inp[..]) { debug_assert_eq!(result.output, &__ret[..]); if !unconstrained { *result.multiplicity += G::ONE; } } else { record.function_queries[513].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained)); }; return Ok(__ret); }, } @@ -45141,8 +44857,8 @@ fn aiur_fn_517( let __v_20: G = G::from_u64(1); let __v_21: G = G::from_u64(1); let __v_22: G = { let __values: [G; 10] = [__v_20, __v_21, __v_21, __v_21, __v_21, __v_21, __v_21, __v_21, __v_21, __v_21]; let __mq = record.memory_queries.get_mut(&10).ok_or(ExecError::InvalidMemorySize(10))?; if let Some(result) = __mq.get_mut(&__values[..]) { if !unconstrained { *result.multiplicity += G::ONE; } result.output[0] } else { let __ptr = G::from_usize(__mq.len()); __mq.insert(&__values[..], &[__ptr], G::from_bool(!unconstrained)); __ptr } }; - let __ret: [G; OUT_517] = [__v_18, __v_19, __v_22]; - if let Some(result) = record.function_queries[517].get_mut(&inp[..]) { debug_assert_eq!(result.output, &__ret[..]); if !unconstrained { *result.multiplicity += G::ONE; } } else { record.function_queries[517].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained)); }; + let __ret: [G; OUT_513] = [__v_18, __v_19, __v_22]; + if let Some(result) = record.function_queries[513].get_mut(&inp[..]) { debug_assert_eq!(result.output, &__ret[..]); if !unconstrained { *result.multiplicity += G::ONE; } } else { record.function_queries[513].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained)); }; return Ok(__ret); }, } @@ -45155,8 +44871,8 @@ fn aiur_fn_517( let __v_11: G = G::from_u64(1); let __v_12: G = G::from_u64(1); let __v_13: G = { let __values: [G; 10] = [__v_11, __v_12, __v_12, __v_12, __v_12, __v_12, __v_12, __v_12, __v_12, __v_12]; let __mq = record.memory_queries.get_mut(&10).ok_or(ExecError::InvalidMemorySize(10))?; if let Some(result) = __mq.get_mut(&__values[..]) { if !unconstrained { *result.multiplicity += G::ONE; } result.output[0] } else { let __ptr = G::from_usize(__mq.len()); __mq.insert(&__values[..], &[__ptr], G::from_bool(!unconstrained)); __ptr } }; - let __ret: [G; OUT_517] = [__v_9, __v_10, __v_13]; - if let Some(result) = record.function_queries[517].get_mut(&inp[..]) { debug_assert_eq!(result.output, &__ret[..]); if !unconstrained { *result.multiplicity += G::ONE; } } else { record.function_queries[517].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained)); }; + let __ret: [G; OUT_513] = [__v_9, __v_10, __v_13]; + if let Some(result) = record.function_queries[513].get_mut(&inp[..]) { debug_assert_eq!(result.output, &__ret[..]); if !unconstrained { *result.multiplicity += G::ONE; } } else { record.function_queries[513].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained)); }; return Ok(__ret); }, } @@ -45167,23 +44883,23 @@ fn aiur_fn_517( let __v_7: G = G::from_u64(1); let __v_8: G = G::from_u64(1); let __v_9: G = { let __values: [G; 10] = [__v_7, __v_8, __v_8, __v_8, __v_8, __v_8, __v_8, __v_8, __v_8, __v_8]; let __mq = record.memory_queries.get_mut(&10).ok_or(ExecError::InvalidMemorySize(10))?; if let Some(result) = __mq.get_mut(&__values[..]) { if !unconstrained { *result.multiplicity += G::ONE; } result.output[0] } else { let __ptr = G::from_usize(__mq.len()); __mq.insert(&__values[..], &[__ptr], G::from_bool(!unconstrained)); __ptr } }; - let __ret: [G; OUT_517] = [__v_5, __v_6, __v_9]; - if let Some(result) = record.function_queries[517].get_mut(&inp[..]) { debug_assert_eq!(result.output, &__ret[..]); if !unconstrained { *result.multiplicity += G::ONE; } } else { record.function_queries[517].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained)); }; + let __ret: [G; OUT_513] = [__v_5, __v_6, __v_9]; + if let Some(result) = record.function_queries[513].get_mut(&inp[..]) { debug_assert_eq!(result.output, &__ret[..]); if !unconstrained { *result.multiplicity += G::ONE; } } else { record.function_queries[513].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained)); }; return Ok(__ret); }, } }) } -const INPUT_SIZE_518: usize = 2; -const IN_518: usize = 2; -const OUT_518: usize = 1; -fn aiur_fn_518( - inp: [G; IN_518], +const INPUT_SIZE_514: usize = 2; +const IN_514: usize = 2; +const OUT_514: usize = 1; +fn aiur_fn_514( + inp: [G; IN_514], record: &mut QueryRecord, io_buffer: &mut IOBuffer, unconstrained: bool, -) -> Result<[G; OUT_518], ExecError> { +) -> Result<[G; OUT_514], ExecError> { stacker::maybe_grow(64 * 1024, 4 * 1024 * 1024, || { let __v_0: G = inp[0]; let __v_1: G = inp[1]; @@ -45214,27 +44930,27 @@ fn aiur_fn_518( let __v_13: G = G::from_u64(3); let __v_14: G = G::from_u64(0); let __v_15: G = { let __values: [G; 4] = [__v_13, __v_8, __v_12, __v_14]; let __mq = record.memory_queries.get_mut(&4).ok_or(ExecError::InvalidMemorySize(4))?; if let Some(result) = __mq.get_mut(&__values[..]) { if !unconstrained { *result.multiplicity += G::ONE; } result.output[0] } else { let __ptr = G::from_usize(__mq.len()); __mq.insert(&__values[..], &[__ptr], G::from_bool(!unconstrained)); __ptr } }; - let __ret: [G; OUT_518] = [__v_15]; - if let Some(result) = record.function_queries[518].get_mut(&inp[..]) { debug_assert_eq!(result.output, &__ret[..]); if !unconstrained { *result.multiplicity += G::ONE; } } else { record.function_queries[518].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained)); }; + let __ret: [G; OUT_514] = [__v_15]; + if let Some(result) = record.function_queries[514].get_mut(&inp[..]) { debug_assert_eq!(result.output, &__ret[..]); if !unconstrained { *result.multiplicity += G::ONE; } } else { record.function_queries[514].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained)); }; return Ok(__ret); }) } -const INPUT_SIZE_519: usize = 4; -const IN_519: usize = 4; -const OUT_519: usize = 2; -fn aiur_fn_519( - inp: [G; IN_519], +const INPUT_SIZE_515: usize = 4; +const IN_515: usize = 4; +const OUT_515: usize = 2; +fn aiur_fn_515( + inp: [G; IN_515], record: &mut QueryRecord, io_buffer: &mut IOBuffer, unconstrained: bool, -) -> Result<[G; OUT_519], ExecError> { +) -> Result<[G; OUT_515], ExecError> { stacker::maybe_grow(64 * 1024, 4 * 1024 * 1024, || { let __v_0: G = inp[0]; let __v_1: G = inp[1]; let __v_2: G = inp[2]; let __v_3: G = inp[3]; - let __r_arr: [G; OUT_764] = { let __args: [G; IN_764] = [__v_2]; let __cu = unconstrained; if let Some(result) = record.function_queries[764].get_mut(&__args[..]) { if !__cu && *result.multiplicity == G::ZERO { aiur_fn_764(__args, record, io_buffer, false)? } else { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_764] = unsafe { *(result.output.as_ptr() as *const [G; OUT_764]) }; __ret } } else { aiur_fn_764(__args, record, io_buffer, __cu)? } }; + let __r_arr: [G; OUT_760] = { let __args: [G; IN_760] = [__v_2]; let __cu = unconstrained; if let Some(result) = record.function_queries[760].get_mut(&__args[..]) { if !__cu && *result.multiplicity == G::ZERO { aiur_fn_760(__args, record, io_buffer, false)? } else { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_760] = unsafe { *(result.output.as_ptr() as *const [G; OUT_760]) }; __ret } } else { aiur_fn_760(__args, record, io_buffer, __cu)? } }; let __v_4: G = __r_arr[0]; let __v_5: G = G::from_u64(2); let __v_6: G = { let __a_val = __v_4.as_canonical_u64(); let __b_val = __v_5.as_canonical_u64(); let __a_u32 = u32::try_from(__a_val).ok().ok_or(ExecError::U32OutOfRange(__a_val))?; let __b_u32 = u32::try_from(__b_val).ok().ok_or(ExecError::U32OutOfRange(__b_val))?; let __result = G::from_bool(__a_u32 < __b_u32); if !unconstrained { let __x_bytes = __a_u32.to_le_bytes(); let __z_bytes = __b_u32.to_le_bytes(); let __c_u32 = __b_u32.wrapping_sub(__a_u32).wrapping_sub(1); let __y_bytes = __c_u32.to_le_bytes(); record.bytes2_queries.bump_range_check(&G::from_u8(__x_bytes[0]), &G::from_u8(__x_bytes[1])); record.bytes2_queries.bump_range_check(&G::from_u8(__x_bytes[2]), &G::from_u8(__x_bytes[3])); record.bytes2_queries.bump_range_check(&G::from_u8(__y_bytes[0]), &G::from_u8(__y_bytes[1])); record.bytes2_queries.bump_range_check(&G::from_u8(__y_bytes[2]), &G::from_u8(__y_bytes[3])); record.bytes2_queries.bump_range_check(&G::from_u8(__z_bytes[0]), &G::from_u8(__z_bytes[1])); record.bytes2_queries.bump_range_check(&G::from_u8(__z_bytes[2]), &G::from_u8(__z_bytes[3])); } __result }; @@ -45245,24 +44961,24 @@ fn aiur_fn_519( let __v_9: G = G::from_u64(0); let __v_10: G = G::from_u64(0); let __v_11: G = { let __values: [G; 4] = [__v_8, __v_9, __v_10, __v_10]; let __mq = record.memory_queries.get_mut(&4).ok_or(ExecError::InvalidMemorySize(4))?; if let Some(result) = __mq.get_mut(&__values[..]) { if !unconstrained { *result.multiplicity += G::ONE; } result.output[0] } else { let __ptr = G::from_usize(__mq.len()); __mq.insert(&__values[..], &[__ptr], G::from_bool(!unconstrained)); __ptr } }; - let __ret: [G; OUT_519] = [__v_7, __v_11]; - if let Some(result) = record.function_queries[519].get_mut(&inp[..]) { debug_assert_eq!(result.output, &__ret[..]); if !unconstrained { *result.multiplicity += G::ONE; } } else { record.function_queries[519].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained)); }; + let __ret: [G; OUT_515] = [__v_7, __v_11]; + if let Some(result) = record.function_queries[515].get_mut(&inp[..]) { debug_assert_eq!(result.output, &__ret[..]); if !unconstrained { *result.multiplicity += G::ONE; } } else { record.function_queries[515].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained)); }; return Ok(__ret); }, _ => { let __v_7: G = G::from_u64(0); - let __r_arr: [G; OUT_766] = { let __args: [G; IN_766] = [__v_2, __v_7]; let __cu = unconstrained; if let Some(result) = record.function_queries[766].get_mut(&__args[..]) { if !__cu && *result.multiplicity == G::ZERO { aiur_fn_766(__args, record, io_buffer, false)? } else { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_766] = unsafe { *(result.output.as_ptr() as *const [G; OUT_766]) }; __ret } } else { aiur_fn_766(__args, record, io_buffer, __cu)? } }; + let __r_arr: [G; OUT_762] = { let __args: [G; IN_762] = [__v_2, __v_7]; let __cu = unconstrained; if let Some(result) = record.function_queries[762].get_mut(&__args[..]) { if !__cu && *result.multiplicity == G::ZERO { aiur_fn_762(__args, record, io_buffer, false)? } else { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_762] = unsafe { *(result.output.as_ptr() as *const [G; OUT_762]) }; __ret } } else { aiur_fn_762(__args, record, io_buffer, __cu)? } }; let __v_8: G = __r_arr[0]; let __v_9: G = G::from_u64(1); - let __r_arr: [G; OUT_766] = { let __args: [G; IN_766] = [__v_2, __v_9]; let __cu = unconstrained; if let Some(result) = record.function_queries[766].get_mut(&__args[..]) { if !__cu && *result.multiplicity == G::ZERO { aiur_fn_766(__args, record, io_buffer, false)? } else { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_766] = unsafe { *(result.output.as_ptr() as *const [G; OUT_766]) }; __ret } } else { aiur_fn_766(__args, record, io_buffer, __cu)? } }; + let __r_arr: [G; OUT_762] = { let __args: [G; IN_762] = [__v_2, __v_9]; let __cu = unconstrained; if let Some(result) = record.function_queries[762].get_mut(&__args[..]) { if !__cu && *result.multiplicity == G::ZERO { aiur_fn_762(__args, record, io_buffer, false)? } else { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_762] = unsafe { *(result.output.as_ptr() as *const [G; OUT_762]) }; __ret } } else { aiur_fn_762(__args, record, io_buffer, __cu)? } }; let __v_10: G = __r_arr[0]; - let __r_arr: [G; OUT_517] = { let __args: [G; IN_517] = [__v_8]; let __cu = unconstrained; if let Some(result) = record.function_queries[517].get_mut(&__args[..]) { if !__cu && *result.multiplicity == G::ZERO { aiur_fn_517(__args, record, io_buffer, false)? } else { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_517] = unsafe { *(result.output.as_ptr() as *const [G; OUT_517]) }; __ret } } else { aiur_fn_517(__args, record, io_buffer, __cu)? } }; + let __r_arr: [G; OUT_513] = { let __args: [G; IN_513] = [__v_8]; let __cu = unconstrained; if let Some(result) = record.function_queries[513].get_mut(&__args[..]) { if !__cu && *result.multiplicity == G::ZERO { aiur_fn_513(__args, record, io_buffer, false)? } else { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_513] = unsafe { *(result.output.as_ptr() as *const [G; OUT_513]) }; __ret } } else { aiur_fn_513(__args, record, io_buffer, __cu)? } }; let __v_11: G = __r_arr[0]; let __v_12: G = __r_arr[1]; let __v_13: G = __r_arr[2]; match __v_11.as_canonical_u64() { 1u64 => { - let __r_arr: [G; OUT_517] = { let __args: [G; IN_517] = [__v_10]; let __cu = unconstrained; if let Some(result) = record.function_queries[517].get_mut(&__args[..]) { if !__cu && *result.multiplicity == G::ZERO { aiur_fn_517(__args, record, io_buffer, false)? } else { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_517] = unsafe { *(result.output.as_ptr() as *const [G; OUT_517]) }; __ret } } else { aiur_fn_517(__args, record, io_buffer, __cu)? } }; + let __r_arr: [G; OUT_513] = { let __args: [G; IN_513] = [__v_10]; let __cu = unconstrained; if let Some(result) = record.function_queries[513].get_mut(&__args[..]) { if !__cu && *result.multiplicity == G::ZERO { aiur_fn_513(__args, record, io_buffer, false)? } else { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_513] = unsafe { *(result.output.as_ptr() as *const [G; OUT_513]) }; __ret } } else { aiur_fn_513(__args, record, io_buffer, __cu)? } }; let __v_14: G = __r_arr[0]; let __v_15: G = __r_arr[1]; let __v_16: G = __r_arr[2]; @@ -45273,26 +44989,26 @@ fn aiur_fn_519( let __v_19: G = G::from_u64(0); let __v_20: G = G::from_u64(0); let __v_21: G = { let __values: [G; 4] = [__v_18, __v_19, __v_20, __v_20]; let __mq = record.memory_queries.get_mut(&4).ok_or(ExecError::InvalidMemorySize(4))?; if let Some(result) = __mq.get_mut(&__values[..]) { if !unconstrained { *result.multiplicity += G::ONE; } result.output[0] } else { let __ptr = G::from_usize(__mq.len()); __mq.insert(&__values[..], &[__ptr], G::from_bool(!unconstrained)); __ptr } }; - let __ret: [G; OUT_519] = [__v_17, __v_21]; - if let Some(result) = record.function_queries[519].get_mut(&inp[..]) { debug_assert_eq!(result.output, &__ret[..]); if !unconstrained { *result.multiplicity += G::ONE; } } else { record.function_queries[519].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained)); }; + let __ret: [G; OUT_515] = [__v_17, __v_21]; + if let Some(result) = record.function_queries[515].get_mut(&inp[..]) { debug_assert_eq!(result.output, &__ret[..]); if !unconstrained { *result.multiplicity += G::ONE; } } else { record.function_queries[515].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained)); }; return Ok(__ret); }, _ => { - let __r_arr: [G; OUT_520] = { let __args: [G; IN_520] = [__v_0, __v_1, __v_2, __v_8, __v_10, __v_3]; let __cu = unconstrained; if let Some(result) = record.function_queries[520].get_mut(&__args[..]) { if !__cu && *result.multiplicity == G::ZERO { aiur_fn_520(__args, record, io_buffer, false)? } else { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_520] = unsafe { *(result.output.as_ptr() as *const [G; OUT_520]) }; __ret } } else { aiur_fn_520(__args, record, io_buffer, __cu)? } }; + let __r_arr: [G; OUT_516] = { let __args: [G; IN_516] = [__v_0, __v_1, __v_2, __v_8, __v_10, __v_3]; let __cu = unconstrained; if let Some(result) = record.function_queries[516].get_mut(&__args[..]) { if !__cu && *result.multiplicity == G::ZERO { aiur_fn_516(__args, record, io_buffer, false)? } else { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_516] = unsafe { *(result.output.as_ptr() as *const [G; OUT_516]) }; __ret } } else { aiur_fn_516(__args, record, io_buffer, __cu)? } }; let __v_17: G = __r_arr[0]; let __v_18: G = __r_arr[1]; - let __ret: [G; OUT_519] = [__v_17, __v_18]; - if let Some(result) = record.function_queries[519].get_mut(&inp[..]) { debug_assert_eq!(result.output, &__ret[..]); if !unconstrained { *result.multiplicity += G::ONE; } } else { record.function_queries[519].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained)); }; + let __ret: [G; OUT_515] = [__v_17, __v_18]; + if let Some(result) = record.function_queries[515].get_mut(&inp[..]) { debug_assert_eq!(result.output, &__ret[..]); if !unconstrained { *result.multiplicity += G::ONE; } } else { record.function_queries[515].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained)); }; return Ok(__ret); }, } }, _ => { - let __r_arr: [G; OUT_520] = { let __args: [G; IN_520] = [__v_0, __v_1, __v_2, __v_8, __v_10, __v_3]; let __cu = unconstrained; if let Some(result) = record.function_queries[520].get_mut(&__args[..]) { if !__cu && *result.multiplicity == G::ZERO { aiur_fn_520(__args, record, io_buffer, false)? } else { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_520] = unsafe { *(result.output.as_ptr() as *const [G; OUT_520]) }; __ret } } else { aiur_fn_520(__args, record, io_buffer, __cu)? } }; + let __r_arr: [G; OUT_516] = { let __args: [G; IN_516] = [__v_0, __v_1, __v_2, __v_8, __v_10, __v_3]; let __cu = unconstrained; if let Some(result) = record.function_queries[516].get_mut(&__args[..]) { if !__cu && *result.multiplicity == G::ZERO { aiur_fn_516(__args, record, io_buffer, false)? } else { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_516] = unsafe { *(result.output.as_ptr() as *const [G; OUT_516]) }; __ret } } else { aiur_fn_516(__args, record, io_buffer, __cu)? } }; let __v_14: G = __r_arr[0]; let __v_15: G = __r_arr[1]; - let __ret: [G; OUT_519] = [__v_14, __v_15]; - if let Some(result) = record.function_queries[519].get_mut(&inp[..]) { debug_assert_eq!(result.output, &__ret[..]); if !unconstrained { *result.multiplicity += G::ONE; } } else { record.function_queries[519].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained)); }; + let __ret: [G; OUT_515] = [__v_14, __v_15]; + if let Some(result) = record.function_queries[515].get_mut(&inp[..]) { debug_assert_eq!(result.output, &__ret[..]); if !unconstrained { *result.multiplicity += G::ONE; } } else { record.function_queries[515].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained)); }; return Ok(__ret); }, } @@ -45301,15 +45017,15 @@ fn aiur_fn_519( }) } -const INPUT_SIZE_520: usize = 6; -const IN_520: usize = 6; -const OUT_520: usize = 2; -fn aiur_fn_520( - inp: [G; IN_520], +const INPUT_SIZE_516: usize = 6; +const IN_516: usize = 6; +const OUT_516: usize = 2; +fn aiur_fn_516( + inp: [G; IN_516], record: &mut QueryRecord, io_buffer: &mut IOBuffer, unconstrained: bool, -) -> Result<[G; OUT_520], ExecError> { +) -> Result<[G; OUT_516], ExecError> { stacker::maybe_grow(64 * 1024, 4 * 1024 * 1024, || { let __v_0: G = inp[0]; let __v_1: G = inp[1]; @@ -45317,25 +45033,25 @@ fn aiur_fn_520( let __v_3: G = inp[3]; let __v_4: G = inp[4]; let __v_5: G = inp[5]; - let __r_arr: [G; OUT_418] = { let __args: [G; IN_418] = [__v_3, __v_5]; let __cu = unconstrained; if let Some(result) = record.function_queries[418].get_mut(&__args[..]) { if !__cu && *result.multiplicity == G::ZERO { aiur_fn_418(__args, record, io_buffer, false)? } else { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_418] = unsafe { *(result.output.as_ptr() as *const [G; OUT_418]) }; __ret } } else { aiur_fn_418(__args, record, io_buffer, __cu)? } }; + let __r_arr: [G; OUT_414] = { let __args: [G; IN_414] = [__v_3, __v_5]; let __cu = unconstrained; if let Some(result) = record.function_queries[414].get_mut(&__args[..]) { if !__cu && *result.multiplicity == G::ZERO { aiur_fn_414(__args, record, io_buffer, false)? } else { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_414] = unsafe { *(result.output.as_ptr() as *const [G; OUT_414]) }; __ret } } else { aiur_fn_414(__args, record, io_buffer, __cu)? } }; let __v_6: G = __r_arr[0]; - let __r_arr: [G; OUT_418] = { let __args: [G; IN_418] = [__v_4, __v_5]; let __cu = unconstrained; if let Some(result) = record.function_queries[418].get_mut(&__args[..]) { if !__cu && *result.multiplicity == G::ZERO { aiur_fn_418(__args, record, io_buffer, false)? } else { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_418] = unsafe { *(result.output.as_ptr() as *const [G; OUT_418]) }; __ret } } else { aiur_fn_418(__args, record, io_buffer, __cu)? } }; + let __r_arr: [G; OUT_414] = { let __args: [G; IN_414] = [__v_4, __v_5]; let __cu = unconstrained; if let Some(result) = record.function_queries[414].get_mut(&__args[..]) { if !__cu && *result.multiplicity == G::ZERO { aiur_fn_414(__args, record, io_buffer, false)? } else { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_414] = unsafe { *(result.output.as_ptr() as *const [G; OUT_414]) }; __ret } } else { aiur_fn_414(__args, record, io_buffer, __cu)? } }; let __v_7: G = __r_arr[0]; - let __r_arr: [G; OUT_517] = { let __args: [G; IN_517] = [__v_6]; let __cu = unconstrained; if let Some(result) = record.function_queries[517].get_mut(&__args[..]) { if !__cu && *result.multiplicity == G::ZERO { aiur_fn_517(__args, record, io_buffer, false)? } else { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_517] = unsafe { *(result.output.as_ptr() as *const [G; OUT_517]) }; __ret } } else { aiur_fn_517(__args, record, io_buffer, __cu)? } }; + let __r_arr: [G; OUT_513] = { let __args: [G; IN_513] = [__v_6]; let __cu = unconstrained; if let Some(result) = record.function_queries[513].get_mut(&__args[..]) { if !__cu && *result.multiplicity == G::ZERO { aiur_fn_513(__args, record, io_buffer, false)? } else { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_513] = unsafe { *(result.output.as_ptr() as *const [G; OUT_513]) }; __ret } } else { aiur_fn_513(__args, record, io_buffer, __cu)? } }; let __v_8: G = __r_arr[0]; let __v_9: G = __r_arr[1]; let __v_10: G = __r_arr[2]; match __v_8.as_canonical_u64() { 1u64 => { - let __r_arr: [G; OUT_517] = { let __args: [G; IN_517] = [__v_7]; let __cu = unconstrained; if let Some(result) = record.function_queries[517].get_mut(&__args[..]) { if !__cu && *result.multiplicity == G::ZERO { aiur_fn_517(__args, record, io_buffer, false)? } else { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_517] = unsafe { *(result.output.as_ptr() as *const [G; OUT_517]) }; __ret } } else { aiur_fn_517(__args, record, io_buffer, __cu)? } }; + let __r_arr: [G; OUT_513] = { let __args: [G; IN_513] = [__v_7]; let __cu = unconstrained; if let Some(result) = record.function_queries[513].get_mut(&__args[..]) { if !__cu && *result.multiplicity == G::ZERO { aiur_fn_513(__args, record, io_buffer, false)? } else { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_513] = unsafe { *(result.output.as_ptr() as *const [G; OUT_513]) }; __ret } } else { aiur_fn_513(__args, record, io_buffer, __cu)? } }; let __v_11: G = __r_arr[0]; let __v_12: G = __r_arr[1]; let __v_13: G = __r_arr[2]; match __v_11.as_canonical_u64() { 1u64 => { - let __r_arr: [G; OUT_518] = { let __args: [G; IN_518] = [__v_9, __v_10]; let __cu = unconstrained; if let Some(result) = record.function_queries[518].get_mut(&__args[..]) { if !__cu && *result.multiplicity == G::ZERO { aiur_fn_518(__args, record, io_buffer, false)? } else { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_518] = unsafe { *(result.output.as_ptr() as *const [G; OUT_518]) }; __ret } } else { aiur_fn_518(__args, record, io_buffer, __cu)? } }; + let __r_arr: [G; OUT_514] = { let __args: [G; IN_514] = [__v_9, __v_10]; let __cu = unconstrained; if let Some(result) = record.function_queries[514].get_mut(&__args[..]) { if !__cu && *result.multiplicity == G::ZERO { aiur_fn_514(__args, record, io_buffer, false)? } else { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_514] = unsafe { *(result.output.as_ptr() as *const [G; OUT_514]) }; __ret } } else { aiur_fn_514(__args, record, io_buffer, __cu)? } }; let __v_14: G = __r_arr[0]; - let __r_arr: [G; OUT_518] = { let __args: [G; IN_518] = [__v_12, __v_13]; let __cu = unconstrained; if let Some(result) = record.function_queries[518].get_mut(&__args[..]) { if !__cu && *result.multiplicity == G::ZERO { aiur_fn_518(__args, record, io_buffer, false)? } else { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_518] = unsafe { *(result.output.as_ptr() as *const [G; OUT_518]) }; __ret } } else { aiur_fn_518(__args, record, io_buffer, __cu)? } }; + let __r_arr: [G; OUT_514] = { let __args: [G; IN_514] = [__v_12, __v_13]; let __cu = unconstrained; if let Some(result) = record.function_queries[514].get_mut(&__args[..]) { if !__cu && *result.multiplicity == G::ZERO { aiur_fn_514(__args, record, io_buffer, false)? } else { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_514] = unsafe { *(result.output.as_ptr() as *const [G; OUT_514]) }; __ret } } else { aiur_fn_514(__args, record, io_buffer, __cu)? } }; let __v_15: G = __r_arr[0]; let __v_16: G = G::from_u64(2); let __v_17: G = G::from_u64(0); @@ -45347,13 +45063,13 @@ fn aiur_fn_520( let __v_23: G = G::from_u64(0); let __v_24: G = { let __values: [G; 4] = [__v_22, __v_21, __v_15, __v_23]; let __mq = record.memory_queries.get_mut(&4).ok_or(ExecError::InvalidMemorySize(4))?; if let Some(result) = __mq.get_mut(&__values[..]) { if !unconstrained { *result.multiplicity += G::ONE; } result.output[0] } else { let __ptr = G::from_usize(__mq.len()); __mq.insert(&__values[..], &[__ptr], G::from_bool(!unconstrained)); __ptr } }; let __v_25: G = G::from_u64(2); - let __r_arr: [G; OUT_775] = { let __args: [G; IN_775] = [__v_2, __v_25]; let __cu = unconstrained; if let Some(result) = record.function_queries[775].get_mut(&__args[..]) { if !__cu && *result.multiplicity == G::ZERO { aiur_fn_775(__args, record, io_buffer, false)? } else { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_775] = unsafe { *(result.output.as_ptr() as *const [G; OUT_775]) }; __ret } } else { aiur_fn_775(__args, record, io_buffer, __cu)? } }; + let __r_arr: [G; OUT_771] = { let __args: [G; IN_771] = [__v_2, __v_25]; let __cu = unconstrained; if let Some(result) = record.function_queries[771].get_mut(&__args[..]) { if !__cu && *result.multiplicity == G::ZERO { aiur_fn_771(__args, record, io_buffer, false)? } else { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_771] = unsafe { *(result.output.as_ptr() as *const [G; OUT_771]) }; __ret } } else { aiur_fn_771(__args, record, io_buffer, __cu)? } }; let __v_26: G = __r_arr[0]; let __v_27: G = G::from_u64(1); - let __r_arr: [G; OUT_255] = { let __args: [G; IN_255] = [__v_24, __v_26]; let __cu = unconstrained; if let Some(result) = record.function_queries[255].get_mut(&__args[..]) { if !__cu && *result.multiplicity == G::ZERO { aiur_fn_255(__args, record, io_buffer, false)? } else { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_255] = unsafe { *(result.output.as_ptr() as *const [G; OUT_255]) }; __ret } } else { aiur_fn_255(__args, record, io_buffer, __cu)? } }; + let __r_arr: [G; OUT_251] = { let __args: [G; IN_251] = [__v_24, __v_26]; let __cu = unconstrained; if let Some(result) = record.function_queries[251].get_mut(&__args[..]) { if !__cu && *result.multiplicity == G::ZERO { aiur_fn_251(__args, record, io_buffer, false)? } else { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_251] = unsafe { *(result.output.as_ptr() as *const [G; OUT_251]) }; __ret } } else { aiur_fn_251(__args, record, io_buffer, __cu)? } }; let __v_28: G = __r_arr[0]; - let __ret: [G; OUT_520] = [__v_27, __v_28]; - if let Some(result) = record.function_queries[520].get_mut(&inp[..]) { debug_assert_eq!(result.output, &__ret[..]); if !unconstrained { *result.multiplicity += G::ONE; } } else { record.function_queries[520].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained)); }; + let __ret: [G; OUT_516] = [__v_27, __v_28]; + if let Some(result) = record.function_queries[516].get_mut(&inp[..]) { debug_assert_eq!(result.output, &__ret[..]); if !unconstrained { *result.multiplicity += G::ONE; } } else { record.function_queries[516].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained)); }; return Ok(__ret); }, _ => { @@ -45362,8 +45078,8 @@ fn aiur_fn_520( let __v_16: G = G::from_u64(0); let __v_17: G = G::from_u64(0); let __v_18: G = { let __values: [G; 4] = [__v_15, __v_16, __v_17, __v_17]; let __mq = record.memory_queries.get_mut(&4).ok_or(ExecError::InvalidMemorySize(4))?; if let Some(result) = __mq.get_mut(&__values[..]) { if !unconstrained { *result.multiplicity += G::ONE; } result.output[0] } else { let __ptr = G::from_usize(__mq.len()); __mq.insert(&__values[..], &[__ptr], G::from_bool(!unconstrained)); __ptr } }; - let __ret: [G; OUT_520] = [__v_14, __v_18]; - if let Some(result) = record.function_queries[520].get_mut(&inp[..]) { debug_assert_eq!(result.output, &__ret[..]); if !unconstrained { *result.multiplicity += G::ONE; } } else { record.function_queries[520].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained)); }; + let __ret: [G; OUT_516] = [__v_14, __v_18]; + if let Some(result) = record.function_queries[516].get_mut(&inp[..]) { debug_assert_eq!(result.output, &__ret[..]); if !unconstrained { *result.multiplicity += G::ONE; } } else { record.function_queries[516].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained)); }; return Ok(__ret); }, } @@ -45374,29 +45090,29 @@ fn aiur_fn_520( let __v_13: G = G::from_u64(0); let __v_14: G = G::from_u64(0); let __v_15: G = { let __values: [G; 4] = [__v_12, __v_13, __v_14, __v_14]; let __mq = record.memory_queries.get_mut(&4).ok_or(ExecError::InvalidMemorySize(4))?; if let Some(result) = __mq.get_mut(&__values[..]) { if !unconstrained { *result.multiplicity += G::ONE; } result.output[0] } else { let __ptr = G::from_usize(__mq.len()); __mq.insert(&__values[..], &[__ptr], G::from_bool(!unconstrained)); __ptr } }; - let __ret: [G; OUT_520] = [__v_11, __v_15]; - if let Some(result) = record.function_queries[520].get_mut(&inp[..]) { debug_assert_eq!(result.output, &__ret[..]); if !unconstrained { *result.multiplicity += G::ONE; } } else { record.function_queries[520].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained)); }; + let __ret: [G; OUT_516] = [__v_11, __v_15]; + if let Some(result) = record.function_queries[516].get_mut(&inp[..]) { debug_assert_eq!(result.output, &__ret[..]); if !unconstrained { *result.multiplicity += G::ONE; } } else { record.function_queries[516].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained)); }; return Ok(__ret); }, } }) } -const INPUT_SIZE_521: usize = 4; -const IN_521: usize = 4; -const OUT_521: usize = 2; -fn aiur_fn_521( - inp: [G; IN_521], +const INPUT_SIZE_517: usize = 4; +const IN_517: usize = 4; +const OUT_517: usize = 2; +fn aiur_fn_517( + inp: [G; IN_517], record: &mut QueryRecord, io_buffer: &mut IOBuffer, unconstrained: bool, -) -> Result<[G; OUT_521], ExecError> { +) -> Result<[G; OUT_517], ExecError> { stacker::maybe_grow(64 * 1024, 4 * 1024 * 1024, || { let __v_0: G = inp[0]; let __v_1: G = inp[1]; let __v_2: G = inp[2]; let __v_3: G = inp[3]; - let __r_arr: [G; OUT_764] = { let __args: [G; IN_764] = [__v_2]; let __cu = unconstrained; if let Some(result) = record.function_queries[764].get_mut(&__args[..]) { if !__cu && *result.multiplicity == G::ZERO { aiur_fn_764(__args, record, io_buffer, false)? } else { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_764] = unsafe { *(result.output.as_ptr() as *const [G; OUT_764]) }; __ret } } else { aiur_fn_764(__args, record, io_buffer, __cu)? } }; + let __r_arr: [G; OUT_760] = { let __args: [G; IN_760] = [__v_2]; let __cu = unconstrained; if let Some(result) = record.function_queries[760].get_mut(&__args[..]) { if !__cu && *result.multiplicity == G::ZERO { aiur_fn_760(__args, record, io_buffer, false)? } else { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_760] = unsafe { *(result.output.as_ptr() as *const [G; OUT_760]) }; __ret } } else { aiur_fn_760(__args, record, io_buffer, __cu)? } }; let __v_4: G = __r_arr[0]; let __v_5: G = G::from_u64(2); let __v_6: G = { let __a_val = __v_4.as_canonical_u64(); let __b_val = __v_5.as_canonical_u64(); let __a_u32 = u32::try_from(__a_val).ok().ok_or(ExecError::U32OutOfRange(__a_val))?; let __b_u32 = u32::try_from(__b_val).ok().ok_or(ExecError::U32OutOfRange(__b_val))?; let __result = G::from_bool(__a_u32 < __b_u32); if !unconstrained { let __x_bytes = __a_u32.to_le_bytes(); let __z_bytes = __b_u32.to_le_bytes(); let __c_u32 = __b_u32.wrapping_sub(__a_u32).wrapping_sub(1); let __y_bytes = __c_u32.to_le_bytes(); record.bytes2_queries.bump_range_check(&G::from_u8(__x_bytes[0]), &G::from_u8(__x_bytes[1])); record.bytes2_queries.bump_range_check(&G::from_u8(__x_bytes[2]), &G::from_u8(__x_bytes[3])); record.bytes2_queries.bump_range_check(&G::from_u8(__y_bytes[0]), &G::from_u8(__y_bytes[1])); record.bytes2_queries.bump_range_check(&G::from_u8(__y_bytes[2]), &G::from_u8(__y_bytes[3])); record.bytes2_queries.bump_range_check(&G::from_u8(__z_bytes[0]), &G::from_u8(__z_bytes[1])); record.bytes2_queries.bump_range_check(&G::from_u8(__z_bytes[2]), &G::from_u8(__z_bytes[3])); } __result }; @@ -45407,50 +45123,50 @@ fn aiur_fn_521( let __v_9: G = G::from_u64(0); let __v_10: G = G::from_u64(0); let __v_11: G = { let __values: [G; 4] = [__v_8, __v_9, __v_10, __v_10]; let __mq = record.memory_queries.get_mut(&4).ok_or(ExecError::InvalidMemorySize(4))?; if let Some(result) = __mq.get_mut(&__values[..]) { if !unconstrained { *result.multiplicity += G::ONE; } result.output[0] } else { let __ptr = G::from_usize(__mq.len()); __mq.insert(&__values[..], &[__ptr], G::from_bool(!unconstrained)); __ptr } }; - let __ret: [G; OUT_521] = [__v_7, __v_11]; - if let Some(result) = record.function_queries[521].get_mut(&inp[..]) { debug_assert_eq!(result.output, &__ret[..]); if !unconstrained { *result.multiplicity += G::ONE; } } else { record.function_queries[521].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained)); }; + let __ret: [G; OUT_517] = [__v_7, __v_11]; + if let Some(result) = record.function_queries[517].get_mut(&inp[..]) { debug_assert_eq!(result.output, &__ret[..]); if !unconstrained { *result.multiplicity += G::ONE; } } else { record.function_queries[517].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained)); }; return Ok(__ret); }, _ => { - let __r_arr: [G; OUT_516] = { let __args: [G; IN_516] = [__v_0]; let __cu = unconstrained; if let Some(result) = record.function_queries[516].get_mut(&__args[..]) { if !__cu && *result.multiplicity == G::ZERO { aiur_fn_516(__args, record, io_buffer, false)? } else { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_516] = unsafe { *(result.output.as_ptr() as *const [G; OUT_516]) }; __ret } } else { aiur_fn_516(__args, record, io_buffer, __cu)? } }; + let __r_arr: [G; OUT_512] = { let __args: [G; IN_512] = [__v_0]; let __cu = unconstrained; if let Some(result) = record.function_queries[512].get_mut(&__args[..]) { if !__cu && *result.multiplicity == G::ZERO { aiur_fn_512(__args, record, io_buffer, false)? } else { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_512] = unsafe { *(result.output.as_ptr() as *const [G; OUT_512]) }; __ret } } else { aiur_fn_512(__args, record, io_buffer, __cu)? } }; let __v_7: G = __r_arr[0]; match __v_7.as_canonical_u64() { 1u64 => { - let __r_arr: [G; OUT_519] = { let __args: [G; IN_519] = [__v_0, __v_1, __v_2, __v_3]; let __cu = unconstrained; if let Some(result) = record.function_queries[519].get_mut(&__args[..]) { if !__cu && *result.multiplicity == G::ZERO { aiur_fn_519(__args, record, io_buffer, false)? } else { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_519] = unsafe { *(result.output.as_ptr() as *const [G; OUT_519]) }; __ret } } else { aiur_fn_519(__args, record, io_buffer, __cu)? } }; + let __r_arr: [G; OUT_515] = { let __args: [G; IN_515] = [__v_0, __v_1, __v_2, __v_3]; let __cu = unconstrained; if let Some(result) = record.function_queries[515].get_mut(&__args[..]) { if !__cu && *result.multiplicity == G::ZERO { aiur_fn_515(__args, record, io_buffer, false)? } else { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_515] = unsafe { *(result.output.as_ptr() as *const [G; OUT_515]) }; __ret } } else { aiur_fn_515(__args, record, io_buffer, __cu)? } }; let __v_8: G = __r_arr[0]; let __v_9: G = __r_arr[1]; - let __ret: [G; OUT_521] = [__v_8, __v_9]; - if let Some(result) = record.function_queries[521].get_mut(&inp[..]) { debug_assert_eq!(result.output, &__ret[..]); if !unconstrained { *result.multiplicity += G::ONE; } } else { record.function_queries[521].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained)); }; + let __ret: [G; OUT_517] = [__v_8, __v_9]; + if let Some(result) = record.function_queries[517].get_mut(&inp[..]) { debug_assert_eq!(result.output, &__ret[..]); if !unconstrained { *result.multiplicity += G::ONE; } } else { record.function_queries[517].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained)); }; return Ok(__ret); }, _ => { - let __r_arr: [G; OUT_501] = { let __args: [G; IN_501] = []; let __cu = unconstrained; if let Some(result) = record.function_queries[501].get_mut(&__args[..]) { if !__cu && *result.multiplicity == G::ZERO { aiur_fn_501(__args, record, io_buffer, false)? } else { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_501] = unsafe { *(result.output.as_ptr() as *const [G; OUT_501]) }; __ret } } else { aiur_fn_501(__args, record, io_buffer, __cu)? } }; + let __r_arr: [G; OUT_497] = { let __args: [G; IN_497] = []; let __cu = unconstrained; if let Some(result) = record.function_queries[497].get_mut(&__args[..]) { if !__cu && *result.multiplicity == G::ZERO { aiur_fn_497(__args, record, io_buffer, false)? } else { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_497] = unsafe { *(result.output.as_ptr() as *const [G; OUT_497]) }; __ret } } else { aiur_fn_497(__args, record, io_buffer, __cu)? } }; let __v_8: G = __r_arr[0]; let __r_arr: [G; OUT_1] = { let __args: [G; IN_1] = [__v_0, __v_8]; let __cu = unconstrained; if let Some(result) = record.function_queries[1].get_mut(&__args[..]) { if !__cu && *result.multiplicity == G::ZERO { aiur_fn_1(__args, record, io_buffer, false)? } else { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_1] = unsafe { *(result.output.as_ptr() as *const [G; OUT_1]) }; __ret } } else { aiur_fn_1(__args, record, io_buffer, __cu)? } }; let __v_9: G = __r_arr[0]; - let __r_arr: [G; OUT_502] = { let __args: [G; IN_502] = []; let __cu = unconstrained; if let Some(result) = record.function_queries[502].get_mut(&__args[..]) { if !__cu && *result.multiplicity == G::ZERO { aiur_fn_502(__args, record, io_buffer, false)? } else { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_502] = unsafe { *(result.output.as_ptr() as *const [G; OUT_502]) }; __ret } } else { aiur_fn_502(__args, record, io_buffer, __cu)? } }; + let __r_arr: [G; OUT_498] = { let __args: [G; IN_498] = []; let __cu = unconstrained; if let Some(result) = record.function_queries[498].get_mut(&__args[..]) { if !__cu && *result.multiplicity == G::ZERO { aiur_fn_498(__args, record, io_buffer, false)? } else { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_498] = unsafe { *(result.output.as_ptr() as *const [G; OUT_498]) }; __ret } } else { aiur_fn_498(__args, record, io_buffer, __cu)? } }; let __v_10: G = __r_arr[0]; let __r_arr: [G; OUT_1] = { let __args: [G; IN_1] = [__v_0, __v_10]; let __cu = unconstrained; if let Some(result) = record.function_queries[1].get_mut(&__args[..]) { if !__cu && *result.multiplicity == G::ZERO { aiur_fn_1(__args, record, io_buffer, false)? } else { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_1] = unsafe { *(result.output.as_ptr() as *const [G; OUT_1]) }; __ret } } else { aiur_fn_1(__args, record, io_buffer, __cu)? } }; let __v_11: G = __r_arr[0]; - let __r_arr: [G; OUT_503] = { let __args: [G; IN_503] = []; let __cu = unconstrained; if let Some(result) = record.function_queries[503].get_mut(&__args[..]) { if !__cu && *result.multiplicity == G::ZERO { aiur_fn_503(__args, record, io_buffer, false)? } else { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_503] = unsafe { *(result.output.as_ptr() as *const [G; OUT_503]) }; __ret } } else { aiur_fn_503(__args, record, io_buffer, __cu)? } }; + let __r_arr: [G; OUT_499] = { let __args: [G; IN_499] = []; let __cu = unconstrained; if let Some(result) = record.function_queries[499].get_mut(&__args[..]) { if !__cu && *result.multiplicity == G::ZERO { aiur_fn_499(__args, record, io_buffer, false)? } else { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_499] = unsafe { *(result.output.as_ptr() as *const [G; OUT_499]) }; __ret } } else { aiur_fn_499(__args, record, io_buffer, __cu)? } }; let __v_12: G = __r_arr[0]; let __r_arr: [G; OUT_1] = { let __args: [G; IN_1] = [__v_0, __v_12]; let __cu = unconstrained; if let Some(result) = record.function_queries[1].get_mut(&__args[..]) { if !__cu && *result.multiplicity == G::ZERO { aiur_fn_1(__args, record, io_buffer, false)? } else { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_1] = unsafe { *(result.output.as_ptr() as *const [G; OUT_1]) }; __ret } } else { aiur_fn_1(__args, record, io_buffer, __cu)? } }; let __v_13: G = __r_arr[0]; match __v_13.as_canonical_u64() { 1u64 => { - let __r_arr: [G; OUT_522] = { let __args: [G; IN_522] = [__v_1, __v_2, __v_3]; let __cu = unconstrained; if let Some(result) = record.function_queries[522].get_mut(&__args[..]) { if !__cu && *result.multiplicity == G::ZERO { aiur_fn_522(__args, record, io_buffer, false)? } else { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_522] = unsafe { *(result.output.as_ptr() as *const [G; OUT_522]) }; __ret } } else { aiur_fn_522(__args, record, io_buffer, __cu)? } }; + let __r_arr: [G; OUT_518] = { let __args: [G; IN_518] = [__v_1, __v_2, __v_3]; let __cu = unconstrained; if let Some(result) = record.function_queries[518].get_mut(&__args[..]) { if !__cu && *result.multiplicity == G::ZERO { aiur_fn_518(__args, record, io_buffer, false)? } else { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_518] = unsafe { *(result.output.as_ptr() as *const [G; OUT_518]) }; __ret } } else { aiur_fn_518(__args, record, io_buffer, __cu)? } }; let __v_14: G = __r_arr[0]; let __v_15: G = __r_arr[1]; - let __ret: [G; OUT_521] = [__v_14, __v_15]; - if let Some(result) = record.function_queries[521].get_mut(&inp[..]) { debug_assert_eq!(result.output, &__ret[..]); if !unconstrained { *result.multiplicity += G::ONE; } } else { record.function_queries[521].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained)); }; + let __ret: [G; OUT_517] = [__v_14, __v_15]; + if let Some(result) = record.function_queries[517].get_mut(&inp[..]) { debug_assert_eq!(result.output, &__ret[..]); if !unconstrained { *result.multiplicity += G::ONE; } } else { record.function_queries[517].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained)); }; return Ok(__ret); }, _ => { - let __r_arr: [G; OUT_523] = { let __args: [G; IN_523] = [__v_9, __v_11, __v_0, __v_1, __v_2, __v_3]; let __cu = unconstrained; if let Some(result) = record.function_queries[523].get_mut(&__args[..]) { if !__cu && *result.multiplicity == G::ZERO { aiur_fn_523(__args, record, io_buffer, false)? } else { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_523] = unsafe { *(result.output.as_ptr() as *const [G; OUT_523]) }; __ret } } else { aiur_fn_523(__args, record, io_buffer, __cu)? } }; + let __r_arr: [G; OUT_519] = { let __args: [G; IN_519] = [__v_9, __v_11, __v_0, __v_1, __v_2, __v_3]; let __cu = unconstrained; if let Some(result) = record.function_queries[519].get_mut(&__args[..]) { if !__cu && *result.multiplicity == G::ZERO { aiur_fn_519(__args, record, io_buffer, false)? } else { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_519] = unsafe { *(result.output.as_ptr() as *const [G; OUT_519]) }; __ret } } else { aiur_fn_519(__args, record, io_buffer, __cu)? } }; let __v_14: G = __r_arr[0]; let __v_15: G = __r_arr[1]; - let __ret: [G; OUT_521] = [__v_14, __v_15]; - if let Some(result) = record.function_queries[521].get_mut(&inp[..]) { debug_assert_eq!(result.output, &__ret[..]); if !unconstrained { *result.multiplicity += G::ONE; } } else { record.function_queries[521].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained)); }; + let __ret: [G; OUT_517] = [__v_14, __v_15]; + if let Some(result) = record.function_queries[517].get_mut(&inp[..]) { debug_assert_eq!(result.output, &__ret[..]); if !unconstrained { *result.multiplicity += G::ONE; } } else { record.function_queries[517].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained)); }; return Ok(__ret); }, } @@ -45461,28 +45177,28 @@ fn aiur_fn_521( }) } -const INPUT_SIZE_522: usize = 3; -const IN_522: usize = 3; -const OUT_522: usize = 2; -fn aiur_fn_522( - inp: [G; IN_522], +const INPUT_SIZE_518: usize = 3; +const IN_518: usize = 3; +const OUT_518: usize = 2; +fn aiur_fn_518( + inp: [G; IN_518], record: &mut QueryRecord, io_buffer: &mut IOBuffer, unconstrained: bool, -) -> Result<[G; OUT_522], ExecError> { +) -> Result<[G; OUT_518], ExecError> { stacker::maybe_grow(64 * 1024, 4 * 1024 * 1024, || { let __v_0: G = inp[0]; let __v_1: G = inp[1]; let __v_2: G = inp[2]; let __v_3: G = G::from_u64(0); - let __r_arr: [G; OUT_766] = { let __args: [G; IN_766] = [__v_1, __v_3]; let __cu = unconstrained; if let Some(result) = record.function_queries[766].get_mut(&__args[..]) { if !__cu && *result.multiplicity == G::ZERO { aiur_fn_766(__args, record, io_buffer, false)? } else { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_766] = unsafe { *(result.output.as_ptr() as *const [G; OUT_766]) }; __ret } } else { aiur_fn_766(__args, record, io_buffer, __cu)? } }; + let __r_arr: [G; OUT_762] = { let __args: [G; IN_762] = [__v_1, __v_3]; let __cu = unconstrained; if let Some(result) = record.function_queries[762].get_mut(&__args[..]) { if !__cu && *result.multiplicity == G::ZERO { aiur_fn_762(__args, record, io_buffer, false)? } else { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_762] = unsafe { *(result.output.as_ptr() as *const [G; OUT_762]) }; __ret } } else { aiur_fn_762(__args, record, io_buffer, __cu)? } }; let __v_4: G = __r_arr[0]; let __v_5: G = G::from_u64(1); - let __r_arr: [G; OUT_766] = { let __args: [G; IN_766] = [__v_1, __v_5]; let __cu = unconstrained; if let Some(result) = record.function_queries[766].get_mut(&__args[..]) { if !__cu && *result.multiplicity == G::ZERO { aiur_fn_766(__args, record, io_buffer, false)? } else { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_766] = unsafe { *(result.output.as_ptr() as *const [G; OUT_766]) }; __ret } } else { aiur_fn_766(__args, record, io_buffer, __cu)? } }; + let __r_arr: [G; OUT_762] = { let __args: [G; IN_762] = [__v_1, __v_5]; let __cu = unconstrained; if let Some(result) = record.function_queries[762].get_mut(&__args[..]) { if !__cu && *result.multiplicity == G::ZERO { aiur_fn_762(__args, record, io_buffer, false)? } else { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_762] = unsafe { *(result.output.as_ptr() as *const [G; OUT_762]) }; __ret } } else { aiur_fn_762(__args, record, io_buffer, __cu)? } }; let __v_6: G = __r_arr[0]; - let __r_arr: [G; OUT_418] = { let __args: [G; IN_418] = [__v_4, __v_2]; let __cu = unconstrained; if let Some(result) = record.function_queries[418].get_mut(&__args[..]) { if !__cu && *result.multiplicity == G::ZERO { aiur_fn_418(__args, record, io_buffer, false)? } else { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_418] = unsafe { *(result.output.as_ptr() as *const [G; OUT_418]) }; __ret } } else { aiur_fn_418(__args, record, io_buffer, __cu)? } }; + let __r_arr: [G; OUT_414] = { let __args: [G; IN_414] = [__v_4, __v_2]; let __cu = unconstrained; if let Some(result) = record.function_queries[414].get_mut(&__args[..]) { if !__cu && *result.multiplicity == G::ZERO { aiur_fn_414(__args, record, io_buffer, false)? } else { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_414] = unsafe { *(result.output.as_ptr() as *const [G; OUT_414]) }; __ret } } else { aiur_fn_414(__args, record, io_buffer, __cu)? } }; let __v_7: G = __r_arr[0]; - let __r_arr: [G; OUT_243] = { let __args: [G; IN_243] = [__v_7]; let __cu = unconstrained; if let Some(result) = record.function_queries[243].get_mut(&__args[..]) { if !__cu && *result.multiplicity == G::ZERO { aiur_fn_243(__args, record, io_buffer, false)? } else { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_243] = unsafe { *(result.output.as_ptr() as *const [G; OUT_243]) }; __ret } } else { aiur_fn_243(__args, record, io_buffer, __cu)? } }; + let __r_arr: [G; OUT_239] = { let __args: [G; IN_239] = [__v_7]; let __cu = unconstrained; if let Some(result) = record.function_queries[239].get_mut(&__args[..]) { if !__cu && *result.multiplicity == G::ZERO { aiur_fn_239(__args, record, io_buffer, false)? } else { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_239] = unsafe { *(result.output.as_ptr() as *const [G; OUT_239]) }; __ret } } else { aiur_fn_239(__args, record, io_buffer, __cu)? } }; let __v_8: G = __r_arr[0]; let __v_9: G = __r_arr[1]; match __v_8.as_canonical_u64() { @@ -45492,17 +45208,17 @@ fn aiur_fn_522( let __v_12: G = G::from_u64(0); let __v_13: G = G::from_u64(0); let __v_14: G = { let __values: [G; 4] = [__v_11, __v_12, __v_13, __v_13]; let __mq = record.memory_queries.get_mut(&4).ok_or(ExecError::InvalidMemorySize(4))?; if let Some(result) = __mq.get_mut(&__values[..]) { if !unconstrained { *result.multiplicity += G::ONE; } result.output[0] } else { let __ptr = G::from_usize(__mq.len()); __mq.insert(&__values[..], &[__ptr], G::from_bool(!unconstrained)); __ptr } }; - let __ret: [G; OUT_522] = [__v_10, __v_14]; - if let Some(result) = record.function_queries[522].get_mut(&inp[..]) { debug_assert_eq!(result.output, &__ret[..]); if !unconstrained { *result.multiplicity += G::ONE; } } else { record.function_queries[522].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained)); }; + let __ret: [G; OUT_518] = [__v_10, __v_14]; + if let Some(result) = record.function_queries[518].get_mut(&inp[..]) { debug_assert_eq!(result.output, &__ret[..]); if !unconstrained { *result.multiplicity += G::ONE; } } else { record.function_queries[518].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained)); }; return Ok(__ret); }, 1u64 => { let __r_arr: [G; OUT_112] = { let __args: [G; IN_112] = [__v_9]; let __cu = unconstrained; if let Some(result) = record.function_queries[112].get_mut(&__args[..]) { if !__cu && *result.multiplicity == G::ZERO { aiur_fn_112(__args, record, io_buffer, false)? } else { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_112] = unsafe { *(result.output.as_ptr() as *const [G; OUT_112]) }; __ret } } else { aiur_fn_112(__args, record, io_buffer, __cu)? } }; let __v_10: G = __r_arr[0]; - let __r_arr: [G; OUT_245] = { let __args: [G; IN_245] = [__v_10]; let __cu = unconstrained; if let Some(result) = record.function_queries[245].get_mut(&__args[..]) { if !__cu && *result.multiplicity == G::ZERO { aiur_fn_245(__args, record, io_buffer, false)? } else { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_245] = unsafe { *(result.output.as_ptr() as *const [G; OUT_245]) }; __ret } } else { aiur_fn_245(__args, record, io_buffer, __cu)? } }; + let __r_arr: [G; OUT_241] = { let __args: [G; IN_241] = [__v_10]; let __cu = unconstrained; if let Some(result) = record.function_queries[241].get_mut(&__args[..]) { if !__cu && *result.multiplicity == G::ZERO { aiur_fn_241(__args, record, io_buffer, false)? } else { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_241] = unsafe { *(result.output.as_ptr() as *const [G; OUT_241]) }; __ret } } else { aiur_fn_241(__args, record, io_buffer, __cu)? } }; let __v_11: G = __r_arr[0]; let __v_12: G = G::from_u64(2); - let __r_arr: [G; OUT_501] = { let __args: [G; IN_501] = []; let __cu = unconstrained; if let Some(result) = record.function_queries[501].get_mut(&__args[..]) { if !__cu && *result.multiplicity == G::ZERO { aiur_fn_501(__args, record, io_buffer, false)? } else { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_501] = unsafe { *(result.output.as_ptr() as *const [G; OUT_501]) }; __ret } } else { aiur_fn_501(__args, record, io_buffer, __cu)? } }; + let __r_arr: [G; OUT_497] = { let __args: [G; IN_497] = []; let __cu = unconstrained; if let Some(result) = record.function_queries[497].get_mut(&__args[..]) { if !__cu && *result.multiplicity == G::ZERO { aiur_fn_497(__args, record, io_buffer, false)? } else { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_497] = unsafe { *(result.output.as_ptr() as *const [G; OUT_497]) }; __ret } } else { aiur_fn_497(__args, record, io_buffer, __cu)? } }; let __v_13: G = __r_arr[0]; let __v_14: G = G::from_u64(0); let __v_15: G = { let __values: [G; 4] = [__v_12, __v_13, __v_0, __v_14]; let __mq = record.memory_queries.get_mut(&4).ok_or(ExecError::InvalidMemorySize(4))?; if let Some(result) = __mq.get_mut(&__values[..]) { if !unconstrained { *result.multiplicity += G::ONE; } result.output[0] } else { let __ptr = G::from_usize(__mq.len()); __mq.insert(&__values[..], &[__ptr], G::from_bool(!unconstrained)); __ptr } }; @@ -45513,13 +45229,13 @@ fn aiur_fn_522( let __v_20: G = G::from_u64(0); let __v_21: G = { let __values: [G; 4] = [__v_19, __v_18, __v_6, __v_20]; let __mq = record.memory_queries.get_mut(&4).ok_or(ExecError::InvalidMemorySize(4))?; if let Some(result) = __mq.get_mut(&__values[..]) { if !unconstrained { *result.multiplicity += G::ONE; } result.output[0] } else { let __ptr = G::from_usize(__mq.len()); __mq.insert(&__values[..], &[__ptr], G::from_bool(!unconstrained)); __ptr } }; let __v_22: G = G::from_u64(2); - let __r_arr: [G; OUT_775] = { let __args: [G; IN_775] = [__v_1, __v_22]; let __cu = unconstrained; if let Some(result) = record.function_queries[775].get_mut(&__args[..]) { if !__cu && *result.multiplicity == G::ZERO { aiur_fn_775(__args, record, io_buffer, false)? } else { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_775] = unsafe { *(result.output.as_ptr() as *const [G; OUT_775]) }; __ret } } else { aiur_fn_775(__args, record, io_buffer, __cu)? } }; + let __r_arr: [G; OUT_771] = { let __args: [G; IN_771] = [__v_1, __v_22]; let __cu = unconstrained; if let Some(result) = record.function_queries[771].get_mut(&__args[..]) { if !__cu && *result.multiplicity == G::ZERO { aiur_fn_771(__args, record, io_buffer, false)? } else { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_771] = unsafe { *(result.output.as_ptr() as *const [G; OUT_771]) }; __ret } } else { aiur_fn_771(__args, record, io_buffer, __cu)? } }; let __v_23: G = __r_arr[0]; let __v_24: G = G::from_u64(1); - let __r_arr: [G; OUT_255] = { let __args: [G; IN_255] = [__v_21, __v_23]; let __cu = unconstrained; if let Some(result) = record.function_queries[255].get_mut(&__args[..]) { if !__cu && *result.multiplicity == G::ZERO { aiur_fn_255(__args, record, io_buffer, false)? } else { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_255] = unsafe { *(result.output.as_ptr() as *const [G; OUT_255]) }; __ret } } else { aiur_fn_255(__args, record, io_buffer, __cu)? } }; + let __r_arr: [G; OUT_251] = { let __args: [G; IN_251] = [__v_21, __v_23]; let __cu = unconstrained; if let Some(result) = record.function_queries[251].get_mut(&__args[..]) { if !__cu && *result.multiplicity == G::ZERO { aiur_fn_251(__args, record, io_buffer, false)? } else { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_251] = unsafe { *(result.output.as_ptr() as *const [G; OUT_251]) }; __ret } } else { aiur_fn_251(__args, record, io_buffer, __cu)? } }; let __v_25: G = __r_arr[0]; - let __ret: [G; OUT_522] = [__v_24, __v_25]; - if let Some(result) = record.function_queries[522].get_mut(&inp[..]) { debug_assert_eq!(result.output, &__ret[..]); if !unconstrained { *result.multiplicity += G::ONE; } } else { record.function_queries[522].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained)); }; + let __ret: [G; OUT_518] = [__v_24, __v_25]; + if let Some(result) = record.function_queries[518].get_mut(&inp[..]) { debug_assert_eq!(result.output, &__ret[..]); if !unconstrained { *result.multiplicity += G::ONE; } } else { record.function_queries[518].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained)); }; return Ok(__ret); }, _ => { @@ -45529,15 +45245,15 @@ fn aiur_fn_522( }) } -const INPUT_SIZE_523: usize = 6; -const IN_523: usize = 6; -const OUT_523: usize = 2; -fn aiur_fn_523( - inp: [G; IN_523], +const INPUT_SIZE_519: usize = 6; +const IN_519: usize = 6; +const OUT_519: usize = 2; +fn aiur_fn_519( + inp: [G; IN_519], record: &mut QueryRecord, io_buffer: &mut IOBuffer, unconstrained: bool, -) -> Result<[G; OUT_523], ExecError> { +) -> Result<[G; OUT_519], ExecError> { stacker::maybe_grow(64 * 1024, 4 * 1024 * 1024, || { let __v_0: G = inp[0]; let __v_1: G = inp[1]; @@ -45546,16 +45262,16 @@ fn aiur_fn_523( let __v_4: G = inp[4]; let __v_5: G = inp[5]; let __v_6: G = G::from_u64(0); - let __r_arr: [G; OUT_766] = { let __args: [G; IN_766] = [__v_4, __v_6]; let __cu = unconstrained; if let Some(result) = record.function_queries[766].get_mut(&__args[..]) { if !__cu && *result.multiplicity == G::ZERO { aiur_fn_766(__args, record, io_buffer, false)? } else { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_766] = unsafe { *(result.output.as_ptr() as *const [G; OUT_766]) }; __ret } } else { aiur_fn_766(__args, record, io_buffer, __cu)? } }; + let __r_arr: [G; OUT_762] = { let __args: [G; IN_762] = [__v_4, __v_6]; let __cu = unconstrained; if let Some(result) = record.function_queries[762].get_mut(&__args[..]) { if !__cu && *result.multiplicity == G::ZERO { aiur_fn_762(__args, record, io_buffer, false)? } else { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_762] = unsafe { *(result.output.as_ptr() as *const [G; OUT_762]) }; __ret } } else { aiur_fn_762(__args, record, io_buffer, __cu)? } }; let __v_7: G = __r_arr[0]; let __v_8: G = G::from_u64(1); - let __r_arr: [G; OUT_766] = { let __args: [G; IN_766] = [__v_4, __v_8]; let __cu = unconstrained; if let Some(result) = record.function_queries[766].get_mut(&__args[..]) { if !__cu && *result.multiplicity == G::ZERO { aiur_fn_766(__args, record, io_buffer, false)? } else { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_766] = unsafe { *(result.output.as_ptr() as *const [G; OUT_766]) }; __ret } } else { aiur_fn_766(__args, record, io_buffer, __cu)? } }; + let __r_arr: [G; OUT_762] = { let __args: [G; IN_762] = [__v_4, __v_8]; let __cu = unconstrained; if let Some(result) = record.function_queries[762].get_mut(&__args[..]) { if !__cu && *result.multiplicity == G::ZERO { aiur_fn_762(__args, record, io_buffer, false)? } else { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_762] = unsafe { *(result.output.as_ptr() as *const [G; OUT_762]) }; __ret } } else { aiur_fn_762(__args, record, io_buffer, __cu)? } }; let __v_9: G = __r_arr[0]; - let __r_arr: [G; OUT_418] = { let __args: [G; IN_418] = [__v_7, __v_5]; let __cu = unconstrained; if let Some(result) = record.function_queries[418].get_mut(&__args[..]) { if !__cu && *result.multiplicity == G::ZERO { aiur_fn_418(__args, record, io_buffer, false)? } else { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_418] = unsafe { *(result.output.as_ptr() as *const [G; OUT_418]) }; __ret } } else { aiur_fn_418(__args, record, io_buffer, __cu)? } }; + let __r_arr: [G; OUT_414] = { let __args: [G; IN_414] = [__v_7, __v_5]; let __cu = unconstrained; if let Some(result) = record.function_queries[414].get_mut(&__args[..]) { if !__cu && *result.multiplicity == G::ZERO { aiur_fn_414(__args, record, io_buffer, false)? } else { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_414] = unsafe { *(result.output.as_ptr() as *const [G; OUT_414]) }; __ret } } else { aiur_fn_414(__args, record, io_buffer, __cu)? } }; let __v_10: G = __r_arr[0]; - let __r_arr: [G; OUT_418] = { let __args: [G; IN_418] = [__v_9, __v_5]; let __cu = unconstrained; if let Some(result) = record.function_queries[418].get_mut(&__args[..]) { if !__cu && *result.multiplicity == G::ZERO { aiur_fn_418(__args, record, io_buffer, false)? } else { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_418] = unsafe { *(result.output.as_ptr() as *const [G; OUT_418]) }; __ret } } else { aiur_fn_418(__args, record, io_buffer, __cu)? } }; + let __r_arr: [G; OUT_414] = { let __args: [G; IN_414] = [__v_9, __v_5]; let __cu = unconstrained; if let Some(result) = record.function_queries[414].get_mut(&__args[..]) { if !__cu && *result.multiplicity == G::ZERO { aiur_fn_414(__args, record, io_buffer, false)? } else { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_414] = unsafe { *(result.output.as_ptr() as *const [G; OUT_414]) }; __ret } } else { aiur_fn_414(__args, record, io_buffer, __cu)? } }; let __v_11: G = __r_arr[0]; - let __r_arr: [G; OUT_243] = { let __args: [G; IN_243] = [__v_10]; let __cu = unconstrained; if let Some(result) = record.function_queries[243].get_mut(&__args[..]) { if !__cu && *result.multiplicity == G::ZERO { aiur_fn_243(__args, record, io_buffer, false)? } else { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_243] = unsafe { *(result.output.as_ptr() as *const [G; OUT_243]) }; __ret } } else { aiur_fn_243(__args, record, io_buffer, __cu)? } }; + let __r_arr: [G; OUT_239] = { let __args: [G; IN_239] = [__v_10]; let __cu = unconstrained; if let Some(result) = record.function_queries[239].get_mut(&__args[..]) { if !__cu && *result.multiplicity == G::ZERO { aiur_fn_239(__args, record, io_buffer, false)? } else { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_239] = unsafe { *(result.output.as_ptr() as *const [G; OUT_239]) }; __ret } } else { aiur_fn_239(__args, record, io_buffer, __cu)? } }; let __v_12: G = __r_arr[0]; let __v_13: G = __r_arr[1]; match __v_12.as_canonical_u64() { @@ -45565,12 +45281,12 @@ fn aiur_fn_523( let __v_16: G = G::from_u64(0); let __v_17: G = G::from_u64(0); let __v_18: G = { let __values: [G; 4] = [__v_15, __v_16, __v_17, __v_17]; let __mq = record.memory_queries.get_mut(&4).ok_or(ExecError::InvalidMemorySize(4))?; if let Some(result) = __mq.get_mut(&__values[..]) { if !unconstrained { *result.multiplicity += G::ONE; } result.output[0] } else { let __ptr = G::from_usize(__mq.len()); __mq.insert(&__values[..], &[__ptr], G::from_bool(!unconstrained)); __ptr } }; - let __ret: [G; OUT_523] = [__v_14, __v_18]; - if let Some(result) = record.function_queries[523].get_mut(&inp[..]) { debug_assert_eq!(result.output, &__ret[..]); if !unconstrained { *result.multiplicity += G::ONE; } } else { record.function_queries[523].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained)); }; + let __ret: [G; OUT_519] = [__v_14, __v_18]; + if let Some(result) = record.function_queries[519].get_mut(&inp[..]) { debug_assert_eq!(result.output, &__ret[..]); if !unconstrained { *result.multiplicity += G::ONE; } } else { record.function_queries[519].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained)); }; return Ok(__ret); }, 1u64 => { - let __r_arr: [G; OUT_243] = { let __args: [G; IN_243] = [__v_11]; let __cu = unconstrained; if let Some(result) = record.function_queries[243].get_mut(&__args[..]) { if !__cu && *result.multiplicity == G::ZERO { aiur_fn_243(__args, record, io_buffer, false)? } else { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_243] = unsafe { *(result.output.as_ptr() as *const [G; OUT_243]) }; __ret } } else { aiur_fn_243(__args, record, io_buffer, __cu)? } }; + let __r_arr: [G; OUT_239] = { let __args: [G; IN_239] = [__v_11]; let __cu = unconstrained; if let Some(result) = record.function_queries[239].get_mut(&__args[..]) { if !__cu && *result.multiplicity == G::ZERO { aiur_fn_239(__args, record, io_buffer, false)? } else { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_239] = unsafe { *(result.output.as_ptr() as *const [G; OUT_239]) }; __ret } } else { aiur_fn_239(__args, record, io_buffer, __cu)? } }; let __v_14: G = __r_arr[0]; let __v_15: G = __r_arr[1]; match __v_14.as_canonical_u64() { @@ -45580,8 +45296,8 @@ fn aiur_fn_523( let __v_18: G = G::from_u64(0); let __v_19: G = G::from_u64(0); let __v_20: G = { let __values: [G; 4] = [__v_17, __v_18, __v_19, __v_19]; let __mq = record.memory_queries.get_mut(&4).ok_or(ExecError::InvalidMemorySize(4))?; if let Some(result) = __mq.get_mut(&__values[..]) { if !unconstrained { *result.multiplicity += G::ONE; } result.output[0] } else { let __ptr = G::from_usize(__mq.len()); __mq.insert(&__values[..], &[__ptr], G::from_bool(!unconstrained)); __ptr } }; - let __ret: [G; OUT_523] = [__v_16, __v_20]; - if let Some(result) = record.function_queries[523].get_mut(&inp[..]) { debug_assert_eq!(result.output, &__ret[..]); if !unconstrained { *result.multiplicity += G::ONE; } } else { record.function_queries[523].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained)); }; + let __ret: [G; OUT_519] = [__v_16, __v_20]; + if let Some(result) = record.function_queries[519].get_mut(&inp[..]) { debug_assert_eq!(result.output, &__ret[..]); if !unconstrained { *result.multiplicity += G::ONE; } } else { record.function_queries[519].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained)); }; return Ok(__ret); }, 1u64 => { @@ -45592,18 +45308,18 @@ fn aiur_fn_523( break '__mc_0 [__v_16]; }, _ => { - let __r_arr: [G; OUT_338] = { let __args: [G; IN_338] = [__v_13, __v_15]; let __cu = unconstrained; if let Some(result) = record.function_queries[338].get_mut(&__args[..]) { if !__cu && *result.multiplicity == G::ZERO { aiur_fn_338(__args, record, io_buffer, false)? } else { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_338] = unsafe { *(result.output.as_ptr() as *const [G; OUT_338]) }; __ret } } else { aiur_fn_338(__args, record, io_buffer, __cu)? } }; + let __r_arr: [G; OUT_334] = { let __args: [G; IN_334] = [__v_13, __v_15]; let __cu = unconstrained; if let Some(result) = record.function_queries[334].get_mut(&__args[..]) { if !__cu && *result.multiplicity == G::ZERO { aiur_fn_334(__args, record, io_buffer, false)? } else { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_334] = unsafe { *(result.output.as_ptr() as *const [G; OUT_334]) }; __ret } } else { aiur_fn_334(__args, record, io_buffer, __cu)? } }; let __v_16: G = __r_arr[0]; break '__mc_0 [__v_16]; }, } }; let __v_16: G = __mc_out___mc_0[0]; - let __r_arr: [G; OUT_524] = { let __args: [G; IN_524] = [__v_0, __v_1, __v_16, __v_7, __v_9, __v_2, __v_3, __v_4, __v_5]; let __cu = unconstrained; if let Some(result) = record.function_queries[524].get_mut(&__args[..]) { if !__cu && *result.multiplicity == G::ZERO { aiur_fn_524(__args, record, io_buffer, false)? } else { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_524] = unsafe { *(result.output.as_ptr() as *const [G; OUT_524]) }; __ret } } else { aiur_fn_524(__args, record, io_buffer, __cu)? } }; + let __r_arr: [G; OUT_520] = { let __args: [G; IN_520] = [__v_0, __v_1, __v_16, __v_7, __v_9, __v_2, __v_3, __v_4, __v_5]; let __cu = unconstrained; if let Some(result) = record.function_queries[520].get_mut(&__args[..]) { if !__cu && *result.multiplicity == G::ZERO { aiur_fn_520(__args, record, io_buffer, false)? } else { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_520] = unsafe { *(result.output.as_ptr() as *const [G; OUT_520]) }; __ret } } else { aiur_fn_520(__args, record, io_buffer, __cu)? } }; let __v_17: G = __r_arr[0]; let __v_18: G = __r_arr[1]; - let __ret: [G; OUT_523] = [__v_17, __v_18]; - if let Some(result) = record.function_queries[523].get_mut(&inp[..]) { debug_assert_eq!(result.output, &__ret[..]); if !unconstrained { *result.multiplicity += G::ONE; } } else { record.function_queries[523].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained)); }; + let __ret: [G; OUT_519] = [__v_17, __v_18]; + if let Some(result) = record.function_queries[519].get_mut(&inp[..]) { debug_assert_eq!(result.output, &__ret[..]); if !unconstrained { *result.multiplicity += G::ONE; } } else { record.function_queries[519].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained)); }; return Ok(__ret); }, _ => { @@ -45618,15 +45334,15 @@ fn aiur_fn_523( }) } -const INPUT_SIZE_524: usize = 9; -const IN_524: usize = 9; -const OUT_524: usize = 2; -fn aiur_fn_524( - inp: [G; IN_524], +const INPUT_SIZE_520: usize = 9; +const IN_520: usize = 9; +const OUT_520: usize = 2; +fn aiur_fn_520( + inp: [G; IN_520], record: &mut QueryRecord, io_buffer: &mut IOBuffer, unconstrained: bool, -) -> Result<[G; OUT_524], ExecError> { +) -> Result<[G; OUT_520], ExecError> { stacker::maybe_grow(64 * 1024, 4 * 1024 * 1024, || { let __v_0: G = inp[0]; let __v_1: G = inp[1]; @@ -45647,8 +45363,8 @@ fn aiur_fn_524( let __v_14: G = G::from_u64(0); let __v_15: G = G::from_u64(0); let __v_16: G = { let __values: [G; 4] = [__v_13, __v_14, __v_15, __v_15]; let __mq = record.memory_queries.get_mut(&4).ok_or(ExecError::InvalidMemorySize(4))?; if let Some(result) = __mq.get_mut(&__values[..]) { if !unconstrained { *result.multiplicity += G::ONE; } result.output[0] } else { let __ptr = G::from_usize(__mq.len()); __mq.insert(&__values[..], &[__ptr], G::from_bool(!unconstrained)); __ptr } }; - let __ret: [G; OUT_524] = [__v_12, __v_16]; - if let Some(result) = record.function_queries[524].get_mut(&inp[..]) { debug_assert_eq!(result.output, &__ret[..]); if !unconstrained { *result.multiplicity += G::ONE; } } else { record.function_queries[524].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained)); }; + let __ret: [G; OUT_520] = [__v_12, __v_16]; + if let Some(result) = record.function_queries[520].get_mut(&inp[..]) { debug_assert_eq!(result.output, &__ret[..]); if !unconstrained { *result.multiplicity += G::ONE; } } else { record.function_queries[520].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained)); }; return Ok(__ret); }, _ => { @@ -45664,12 +45380,12 @@ fn aiur_fn_524( let __v_21: G = { let __values: [G; 3] = [__v_19, __v_20, __v_20]; let __mq = record.memory_queries.get_mut(&3).ok_or(ExecError::InvalidMemorySize(3))?; if let Some(result) = __mq.get_mut(&__values[..]) { if !unconstrained { *result.multiplicity += G::ONE; } result.output[0] } else { let __ptr = G::from_usize(__mq.len()); __mq.insert(&__values[..], &[__ptr], G::from_bool(!unconstrained)); __ptr } }; let __v_22: G = { let __values: [G; 3] = [__v_18, __v_17, __v_21]; let __mq = record.memory_queries.get_mut(&3).ok_or(ExecError::InvalidMemorySize(3))?; if let Some(result) = __mq.get_mut(&__values[..]) { if !unconstrained { *result.multiplicity += G::ONE; } result.output[0] } else { let __ptr = G::from_usize(__mq.len()); __mq.insert(&__values[..], &[__ptr], G::from_bool(!unconstrained)); __ptr } }; let __v_23: G = G::from_u64(2); - let __r_arr: [G; OUT_511] = { let __args: [G; IN_511] = []; let __cu = unconstrained; if let Some(result) = record.function_queries[511].get_mut(&__args[..]) { if !__cu && *result.multiplicity == G::ZERO { aiur_fn_511(__args, record, io_buffer, false)? } else { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_511] = unsafe { *(result.output.as_ptr() as *const [G; OUT_511]) }; __ret } } else { aiur_fn_511(__args, record, io_buffer, __cu)? } }; + let __r_arr: [G; OUT_507] = { let __args: [G; IN_507] = []; let __cu = unconstrained; if let Some(result) = record.function_queries[507].get_mut(&__args[..]) { if !__cu && *result.multiplicity == G::ZERO { aiur_fn_507(__args, record, io_buffer, false)? } else { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_507] = unsafe { *(result.output.as_ptr() as *const [G; OUT_507]) }; __ret } } else { aiur_fn_507(__args, record, io_buffer, __cu)? } }; let __v_24: G = __r_arr[0]; let __v_25: G = G::from_u64(0); let __v_26: G = { let __values: [G; 4] = [__v_23, __v_24, __v_22, __v_25]; let __mq = record.memory_queries.get_mut(&4).ok_or(ExecError::InvalidMemorySize(4))?; if let Some(result) = __mq.get_mut(&__values[..]) { if !unconstrained { *result.multiplicity += G::ONE; } result.output[0] } else { let __ptr = G::from_usize(__mq.len()); __mq.insert(&__values[..], &[__ptr], G::from_bool(!unconstrained)); __ptr } }; let __v_27: G = G::from_u64(2); - let __r_arr: [G; OUT_510] = { let __args: [G; IN_510] = []; let __cu = unconstrained; if let Some(result) = record.function_queries[510].get_mut(&__args[..]) { if !__cu && *result.multiplicity == G::ZERO { aiur_fn_510(__args, record, io_buffer, false)? } else { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_510] = unsafe { *(result.output.as_ptr() as *const [G; OUT_510]) }; __ret } } else { aiur_fn_510(__args, record, io_buffer, __cu)? } }; + let __r_arr: [G; OUT_506] = { let __args: [G; IN_506] = []; let __cu = unconstrained; if let Some(result) = record.function_queries[506].get_mut(&__args[..]) { if !__cu && *result.multiplicity == G::ZERO { aiur_fn_506(__args, record, io_buffer, false)? } else { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_506] = unsafe { *(result.output.as_ptr() as *const [G; OUT_506]) }; __ret } } else { aiur_fn_506(__args, record, io_buffer, __cu)? } }; let __v_28: G = __r_arr[0]; let __v_29: G = G::from_u64(1); let __v_30: G = G::from_u64(1); @@ -45706,12 +45422,12 @@ fn aiur_fn_524( 1u64 => { match __v_2.as_canonical_u64() { 1u64 => { - let __r_arr: [G; OUT_506] = { let __args: [G; IN_506] = []; let __cu = unconstrained; if let Some(result) = record.function_queries[506].get_mut(&__args[..]) { if !__cu && *result.multiplicity == G::ZERO { aiur_fn_506(__args, record, io_buffer, false)? } else { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_506] = unsafe { *(result.output.as_ptr() as *const [G; OUT_506]) }; __ret } } else { aiur_fn_506(__args, record, io_buffer, __cu)? } }; + let __r_arr: [G; OUT_502] = { let __args: [G; IN_502] = []; let __cu = unconstrained; if let Some(result) = record.function_queries[502].get_mut(&__args[..]) { if !__cu && *result.multiplicity == G::ZERO { aiur_fn_502(__args, record, io_buffer, false)? } else { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_502] = unsafe { *(result.output.as_ptr() as *const [G; OUT_502]) }; __ret } } else { aiur_fn_502(__args, record, io_buffer, __cu)? } }; let __v_47: G = __r_arr[0]; break '__mc_1 [__v_47]; }, _ => { - let __r_arr: [G; OUT_507] = { let __args: [G; IN_507] = []; let __cu = unconstrained; if let Some(result) = record.function_queries[507].get_mut(&__args[..]) { if !__cu && *result.multiplicity == G::ZERO { aiur_fn_507(__args, record, io_buffer, false)? } else { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_507] = unsafe { *(result.output.as_ptr() as *const [G; OUT_507]) }; __ret } } else { aiur_fn_507(__args, record, io_buffer, __cu)? } }; + let __r_arr: [G; OUT_503] = { let __args: [G; IN_503] = []; let __cu = unconstrained; if let Some(result) = record.function_queries[503].get_mut(&__args[..]) { if !__cu && *result.multiplicity == G::ZERO { aiur_fn_503(__args, record, io_buffer, false)? } else { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_503] = unsafe { *(result.output.as_ptr() as *const [G; OUT_503]) }; __ret } } else { aiur_fn_503(__args, record, io_buffer, __cu)? } }; let __v_47: G = __r_arr[0]; break '__mc_1 [__v_47]; }, @@ -45720,12 +45436,12 @@ fn aiur_fn_524( _ => { match __v_2.as_canonical_u64() { 1u64 => { - let __r_arr: [G; OUT_508] = { let __args: [G; IN_508] = []; let __cu = unconstrained; if let Some(result) = record.function_queries[508].get_mut(&__args[..]) { if !__cu && *result.multiplicity == G::ZERO { aiur_fn_508(__args, record, io_buffer, false)? } else { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_508] = unsafe { *(result.output.as_ptr() as *const [G; OUT_508]) }; __ret } } else { aiur_fn_508(__args, record, io_buffer, __cu)? } }; + let __r_arr: [G; OUT_504] = { let __args: [G; IN_504] = []; let __cu = unconstrained; if let Some(result) = record.function_queries[504].get_mut(&__args[..]) { if !__cu && *result.multiplicity == G::ZERO { aiur_fn_504(__args, record, io_buffer, false)? } else { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_504] = unsafe { *(result.output.as_ptr() as *const [G; OUT_504]) }; __ret } } else { aiur_fn_504(__args, record, io_buffer, __cu)? } }; let __v_47: G = __r_arr[0]; break '__mc_1 [__v_47]; }, _ => { - let __r_arr: [G; OUT_509] = { let __args: [G; IN_509] = []; let __cu = unconstrained; if let Some(result) = record.function_queries[509].get_mut(&__args[..]) { if !__cu && *result.multiplicity == G::ZERO { aiur_fn_509(__args, record, io_buffer, false)? } else { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_509] = unsafe { *(result.output.as_ptr() as *const [G; OUT_509]) }; __ret } } else { aiur_fn_509(__args, record, io_buffer, __cu)? } }; + let __r_arr: [G; OUT_505] = { let __args: [G; IN_505] = []; let __cu = unconstrained; if let Some(result) = record.function_queries[505].get_mut(&__args[..]) { if !__cu && *result.multiplicity == G::ZERO { aiur_fn_505(__args, record, io_buffer, false)? } else { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_505] = unsafe { *(result.output.as_ptr() as *const [G; OUT_505]) }; __ret } } else { aiur_fn_505(__args, record, io_buffer, __cu)? } }; let __v_47: G = __r_arr[0]; break '__mc_1 [__v_47]; }, @@ -45749,31 +45465,31 @@ fn aiur_fn_524( let __v_60: G = G::from_u64(3); let __v_61: G = G::from_u64(0); let __v_62: G = { let __values: [G; 4] = [__v_60, __v_59, __v_46, __v_61]; let __mq = record.memory_queries.get_mut(&4).ok_or(ExecError::InvalidMemorySize(4))?; if let Some(result) = __mq.get_mut(&__values[..]) { if !unconstrained { *result.multiplicity += G::ONE; } result.output[0] } else { let __ptr = G::from_usize(__mq.len()); __mq.insert(&__values[..], &[__ptr], G::from_bool(!unconstrained)); __ptr } }; - let __r_arr: [G; OUT_527] = { let __args: [G; IN_527] = [__v_2, __v_62, __v_5, __v_6, __v_7, __v_8]; let __cu = unconstrained; if let Some(result) = record.function_queries[527].get_mut(&__args[..]) { if !__cu && *result.multiplicity == G::ZERO { aiur_fn_527(__args, record, io_buffer, false)? } else { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_527] = unsafe { *(result.output.as_ptr() as *const [G; OUT_527]) }; __ret } } else { aiur_fn_527(__args, record, io_buffer, __cu)? } }; + let __r_arr: [G; OUT_523] = { let __args: [G; IN_523] = [__v_2, __v_62, __v_5, __v_6, __v_7, __v_8]; let __cu = unconstrained; if let Some(result) = record.function_queries[523].get_mut(&__args[..]) { if !__cu && *result.multiplicity == G::ZERO { aiur_fn_523(__args, record, io_buffer, false)? } else { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_523] = unsafe { *(result.output.as_ptr() as *const [G; OUT_523]) }; __ret } } else { aiur_fn_523(__args, record, io_buffer, __cu)? } }; let __v_63: G = __r_arr[0]; let __v_64: G = __r_arr[1]; - let __ret: [G; OUT_524] = [__v_63, __v_64]; - if let Some(result) = record.function_queries[524].get_mut(&inp[..]) { debug_assert_eq!(result.output, &__ret[..]); if !unconstrained { *result.multiplicity += G::ONE; } } else { record.function_queries[524].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained)); }; + let __ret: [G; OUT_520] = [__v_63, __v_64]; + if let Some(result) = record.function_queries[520].get_mut(&inp[..]) { debug_assert_eq!(result.output, &__ret[..]); if !unconstrained { *result.multiplicity += G::ONE; } } else { record.function_queries[520].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained)); }; return Ok(__ret); }, } }) } -const INPUT_SIZE_525: usize = 3; -const IN_525: usize = 3; -const OUT_525: usize = 2; -fn aiur_fn_525( - inp: [G; IN_525], +const INPUT_SIZE_521: usize = 3; +const IN_521: usize = 3; +const OUT_521: usize = 2; +fn aiur_fn_521( + inp: [G; IN_521], record: &mut QueryRecord, io_buffer: &mut IOBuffer, unconstrained: bool, -) -> Result<[G; OUT_525], ExecError> { +) -> Result<[G; OUT_521], ExecError> { stacker::maybe_grow(64 * 1024, 4 * 1024 * 1024, || { let __v_0: G = inp[0]; let __v_1: G = inp[1]; let __v_2: G = inp[2]; - let __r_arr: [G; OUT_764] = { let __args: [G; IN_764] = [__v_1]; let __cu = unconstrained; if let Some(result) = record.function_queries[764].get_mut(&__args[..]) { if !__cu && *result.multiplicity == G::ZERO { aiur_fn_764(__args, record, io_buffer, false)? } else { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_764] = unsafe { *(result.output.as_ptr() as *const [G; OUT_764]) }; __ret } } else { aiur_fn_764(__args, record, io_buffer, __cu)? } }; + let __r_arr: [G; OUT_760] = { let __args: [G; IN_760] = [__v_1]; let __cu = unconstrained; if let Some(result) = record.function_queries[760].get_mut(&__args[..]) { if !__cu && *result.multiplicity == G::ZERO { aiur_fn_760(__args, record, io_buffer, false)? } else { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_760] = unsafe { *(result.output.as_ptr() as *const [G; OUT_760]) }; __ret } } else { aiur_fn_760(__args, record, io_buffer, __cu)? } }; let __v_3: G = __r_arr[0]; let __v_4: G = G::from_u64(2); let __v_5: G = { let __a_val = __v_3.as_canonical_u64(); let __b_val = __v_4.as_canonical_u64(); let __a_u32 = u32::try_from(__a_val).ok().ok_or(ExecError::U32OutOfRange(__a_val))?; let __b_u32 = u32::try_from(__b_val).ok().ok_or(ExecError::U32OutOfRange(__b_val))?; let __result = G::from_bool(__a_u32 < __b_u32); if !unconstrained { let __x_bytes = __a_u32.to_le_bytes(); let __z_bytes = __b_u32.to_le_bytes(); let __c_u32 = __b_u32.wrapping_sub(__a_u32).wrapping_sub(1); let __y_bytes = __c_u32.to_le_bytes(); record.bytes2_queries.bump_range_check(&G::from_u8(__x_bytes[0]), &G::from_u8(__x_bytes[1])); record.bytes2_queries.bump_range_check(&G::from_u8(__x_bytes[2]), &G::from_u8(__x_bytes[3])); record.bytes2_queries.bump_range_check(&G::from_u8(__y_bytes[0]), &G::from_u8(__y_bytes[1])); record.bytes2_queries.bump_range_check(&G::from_u8(__y_bytes[2]), &G::from_u8(__y_bytes[3])); record.bytes2_queries.bump_range_check(&G::from_u8(__z_bytes[0]), &G::from_u8(__z_bytes[1])); record.bytes2_queries.bump_range_check(&G::from_u8(__z_bytes[2]), &G::from_u8(__z_bytes[3])); } __result }; @@ -45784,16 +45500,16 @@ fn aiur_fn_525( let __v_8: G = G::from_u64(0); let __v_9: G = G::from_u64(0); let __v_10: G = { let __values: [G; 4] = [__v_7, __v_8, __v_9, __v_9]; let __mq = record.memory_queries.get_mut(&4).ok_or(ExecError::InvalidMemorySize(4))?; if let Some(result) = __mq.get_mut(&__values[..]) { if !unconstrained { *result.multiplicity += G::ONE; } result.output[0] } else { let __ptr = G::from_usize(__mq.len()); __mq.insert(&__values[..], &[__ptr], G::from_bool(!unconstrained)); __ptr } }; - let __ret: [G; OUT_525] = [__v_6, __v_10]; - if let Some(result) = record.function_queries[525].get_mut(&inp[..]) { debug_assert_eq!(result.output, &__ret[..]); if !unconstrained { *result.multiplicity += G::ONE; } } else { record.function_queries[525].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained)); }; + let __ret: [G; OUT_521] = [__v_6, __v_10]; + if let Some(result) = record.function_queries[521].get_mut(&inp[..]) { debug_assert_eq!(result.output, &__ret[..]); if !unconstrained { *result.multiplicity += G::ONE; } } else { record.function_queries[521].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained)); }; return Ok(__ret); }, _ => { let __v_6: G = G::from_u64(0); - let __r_arr: [G; OUT_766] = { let __args: [G; IN_766] = [__v_1, __v_6]; let __cu = unconstrained; if let Some(result) = record.function_queries[766].get_mut(&__args[..]) { if !__cu && *result.multiplicity == G::ZERO { aiur_fn_766(__args, record, io_buffer, false)? } else { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_766] = unsafe { *(result.output.as_ptr() as *const [G; OUT_766]) }; __ret } } else { aiur_fn_766(__args, record, io_buffer, __cu)? } }; + let __r_arr: [G; OUT_762] = { let __args: [G; IN_762] = [__v_1, __v_6]; let __cu = unconstrained; if let Some(result) = record.function_queries[762].get_mut(&__args[..]) { if !__cu && *result.multiplicity == G::ZERO { aiur_fn_762(__args, record, io_buffer, false)? } else { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_762] = unsafe { *(result.output.as_ptr() as *const [G; OUT_762]) }; __ret } } else { aiur_fn_762(__args, record, io_buffer, __cu)? } }; let __v_7: G = __r_arr[0]; let __v_8: G = G::from_u64(1); - let __r_arr: [G; OUT_766] = { let __args: [G; IN_766] = [__v_1, __v_8]; let __cu = unconstrained; if let Some(result) = record.function_queries[766].get_mut(&__args[..]) { if !__cu && *result.multiplicity == G::ZERO { aiur_fn_766(__args, record, io_buffer, false)? } else { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_766] = unsafe { *(result.output.as_ptr() as *const [G; OUT_766]) }; __ret } } else { aiur_fn_766(__args, record, io_buffer, __cu)? } }; + let __r_arr: [G; OUT_762] = { let __args: [G; IN_762] = [__v_1, __v_8]; let __cu = unconstrained; if let Some(result) = record.function_queries[762].get_mut(&__args[..]) { if !__cu && *result.multiplicity == G::ZERO { aiur_fn_762(__args, record, io_buffer, false)? } else { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_762] = unsafe { *(result.output.as_ptr() as *const [G; OUT_762]) }; __ret } } else { aiur_fn_762(__args, record, io_buffer, __cu)? } }; let __v_9: G = __r_arr[0]; let __loaded: [G; 4] = { let __mq = record.memory_queries.get_mut(&4).ok_or(ExecError::InvalidMemorySize(4))?; let __ptr_u64 = __v_7.as_canonical_u64(); let __ptr_usize = usize::try_from(__ptr_u64).ok().ok_or(ExecError::PointerTooLarge(__ptr_u64))?; let (__args, __mult) = __mq.get_index_mut(__ptr_usize).ok_or(ExecError::UnboundPointer { ptr: __ptr_u64, size: 4 })?; if !unconstrained { *__mult += G::ONE; } let __arr: [G; 4] = __args[..4].try_into().unwrap(); __arr }; let __v_10: G = __loaded[0]; @@ -45813,7 +45529,7 @@ fn aiur_fn_525( 7u64 => { match __v_15.as_canonical_u64() { 1u64 => { - let __r_arr: [G; OUT_339] = { let __args: [G; IN_339] = [__v_12, __v_16]; let __cu = unconstrained; if let Some(result) = record.function_queries[339].get_mut(&__args[..]) { if !__cu && *result.multiplicity == G::ZERO { aiur_fn_339(__args, record, io_buffer, false)? } else { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_339] = unsafe { *(result.output.as_ptr() as *const [G; OUT_339]) }; __ret } } else { aiur_fn_339(__args, record, io_buffer, __cu)? } }; + let __r_arr: [G; OUT_335] = { let __args: [G; IN_335] = [__v_12, __v_16]; let __cu = unconstrained; if let Some(result) = record.function_queries[335].get_mut(&__args[..]) { if !__cu && *result.multiplicity == G::ZERO { aiur_fn_335(__args, record, io_buffer, false)? } else { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_335] = unsafe { *(result.output.as_ptr() as *const [G; OUT_335]) }; __ret } } else { aiur_fn_335(__args, record, io_buffer, __cu)? } }; let __v_18: G = __r_arr[0]; match __v_18.as_canonical_u64() { 0u64 => { @@ -45822,16 +45538,16 @@ fn aiur_fn_525( let __v_21: G = G::from_u64(0); let __v_22: G = G::from_u64(0); let __v_23: G = { let __values: [G; 4] = [__v_20, __v_21, __v_22, __v_22]; let __mq = record.memory_queries.get_mut(&4).ok_or(ExecError::InvalidMemorySize(4))?; if let Some(result) = __mq.get_mut(&__values[..]) { if !unconstrained { *result.multiplicity += G::ONE; } result.output[0] } else { let __ptr = G::from_usize(__mq.len()); __mq.insert(&__values[..], &[__ptr], G::from_bool(!unconstrained)); __ptr } }; - let __ret: [G; OUT_525] = [__v_19, __v_23]; - if let Some(result) = record.function_queries[525].get_mut(&inp[..]) { debug_assert_eq!(result.output, &__ret[..]); if !unconstrained { *result.multiplicity += G::ONE; } } else { record.function_queries[525].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained)); }; + let __ret: [G; OUT_521] = [__v_19, __v_23]; + if let Some(result) = record.function_queries[521].get_mut(&inp[..]) { debug_assert_eq!(result.output, &__ret[..]); if !unconstrained { *result.multiplicity += G::ONE; } } else { record.function_queries[521].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained)); }; return Ok(__ret); }, _ => { - let __r_arr: [G; OUT_526] = { let __args: [G; IN_526] = [__v_12, __v_0, __v_1, __v_2]; let __cu = unconstrained; if let Some(result) = record.function_queries[526].get_mut(&__args[..]) { if !__cu && *result.multiplicity == G::ZERO { aiur_fn_526(__args, record, io_buffer, false)? } else { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_526] = unsafe { *(result.output.as_ptr() as *const [G; OUT_526]) }; __ret } } else { aiur_fn_526(__args, record, io_buffer, __cu)? } }; + let __r_arr: [G; OUT_522] = { let __args: [G; IN_522] = [__v_12, __v_0, __v_1, __v_2]; let __cu = unconstrained; if let Some(result) = record.function_queries[522].get_mut(&__args[..]) { if !__cu && *result.multiplicity == G::ZERO { aiur_fn_522(__args, record, io_buffer, false)? } else { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_522] = unsafe { *(result.output.as_ptr() as *const [G; OUT_522]) }; __ret } } else { aiur_fn_522(__args, record, io_buffer, __cu)? } }; let __v_19: G = __r_arr[0]; let __v_20: G = __r_arr[1]; - let __ret: [G; OUT_525] = [__v_19, __v_20]; - if let Some(result) = record.function_queries[525].get_mut(&inp[..]) { debug_assert_eq!(result.output, &__ret[..]); if !unconstrained { *result.multiplicity += G::ONE; } } else { record.function_queries[525].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained)); }; + let __ret: [G; OUT_521] = [__v_19, __v_20]; + if let Some(result) = record.function_queries[521].get_mut(&inp[..]) { debug_assert_eq!(result.output, &__ret[..]); if !unconstrained { *result.multiplicity += G::ONE; } } else { record.function_queries[521].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained)); }; return Ok(__ret); }, } @@ -45842,8 +45558,8 @@ fn aiur_fn_525( let __v_20: G = G::from_u64(0); let __v_21: G = G::from_u64(0); let __v_22: G = { let __values: [G; 4] = [__v_19, __v_20, __v_21, __v_21]; let __mq = record.memory_queries.get_mut(&4).ok_or(ExecError::InvalidMemorySize(4))?; if let Some(result) = __mq.get_mut(&__values[..]) { if !unconstrained { *result.multiplicity += G::ONE; } result.output[0] } else { let __ptr = G::from_usize(__mq.len()); __mq.insert(&__values[..], &[__ptr], G::from_bool(!unconstrained)); __ptr } }; - let __ret: [G; OUT_525] = [__v_18, __v_22]; - if let Some(result) = record.function_queries[525].get_mut(&inp[..]) { debug_assert_eq!(result.output, &__ret[..]); if !unconstrained { *result.multiplicity += G::ONE; } } else { record.function_queries[525].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained)); }; + let __ret: [G; OUT_521] = [__v_18, __v_22]; + if let Some(result) = record.function_queries[521].get_mut(&inp[..]) { debug_assert_eq!(result.output, &__ret[..]); if !unconstrained { *result.multiplicity += G::ONE; } } else { record.function_queries[521].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained)); }; return Ok(__ret); }, } @@ -45854,8 +45570,8 @@ fn aiur_fn_525( let __v_20: G = G::from_u64(0); let __v_21: G = G::from_u64(0); let __v_22: G = { let __values: [G; 4] = [__v_19, __v_20, __v_21, __v_21]; let __mq = record.memory_queries.get_mut(&4).ok_or(ExecError::InvalidMemorySize(4))?; if let Some(result) = __mq.get_mut(&__values[..]) { if !unconstrained { *result.multiplicity += G::ONE; } result.output[0] } else { let __ptr = G::from_usize(__mq.len()); __mq.insert(&__values[..], &[__ptr], G::from_bool(!unconstrained)); __ptr } }; - let __ret: [G; OUT_525] = [__v_18, __v_22]; - if let Some(result) = record.function_queries[525].get_mut(&inp[..]) { debug_assert_eq!(result.output, &__ret[..]); if !unconstrained { *result.multiplicity += G::ONE; } } else { record.function_queries[525].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained)); }; + let __ret: [G; OUT_521] = [__v_18, __v_22]; + if let Some(result) = record.function_queries[521].get_mut(&inp[..]) { debug_assert_eq!(result.output, &__ret[..]); if !unconstrained { *result.multiplicity += G::ONE; } } else { record.function_queries[521].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained)); }; return Ok(__ret); }, } @@ -45866,8 +45582,8 @@ fn aiur_fn_525( let __v_16: G = G::from_u64(0); let __v_17: G = G::from_u64(0); let __v_18: G = { let __values: [G; 4] = [__v_15, __v_16, __v_17, __v_17]; let __mq = record.memory_queries.get_mut(&4).ok_or(ExecError::InvalidMemorySize(4))?; if let Some(result) = __mq.get_mut(&__values[..]) { if !unconstrained { *result.multiplicity += G::ONE; } result.output[0] } else { let __ptr = G::from_usize(__mq.len()); __mq.insert(&__values[..], &[__ptr], G::from_bool(!unconstrained)); __ptr } }; - let __ret: [G; OUT_525] = [__v_14, __v_18]; - if let Some(result) = record.function_queries[525].get_mut(&inp[..]) { debug_assert_eq!(result.output, &__ret[..]); if !unconstrained { *result.multiplicity += G::ONE; } } else { record.function_queries[525].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained)); }; + let __ret: [G; OUT_521] = [__v_14, __v_18]; + if let Some(result) = record.function_queries[521].get_mut(&inp[..]) { debug_assert_eq!(result.output, &__ret[..]); if !unconstrained { *result.multiplicity += G::ONE; } } else { record.function_queries[521].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained)); }; return Ok(__ret); }, } @@ -45878,8 +45594,8 @@ fn aiur_fn_525( let __v_16: G = G::from_u64(0); let __v_17: G = G::from_u64(0); let __v_18: G = { let __values: [G; 4] = [__v_15, __v_16, __v_17, __v_17]; let __mq = record.memory_queries.get_mut(&4).ok_or(ExecError::InvalidMemorySize(4))?; if let Some(result) = __mq.get_mut(&__values[..]) { if !unconstrained { *result.multiplicity += G::ONE; } result.output[0] } else { let __ptr = G::from_usize(__mq.len()); __mq.insert(&__values[..], &[__ptr], G::from_bool(!unconstrained)); __ptr } }; - let __ret: [G; OUT_525] = [__v_14, __v_18]; - if let Some(result) = record.function_queries[525].get_mut(&inp[..]) { debug_assert_eq!(result.output, &__ret[..]); if !unconstrained { *result.multiplicity += G::ONE; } } else { record.function_queries[525].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained)); }; + let __ret: [G; OUT_521] = [__v_14, __v_18]; + if let Some(result) = record.function_queries[521].get_mut(&inp[..]) { debug_assert_eq!(result.output, &__ret[..]); if !unconstrained { *result.multiplicity += G::ONE; } } else { record.function_queries[521].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained)); }; return Ok(__ret); }, } @@ -45888,15 +45604,15 @@ fn aiur_fn_525( }) } -const INPUT_SIZE_526: usize = 4; -const IN_526: usize = 4; -const OUT_526: usize = 2; -fn aiur_fn_526( - inp: [G; IN_526], +const INPUT_SIZE_522: usize = 4; +const IN_522: usize = 4; +const OUT_522: usize = 2; +fn aiur_fn_522( + inp: [G; IN_522], record: &mut QueryRecord, io_buffer: &mut IOBuffer, unconstrained: bool, -) -> Result<[G; OUT_526], ExecError> { +) -> Result<[G; OUT_522], ExecError> { stacker::maybe_grow(64 * 1024, 4 * 1024 * 1024, || { let __v_0: G = inp[0]; let __v_1: G = inp[1]; @@ -45914,12 +45630,12 @@ fn aiur_fn_526( let __v_13: G = { let __values: [G; 3] = [__v_11, __v_12, __v_12]; let __mq = record.memory_queries.get_mut(&3).ok_or(ExecError::InvalidMemorySize(3))?; if let Some(result) = __mq.get_mut(&__values[..]) { if !unconstrained { *result.multiplicity += G::ONE; } result.output[0] } else { let __ptr = G::from_usize(__mq.len()); __mq.insert(&__values[..], &[__ptr], G::from_bool(!unconstrained)); __ptr } }; let __v_14: G = { let __values: [G; 3] = [__v_10, __v_9, __v_13]; let __mq = record.memory_queries.get_mut(&3).ok_or(ExecError::InvalidMemorySize(3))?; if let Some(result) = __mq.get_mut(&__values[..]) { if !unconstrained { *result.multiplicity += G::ONE; } result.output[0] } else { let __ptr = G::from_usize(__mq.len()); __mq.insert(&__values[..], &[__ptr], G::from_bool(!unconstrained)); __ptr } }; let __v_15: G = G::from_u64(2); - let __r_arr: [G; OUT_511] = { let __args: [G; IN_511] = []; let __cu = unconstrained; if let Some(result) = record.function_queries[511].get_mut(&__args[..]) { if !__cu && *result.multiplicity == G::ZERO { aiur_fn_511(__args, record, io_buffer, false)? } else { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_511] = unsafe { *(result.output.as_ptr() as *const [G; OUT_511]) }; __ret } } else { aiur_fn_511(__args, record, io_buffer, __cu)? } }; + let __r_arr: [G; OUT_507] = { let __args: [G; IN_507] = []; let __cu = unconstrained; if let Some(result) = record.function_queries[507].get_mut(&__args[..]) { if !__cu && *result.multiplicity == G::ZERO { aiur_fn_507(__args, record, io_buffer, false)? } else { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_507] = unsafe { *(result.output.as_ptr() as *const [G; OUT_507]) }; __ret } } else { aiur_fn_507(__args, record, io_buffer, __cu)? } }; let __v_16: G = __r_arr[0]; let __v_17: G = G::from_u64(0); let __v_18: G = { let __values: [G; 4] = [__v_15, __v_16, __v_14, __v_17]; let __mq = record.memory_queries.get_mut(&4).ok_or(ExecError::InvalidMemorySize(4))?; if let Some(result) = __mq.get_mut(&__values[..]) { if !unconstrained { *result.multiplicity += G::ONE; } result.output[0] } else { let __ptr = G::from_usize(__mq.len()); __mq.insert(&__values[..], &[__ptr], G::from_bool(!unconstrained)); __ptr } }; let __v_19: G = G::from_u64(2); - let __r_arr: [G; OUT_218] = { let __args: [G; IN_218] = []; let __cu = unconstrained; if let Some(result) = record.function_queries[218].get_mut(&__args[..]) { if !__cu && *result.multiplicity == G::ZERO { aiur_fn_218(__args, record, io_buffer, false)? } else { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_218] = unsafe { *(result.output.as_ptr() as *const [G; OUT_218]) }; __ret } } else { aiur_fn_218(__args, record, io_buffer, __cu)? } }; + let __r_arr: [G; OUT_214] = { let __args: [G; IN_214] = []; let __cu = unconstrained; if let Some(result) = record.function_queries[214].get_mut(&__args[..]) { if !__cu && *result.multiplicity == G::ZERO { aiur_fn_214(__args, record, io_buffer, false)? } else { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_214] = unsafe { *(result.output.as_ptr() as *const [G; OUT_214]) }; __ret } } else { aiur_fn_214(__args, record, io_buffer, __cu)? } }; let __v_20: G = __r_arr[0]; let __v_21: G = G::from_u64(1); let __v_22: G = G::from_u64(1); @@ -45943,18 +45659,18 @@ fn aiur_fn_526( let __v_40: G = G::from_u64(0); let __v_41: G = { let __values: [G; 4] = [__v_36, __v_1, __v_39, __v_40]; let __mq = record.memory_queries.get_mut(&4).ok_or(ExecError::InvalidMemorySize(4))?; if let Some(result) = __mq.get_mut(&__values[..]) { if !unconstrained { *result.multiplicity += G::ONE; } result.output[0] } else { let __ptr = G::from_usize(__mq.len()); __mq.insert(&__values[..], &[__ptr], G::from_bool(!unconstrained)); __ptr } }; let __v_42: G = G::from_u64(2); - let __r_arr: [G; OUT_774] = { let __args: [G; IN_774] = [__v_2, __v_42]; let __cu = unconstrained; if let Some(result) = record.function_queries[774].get_mut(&__args[..]) { if !__cu && *result.multiplicity == G::ZERO { aiur_fn_774(__args, record, io_buffer, false)? } else { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_774] = unsafe { *(result.output.as_ptr() as *const [G; OUT_774]) }; __ret } } else { aiur_fn_774(__args, record, io_buffer, __cu)? } }; + let __r_arr: [G; OUT_770] = { let __args: [G; IN_770] = [__v_2, __v_42]; let __cu = unconstrained; if let Some(result) = record.function_queries[770].get_mut(&__args[..]) { if !__cu && *result.multiplicity == G::ZERO { aiur_fn_770(__args, record, io_buffer, false)? } else { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_770] = unsafe { *(result.output.as_ptr() as *const [G; OUT_770]) }; __ret } } else { aiur_fn_770(__args, record, io_buffer, __cu)? } }; let __v_43: G = __r_arr[0]; - let __r_arr: [G; OUT_255] = { let __args: [G; IN_255] = [__v_41, __v_43]; let __cu = unconstrained; if let Some(result) = record.function_queries[255].get_mut(&__args[..]) { if !__cu && *result.multiplicity == G::ZERO { aiur_fn_255(__args, record, io_buffer, false)? } else { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_255] = unsafe { *(result.output.as_ptr() as *const [G; OUT_255]) }; __ret } } else { aiur_fn_255(__args, record, io_buffer, __cu)? } }; + let __r_arr: [G; OUT_251] = { let __args: [G; IN_251] = [__v_41, __v_43]; let __cu = unconstrained; if let Some(result) = record.function_queries[251].get_mut(&__args[..]) { if !__cu && *result.multiplicity == G::ZERO { aiur_fn_251(__args, record, io_buffer, false)? } else { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_251] = unsafe { *(result.output.as_ptr() as *const [G; OUT_251]) }; __ret } } else { aiur_fn_251(__args, record, io_buffer, __cu)? } }; let __v_44: G = __r_arr[0]; - let __r_arr: [G; OUT_488] = { let __args: [G; IN_488] = [__v_44, __v_3]; let __cu = unconstrained; if let Some(result) = record.function_queries[488].get_mut(&__args[..]) { if !__cu && *result.multiplicity == G::ZERO { aiur_fn_488(__args, record, io_buffer, false)? } else { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_488] = unsafe { *(result.output.as_ptr() as *const [G; OUT_488]) }; __ret } } else { aiur_fn_488(__args, record, io_buffer, __cu)? } }; + let __r_arr: [G; OUT_484] = { let __args: [G; IN_484] = [__v_44, __v_3]; let __cu = unconstrained; if let Some(result) = record.function_queries[484].get_mut(&__args[..]) { if !__cu && *result.multiplicity == G::ZERO { aiur_fn_484(__args, record, io_buffer, false)? } else { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_484] = unsafe { *(result.output.as_ptr() as *const [G; OUT_484]) }; __ret } } else { aiur_fn_484(__args, record, io_buffer, __cu)? } }; let __v_45: G = __r_arr[0]; - let __r_arr: [G; OUT_418] = { let __args: [G; IN_418] = [__v_45, __v_3]; let __cu = unconstrained; if let Some(result) = record.function_queries[418].get_mut(&__args[..]) { if !__cu && *result.multiplicity == G::ZERO { aiur_fn_418(__args, record, io_buffer, false)? } else { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_418] = unsafe { *(result.output.as_ptr() as *const [G; OUT_418]) }; __ret } } else { aiur_fn_418(__args, record, io_buffer, __cu)? } }; + let __r_arr: [G; OUT_414] = { let __args: [G; IN_414] = [__v_45, __v_3]; let __cu = unconstrained; if let Some(result) = record.function_queries[414].get_mut(&__args[..]) { if !__cu && *result.multiplicity == G::ZERO { aiur_fn_414(__args, record, io_buffer, false)? } else { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_414] = unsafe { *(result.output.as_ptr() as *const [G; OUT_414]) }; __ret } } else { aiur_fn_414(__args, record, io_buffer, __cu)? } }; let __v_46: G = __r_arr[0]; let __r_arr: [G; OUT_111] = { let __args: [G; IN_111] = [__v_46]; let __cu = unconstrained; if let Some(result) = record.function_queries[111].get_mut(&__args[..]) { if !__cu && *result.multiplicity == G::ZERO { aiur_fn_111(__args, record, io_buffer, false)? } else { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_111] = unsafe { *(result.output.as_ptr() as *const [G; OUT_111]) }; __ret } } else { aiur_fn_111(__args, record, io_buffer, __cu)? } }; let __v_47: G = __r_arr[0]; let __v_48: G = __r_arr[1]; - let __r_arr: [G; OUT_764] = { let __args: [G; IN_764] = [__v_48]; let __cu = unconstrained; if let Some(result) = record.function_queries[764].get_mut(&__args[..]) { if !__cu && *result.multiplicity == G::ZERO { aiur_fn_764(__args, record, io_buffer, false)? } else { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_764] = unsafe { *(result.output.as_ptr() as *const [G; OUT_764]) }; __ret } } else { aiur_fn_764(__args, record, io_buffer, __cu)? } }; + let __r_arr: [G; OUT_760] = { let __args: [G; IN_760] = [__v_48]; let __cu = unconstrained; if let Some(result) = record.function_queries[760].get_mut(&__args[..]) { if !__cu && *result.multiplicity == G::ZERO { aiur_fn_760(__args, record, io_buffer, false)? } else { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_760] = unsafe { *(result.output.as_ptr() as *const [G; OUT_760]) }; __ret } } else { aiur_fn_760(__args, record, io_buffer, __cu)? } }; let __v_49: G = __r_arr[0]; let __v_50: G = G::from_u64(1); let __v_51: G = { let __a_val = __v_49.as_canonical_u64(); let __b_val = __v_50.as_canonical_u64(); let __a_u32 = u32::try_from(__a_val).ok().ok_or(ExecError::U32OutOfRange(__a_val))?; let __b_u32 = u32::try_from(__b_val).ok().ok_or(ExecError::U32OutOfRange(__b_val))?; let __result = G::from_bool(__a_u32 < __b_u32); if !unconstrained { let __x_bytes = __a_u32.to_le_bytes(); let __z_bytes = __b_u32.to_le_bytes(); let __c_u32 = __b_u32.wrapping_sub(__a_u32).wrapping_sub(1); let __y_bytes = __c_u32.to_le_bytes(); record.bytes2_queries.bump_range_check(&G::from_u8(__x_bytes[0]), &G::from_u8(__x_bytes[1])); record.bytes2_queries.bump_range_check(&G::from_u8(__x_bytes[2]), &G::from_u8(__x_bytes[3])); record.bytes2_queries.bump_range_check(&G::from_u8(__y_bytes[0]), &G::from_u8(__y_bytes[1])); record.bytes2_queries.bump_range_check(&G::from_u8(__y_bytes[2]), &G::from_u8(__y_bytes[3])); record.bytes2_queries.bump_range_check(&G::from_u8(__z_bytes[0]), &G::from_u8(__z_bytes[1])); record.bytes2_queries.bump_range_check(&G::from_u8(__z_bytes[2]), &G::from_u8(__z_bytes[3])); } __result }; @@ -45965,16 +45681,16 @@ fn aiur_fn_526( let __v_54: G = G::from_u64(0); let __v_55: G = G::from_u64(0); let __v_56: G = { let __values: [G; 4] = [__v_53, __v_54, __v_55, __v_55]; let __mq = record.memory_queries.get_mut(&4).ok_or(ExecError::InvalidMemorySize(4))?; if let Some(result) = __mq.get_mut(&__values[..]) { if !unconstrained { *result.multiplicity += G::ONE; } result.output[0] } else { let __ptr = G::from_usize(__mq.len()); __mq.insert(&__values[..], &[__ptr], G::from_bool(!unconstrained)); __ptr } }; - let __ret: [G; OUT_526] = [__v_52, __v_56]; - if let Some(result) = record.function_queries[526].get_mut(&inp[..]) { debug_assert_eq!(result.output, &__ret[..]); if !unconstrained { *result.multiplicity += G::ONE; } } else { record.function_queries[526].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained)); }; + let __ret: [G; OUT_522] = [__v_52, __v_56]; + if let Some(result) = record.function_queries[522].get_mut(&inp[..]) { debug_assert_eq!(result.output, &__ret[..]); if !unconstrained { *result.multiplicity += G::ONE; } } else { record.function_queries[522].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained)); }; return Ok(__ret); }, _ => { let __v_52: G = G::from_u64(0); - let __r_arr: [G; OUT_766] = { let __args: [G; IN_766] = [__v_48, __v_52]; let __cu = unconstrained; if let Some(result) = record.function_queries[766].get_mut(&__args[..]) { if !__cu && *result.multiplicity == G::ZERO { aiur_fn_766(__args, record, io_buffer, false)? } else { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_766] = unsafe { *(result.output.as_ptr() as *const [G; OUT_766]) }; __ret } } else { aiur_fn_766(__args, record, io_buffer, __cu)? } }; + let __r_arr: [G; OUT_762] = { let __args: [G; IN_762] = [__v_48, __v_52]; let __cu = unconstrained; if let Some(result) = record.function_queries[762].get_mut(&__args[..]) { if !__cu && *result.multiplicity == G::ZERO { aiur_fn_762(__args, record, io_buffer, false)? } else { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_762] = unsafe { *(result.output.as_ptr() as *const [G; OUT_762]) }; __ret } } else { aiur_fn_762(__args, record, io_buffer, __cu)? } }; let __v_53: G = __r_arr[0]; let __v_54: G = G::from_u64(2); - let __r_arr: [G; OUT_504] = { let __args: [G; IN_504] = []; let __cu = unconstrained; if let Some(result) = record.function_queries[504].get_mut(&__args[..]) { if !__cu && *result.multiplicity == G::ZERO { aiur_fn_504(__args, record, io_buffer, false)? } else { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_504] = unsafe { *(result.output.as_ptr() as *const [G; OUT_504]) }; __ret } } else { aiur_fn_504(__args, record, io_buffer, __cu)? } }; + let __r_arr: [G; OUT_500] = { let __args: [G; IN_500] = []; let __cu = unconstrained; if let Some(result) = record.function_queries[500].get_mut(&__args[..]) { if !__cu && *result.multiplicity == G::ZERO { aiur_fn_500(__args, record, io_buffer, false)? } else { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_500] = unsafe { *(result.output.as_ptr() as *const [G; OUT_500]) }; __ret } } else { aiur_fn_500(__args, record, io_buffer, __cu)? } }; let __v_55: G = __r_arr[0]; let __v_56: G = G::from_u64(1); let __v_57: G = G::from_u64(1); @@ -45988,28 +45704,28 @@ fn aiur_fn_526( let __v_65: G = G::from_u64(0); let __v_66: G = { let __values: [G; 4] = [__v_64, __v_63, __v_35, __v_65]; let __mq = record.memory_queries.get_mut(&4).ok_or(ExecError::InvalidMemorySize(4))?; if let Some(result) = __mq.get_mut(&__values[..]) { if !unconstrained { *result.multiplicity += G::ONE; } result.output[0] } else { let __ptr = G::from_usize(__mq.len()); __mq.insert(&__values[..], &[__ptr], G::from_bool(!unconstrained)); __ptr } }; let __v_67: G = G::from_u64(2); - let __r_arr: [G; OUT_775] = { let __args: [G; IN_775] = [__v_2, __v_67]; let __cu = unconstrained; if let Some(result) = record.function_queries[775].get_mut(&__args[..]) { if !__cu && *result.multiplicity == G::ZERO { aiur_fn_775(__args, record, io_buffer, false)? } else { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_775] = unsafe { *(result.output.as_ptr() as *const [G; OUT_775]) }; __ret } } else { aiur_fn_775(__args, record, io_buffer, __cu)? } }; + let __r_arr: [G; OUT_771] = { let __args: [G; IN_771] = [__v_2, __v_67]; let __cu = unconstrained; if let Some(result) = record.function_queries[771].get_mut(&__args[..]) { if !__cu && *result.multiplicity == G::ZERO { aiur_fn_771(__args, record, io_buffer, false)? } else { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_771] = unsafe { *(result.output.as_ptr() as *const [G; OUT_771]) }; __ret } } else { aiur_fn_771(__args, record, io_buffer, __cu)? } }; let __v_68: G = __r_arr[0]; let __v_69: G = G::from_u64(1); - let __r_arr: [G; OUT_255] = { let __args: [G; IN_255] = [__v_66, __v_68]; let __cu = unconstrained; if let Some(result) = record.function_queries[255].get_mut(&__args[..]) { if !__cu && *result.multiplicity == G::ZERO { aiur_fn_255(__args, record, io_buffer, false)? } else { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_255] = unsafe { *(result.output.as_ptr() as *const [G; OUT_255]) }; __ret } } else { aiur_fn_255(__args, record, io_buffer, __cu)? } }; + let __r_arr: [G; OUT_251] = { let __args: [G; IN_251] = [__v_66, __v_68]; let __cu = unconstrained; if let Some(result) = record.function_queries[251].get_mut(&__args[..]) { if !__cu && *result.multiplicity == G::ZERO { aiur_fn_251(__args, record, io_buffer, false)? } else { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_251] = unsafe { *(result.output.as_ptr() as *const [G; OUT_251]) }; __ret } } else { aiur_fn_251(__args, record, io_buffer, __cu)? } }; let __v_70: G = __r_arr[0]; - let __ret: [G; OUT_526] = [__v_69, __v_70]; - if let Some(result) = record.function_queries[526].get_mut(&inp[..]) { debug_assert_eq!(result.output, &__ret[..]); if !unconstrained { *result.multiplicity += G::ONE; } } else { record.function_queries[526].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained)); }; + let __ret: [G; OUT_522] = [__v_69, __v_70]; + if let Some(result) = record.function_queries[522].get_mut(&inp[..]) { debug_assert_eq!(result.output, &__ret[..]); if !unconstrained { *result.multiplicity += G::ONE; } } else { record.function_queries[522].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained)); }; return Ok(__ret); }, } }) } -const INPUT_SIZE_527: usize = 6; -const IN_527: usize = 6; -const OUT_527: usize = 2; -fn aiur_fn_527( - inp: [G; IN_527], +const INPUT_SIZE_523: usize = 6; +const IN_523: usize = 6; +const OUT_523: usize = 2; +fn aiur_fn_523( + inp: [G; IN_523], record: &mut QueryRecord, io_buffer: &mut IOBuffer, unconstrained: bool, -) -> Result<[G; OUT_527], ExecError> { +) -> Result<[G; OUT_523], ExecError> { stacker::maybe_grow(64 * 1024, 4 * 1024 * 1024, || { let __v_0: G = inp[0]; let __v_1: G = inp[1]; @@ -46019,12 +45735,12 @@ fn aiur_fn_527( let __v_5: G = inp[5]; let __mc_out___mc_0: [G; 1] = '__mc_0: { match __v_0.as_canonical_u64() { 1u64 => { - let __r_arr: [G; OUT_504] = { let __args: [G; IN_504] = []; let __cu = unconstrained; if let Some(result) = record.function_queries[504].get_mut(&__args[..]) { if !__cu && *result.multiplicity == G::ZERO { aiur_fn_504(__args, record, io_buffer, false)? } else { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_504] = unsafe { *(result.output.as_ptr() as *const [G; OUT_504]) }; __ret } } else { aiur_fn_504(__args, record, io_buffer, __cu)? } }; + let __r_arr: [G; OUT_500] = { let __args: [G; IN_500] = []; let __cu = unconstrained; if let Some(result) = record.function_queries[500].get_mut(&__args[..]) { if !__cu && *result.multiplicity == G::ZERO { aiur_fn_500(__args, record, io_buffer, false)? } else { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_500] = unsafe { *(result.output.as_ptr() as *const [G; OUT_500]) }; __ret } } else { aiur_fn_500(__args, record, io_buffer, __cu)? } }; let __v_6: G = __r_arr[0]; break '__mc_0 [__v_6]; }, _ => { - let __r_arr: [G; OUT_505] = { let __args: [G; IN_505] = []; let __cu = unconstrained; if let Some(result) = record.function_queries[505].get_mut(&__args[..]) { if !__cu && *result.multiplicity == G::ZERO { aiur_fn_505(__args, record, io_buffer, false)? } else { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_505] = unsafe { *(result.output.as_ptr() as *const [G; OUT_505]) }; __ret } } else { aiur_fn_505(__args, record, io_buffer, __cu)? } }; + let __r_arr: [G; OUT_501] = { let __args: [G; IN_501] = []; let __cu = unconstrained; if let Some(result) = record.function_queries[501].get_mut(&__args[..]) { if !__cu && *result.multiplicity == G::ZERO { aiur_fn_501(__args, record, io_buffer, false)? } else { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_501] = unsafe { *(result.output.as_ptr() as *const [G; OUT_501]) }; __ret } } else { aiur_fn_501(__args, record, io_buffer, __cu)? } }; let __v_6: G = __r_arr[0]; break '__mc_0 [__v_6]; }, @@ -46035,18 +45751,18 @@ fn aiur_fn_527( let __v_8: G = G::from_u64(0); let __v_9: G = { let __values: [G; 4] = [__v_7, __v_2, __v_3, __v_8]; let __mq = record.memory_queries.get_mut(&4).ok_or(ExecError::InvalidMemorySize(4))?; if let Some(result) = __mq.get_mut(&__values[..]) { if !unconstrained { *result.multiplicity += G::ONE; } result.output[0] } else { let __ptr = G::from_usize(__mq.len()); __mq.insert(&__values[..], &[__ptr], G::from_bool(!unconstrained)); __ptr } }; let __v_10: G = G::from_u64(2); - let __r_arr: [G; OUT_774] = { let __args: [G; IN_774] = [__v_4, __v_10]; let __cu = unconstrained; if let Some(result) = record.function_queries[774].get_mut(&__args[..]) { if !__cu && *result.multiplicity == G::ZERO { aiur_fn_774(__args, record, io_buffer, false)? } else { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_774] = unsafe { *(result.output.as_ptr() as *const [G; OUT_774]) }; __ret } } else { aiur_fn_774(__args, record, io_buffer, __cu)? } }; + let __r_arr: [G; OUT_770] = { let __args: [G; IN_770] = [__v_4, __v_10]; let __cu = unconstrained; if let Some(result) = record.function_queries[770].get_mut(&__args[..]) { if !__cu && *result.multiplicity == G::ZERO { aiur_fn_770(__args, record, io_buffer, false)? } else { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_770] = unsafe { *(result.output.as_ptr() as *const [G; OUT_770]) }; __ret } } else { aiur_fn_770(__args, record, io_buffer, __cu)? } }; let __v_11: G = __r_arr[0]; - let __r_arr: [G; OUT_255] = { let __args: [G; IN_255] = [__v_9, __v_11]; let __cu = unconstrained; if let Some(result) = record.function_queries[255].get_mut(&__args[..]) { if !__cu && *result.multiplicity == G::ZERO { aiur_fn_255(__args, record, io_buffer, false)? } else { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_255] = unsafe { *(result.output.as_ptr() as *const [G; OUT_255]) }; __ret } } else { aiur_fn_255(__args, record, io_buffer, __cu)? } }; + let __r_arr: [G; OUT_251] = { let __args: [G; IN_251] = [__v_9, __v_11]; let __cu = unconstrained; if let Some(result) = record.function_queries[251].get_mut(&__args[..]) { if !__cu && *result.multiplicity == G::ZERO { aiur_fn_251(__args, record, io_buffer, false)? } else { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_251] = unsafe { *(result.output.as_ptr() as *const [G; OUT_251]) }; __ret } } else { aiur_fn_251(__args, record, io_buffer, __cu)? } }; let __v_12: G = __r_arr[0]; - let __r_arr: [G; OUT_488] = { let __args: [G; IN_488] = [__v_12, __v_5]; let __cu = unconstrained; if let Some(result) = record.function_queries[488].get_mut(&__args[..]) { if !__cu && *result.multiplicity == G::ZERO { aiur_fn_488(__args, record, io_buffer, false)? } else { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_488] = unsafe { *(result.output.as_ptr() as *const [G; OUT_488]) }; __ret } } else { aiur_fn_488(__args, record, io_buffer, __cu)? } }; + let __r_arr: [G; OUT_484] = { let __args: [G; IN_484] = [__v_12, __v_5]; let __cu = unconstrained; if let Some(result) = record.function_queries[484].get_mut(&__args[..]) { if !__cu && *result.multiplicity == G::ZERO { aiur_fn_484(__args, record, io_buffer, false)? } else { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_484] = unsafe { *(result.output.as_ptr() as *const [G; OUT_484]) }; __ret } } else { aiur_fn_484(__args, record, io_buffer, __cu)? } }; let __v_13: G = __r_arr[0]; - let __r_arr: [G; OUT_418] = { let __args: [G; IN_418] = [__v_13, __v_5]; let __cu = unconstrained; if let Some(result) = record.function_queries[418].get_mut(&__args[..]) { if !__cu && *result.multiplicity == G::ZERO { aiur_fn_418(__args, record, io_buffer, false)? } else { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_418] = unsafe { *(result.output.as_ptr() as *const [G; OUT_418]) }; __ret } } else { aiur_fn_418(__args, record, io_buffer, __cu)? } }; + let __r_arr: [G; OUT_414] = { let __args: [G; IN_414] = [__v_13, __v_5]; let __cu = unconstrained; if let Some(result) = record.function_queries[414].get_mut(&__args[..]) { if !__cu && *result.multiplicity == G::ZERO { aiur_fn_414(__args, record, io_buffer, false)? } else { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_414] = unsafe { *(result.output.as_ptr() as *const [G; OUT_414]) }; __ret } } else { aiur_fn_414(__args, record, io_buffer, __cu)? } }; let __v_14: G = __r_arr[0]; let __r_arr: [G; OUT_111] = { let __args: [G; IN_111] = [__v_14]; let __cu = unconstrained; if let Some(result) = record.function_queries[111].get_mut(&__args[..]) { if !__cu && *result.multiplicity == G::ZERO { aiur_fn_111(__args, record, io_buffer, false)? } else { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_111] = unsafe { *(result.output.as_ptr() as *const [G; OUT_111]) }; __ret } } else { aiur_fn_111(__args, record, io_buffer, __cu)? } }; let __v_15: G = __r_arr[0]; let __v_16: G = __r_arr[1]; - let __r_arr: [G; OUT_764] = { let __args: [G; IN_764] = [__v_16]; let __cu = unconstrained; if let Some(result) = record.function_queries[764].get_mut(&__args[..]) { if !__cu && *result.multiplicity == G::ZERO { aiur_fn_764(__args, record, io_buffer, false)? } else { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_764] = unsafe { *(result.output.as_ptr() as *const [G; OUT_764]) }; __ret } } else { aiur_fn_764(__args, record, io_buffer, __cu)? } }; + let __r_arr: [G; OUT_760] = { let __args: [G; IN_760] = [__v_16]; let __cu = unconstrained; if let Some(result) = record.function_queries[760].get_mut(&__args[..]) { if !__cu && *result.multiplicity == G::ZERO { aiur_fn_760(__args, record, io_buffer, false)? } else { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_760] = unsafe { *(result.output.as_ptr() as *const [G; OUT_760]) }; __ret } } else { aiur_fn_760(__args, record, io_buffer, __cu)? } }; let __v_17: G = __r_arr[0]; let __v_18: G = G::from_u64(1); let __v_19: G = { let __a_val = __v_17.as_canonical_u64(); let __b_val = __v_18.as_canonical_u64(); let __a_u32 = u32::try_from(__a_val).ok().ok_or(ExecError::U32OutOfRange(__a_val))?; let __b_u32 = u32::try_from(__b_val).ok().ok_or(ExecError::U32OutOfRange(__b_val))?; let __result = G::from_bool(__a_u32 < __b_u32); if !unconstrained { let __x_bytes = __a_u32.to_le_bytes(); let __z_bytes = __b_u32.to_le_bytes(); let __c_u32 = __b_u32.wrapping_sub(__a_u32).wrapping_sub(1); let __y_bytes = __c_u32.to_le_bytes(); record.bytes2_queries.bump_range_check(&G::from_u8(__x_bytes[0]), &G::from_u8(__x_bytes[1])); record.bytes2_queries.bump_range_check(&G::from_u8(__x_bytes[2]), &G::from_u8(__x_bytes[3])); record.bytes2_queries.bump_range_check(&G::from_u8(__y_bytes[0]), &G::from_u8(__y_bytes[1])); record.bytes2_queries.bump_range_check(&G::from_u8(__y_bytes[2]), &G::from_u8(__y_bytes[3])); record.bytes2_queries.bump_range_check(&G::from_u8(__z_bytes[0]), &G::from_u8(__z_bytes[1])); record.bytes2_queries.bump_range_check(&G::from_u8(__z_bytes[2]), &G::from_u8(__z_bytes[3])); } __result }; @@ -46057,13 +45773,13 @@ fn aiur_fn_527( let __v_22: G = G::from_u64(0); let __v_23: G = G::from_u64(0); let __v_24: G = { let __values: [G; 4] = [__v_21, __v_22, __v_23, __v_23]; let __mq = record.memory_queries.get_mut(&4).ok_or(ExecError::InvalidMemorySize(4))?; if let Some(result) = __mq.get_mut(&__values[..]) { if !unconstrained { *result.multiplicity += G::ONE; } result.output[0] } else { let __ptr = G::from_usize(__mq.len()); __mq.insert(&__values[..], &[__ptr], G::from_bool(!unconstrained)); __ptr } }; - let __ret: [G; OUT_527] = [__v_20, __v_24]; - if let Some(result) = record.function_queries[527].get_mut(&inp[..]) { debug_assert_eq!(result.output, &__ret[..]); if !unconstrained { *result.multiplicity += G::ONE; } } else { record.function_queries[527].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained)); }; + let __ret: [G; OUT_523] = [__v_20, __v_24]; + if let Some(result) = record.function_queries[523].get_mut(&inp[..]) { debug_assert_eq!(result.output, &__ret[..]); if !unconstrained { *result.multiplicity += G::ONE; } } else { record.function_queries[523].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained)); }; return Ok(__ret); }, _ => { let __v_20: G = G::from_u64(0); - let __r_arr: [G; OUT_766] = { let __args: [G; IN_766] = [__v_16, __v_20]; let __cu = unconstrained; if let Some(result) = record.function_queries[766].get_mut(&__args[..]) { if !__cu && *result.multiplicity == G::ZERO { aiur_fn_766(__args, record, io_buffer, false)? } else { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_766] = unsafe { *(result.output.as_ptr() as *const [G; OUT_766]) }; __ret } } else { aiur_fn_766(__args, record, io_buffer, __cu)? } }; + let __r_arr: [G; OUT_762] = { let __args: [G; IN_762] = [__v_16, __v_20]; let __cu = unconstrained; if let Some(result) = record.function_queries[762].get_mut(&__args[..]) { if !__cu && *result.multiplicity == G::ZERO { aiur_fn_762(__args, record, io_buffer, false)? } else { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_762] = unsafe { *(result.output.as_ptr() as *const [G; OUT_762]) }; __ret } } else { aiur_fn_762(__args, record, io_buffer, __cu)? } }; let __v_21: G = __r_arr[0]; let __v_22: G = G::from_u64(2); let __v_23: G = G::from_u64(1); @@ -46078,28 +45794,28 @@ fn aiur_fn_527( let __v_32: G = G::from_u64(0); let __v_33: G = { let __values: [G; 4] = [__v_31, __v_30, __v_1, __v_32]; let __mq = record.memory_queries.get_mut(&4).ok_or(ExecError::InvalidMemorySize(4))?; if let Some(result) = __mq.get_mut(&__values[..]) { if !unconstrained { *result.multiplicity += G::ONE; } result.output[0] } else { let __ptr = G::from_usize(__mq.len()); __mq.insert(&__values[..], &[__ptr], G::from_bool(!unconstrained)); __ptr } }; let __v_34: G = G::from_u64(2); - let __r_arr: [G; OUT_775] = { let __args: [G; IN_775] = [__v_4, __v_34]; let __cu = unconstrained; if let Some(result) = record.function_queries[775].get_mut(&__args[..]) { if !__cu && *result.multiplicity == G::ZERO { aiur_fn_775(__args, record, io_buffer, false)? } else { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_775] = unsafe { *(result.output.as_ptr() as *const [G; OUT_775]) }; __ret } } else { aiur_fn_775(__args, record, io_buffer, __cu)? } }; + let __r_arr: [G; OUT_771] = { let __args: [G; IN_771] = [__v_4, __v_34]; let __cu = unconstrained; if let Some(result) = record.function_queries[771].get_mut(&__args[..]) { if !__cu && *result.multiplicity == G::ZERO { aiur_fn_771(__args, record, io_buffer, false)? } else { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_771] = unsafe { *(result.output.as_ptr() as *const [G; OUT_771]) }; __ret } } else { aiur_fn_771(__args, record, io_buffer, __cu)? } }; let __v_35: G = __r_arr[0]; let __v_36: G = G::from_u64(1); - let __r_arr: [G; OUT_255] = { let __args: [G; IN_255] = [__v_33, __v_35]; let __cu = unconstrained; if let Some(result) = record.function_queries[255].get_mut(&__args[..]) { if !__cu && *result.multiplicity == G::ZERO { aiur_fn_255(__args, record, io_buffer, false)? } else { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_255] = unsafe { *(result.output.as_ptr() as *const [G; OUT_255]) }; __ret } } else { aiur_fn_255(__args, record, io_buffer, __cu)? } }; + let __r_arr: [G; OUT_251] = { let __args: [G; IN_251] = [__v_33, __v_35]; let __cu = unconstrained; if let Some(result) = record.function_queries[251].get_mut(&__args[..]) { if !__cu && *result.multiplicity == G::ZERO { aiur_fn_251(__args, record, io_buffer, false)? } else { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_251] = unsafe { *(result.output.as_ptr() as *const [G; OUT_251]) }; __ret } } else { aiur_fn_251(__args, record, io_buffer, __cu)? } }; let __v_37: G = __r_arr[0]; - let __ret: [G; OUT_527] = [__v_36, __v_37]; - if let Some(result) = record.function_queries[527].get_mut(&inp[..]) { debug_assert_eq!(result.output, &__ret[..]); if !unconstrained { *result.multiplicity += G::ONE; } } else { record.function_queries[527].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained)); }; + let __ret: [G; OUT_523] = [__v_36, __v_37]; + if let Some(result) = record.function_queries[523].get_mut(&inp[..]) { debug_assert_eq!(result.output, &__ret[..]); if !unconstrained { *result.multiplicity += G::ONE; } } else { record.function_queries[523].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained)); }; return Ok(__ret); }, } }) } -const INPUT_SIZE_528: usize = 2; -const IN_528: usize = 2; -const OUT_528: usize = 1; -fn aiur_fn_528( - inp: [G; IN_528], +const INPUT_SIZE_524: usize = 2; +const IN_524: usize = 2; +const OUT_524: usize = 1; +fn aiur_fn_524( + inp: [G; IN_524], record: &mut QueryRecord, io_buffer: &mut IOBuffer, unconstrained: bool, -) -> Result<[G; OUT_528], ExecError> { +) -> Result<[G; OUT_524], ExecError> { stacker::maybe_grow(64 * 1024, 4 * 1024 * 1024, || { let __v_0: G = inp[0]; let __v_1: G = inp[1]; @@ -46107,8 +45823,8 @@ fn aiur_fn_528( match __v_2.as_canonical_u64() { 0u64 => { let __v_3: G = G::from_u64(1); - let __ret: [G; OUT_528] = [__v_3]; - if let Some(result) = record.function_queries[528].get_mut(&inp[..]) { debug_assert_eq!(result.output, &__ret[..]); if !unconstrained { *result.multiplicity += G::ONE; } } else { record.function_queries[528].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained)); }; + let __ret: [G; OUT_524] = [__v_3]; + if let Some(result) = record.function_queries[524].get_mut(&inp[..]) { debug_assert_eq!(result.output, &__ret[..]); if !unconstrained { *result.multiplicity += G::ONE; } } else { record.function_queries[524].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained)); }; return Ok(__ret); }, _ => { @@ -46116,14 +45832,14 @@ fn aiur_fn_528( match __v_3.as_canonical_u64() { 1u64 => { let __v_4: G = G::from_u64(0); - let __ret: [G; OUT_528] = [__v_4]; - if let Some(result) = record.function_queries[528].get_mut(&inp[..]) { debug_assert_eq!(result.output, &__ret[..]); if !unconstrained { *result.multiplicity += G::ONE; } } else { record.function_queries[528].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained)); }; + let __ret: [G; OUT_524] = [__v_4]; + if let Some(result) = record.function_queries[524].get_mut(&inp[..]) { debug_assert_eq!(result.output, &__ret[..]); if !unconstrained { *result.multiplicity += G::ONE; } } else { record.function_queries[524].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained)); }; return Ok(__ret); }, 0u64 => { let __v_4: G = G::from_u64(2); - let __ret: [G; OUT_528] = [__v_4]; - if let Some(result) = record.function_queries[528].get_mut(&inp[..]) { debug_assert_eq!(result.output, &__ret[..]); if !unconstrained { *result.multiplicity += G::ONE; } } else { record.function_queries[528].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained)); }; + let __ret: [G; OUT_524] = [__v_4]; + if let Some(result) = record.function_queries[524].get_mut(&inp[..]) { debug_assert_eq!(result.output, &__ret[..]); if !unconstrained { *result.multiplicity += G::ONE; } } else { record.function_queries[524].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained)); }; return Ok(__ret); }, _ => { @@ -46135,96 +45851,96 @@ fn aiur_fn_528( }) } -const INPUT_SIZE_529: usize = 2; -const IN_529: usize = 2; -const OUT_529: usize = 1; -fn aiur_fn_529( - inp: [G; IN_529], +const INPUT_SIZE_525: usize = 2; +const IN_525: usize = 2; +const OUT_525: usize = 1; +fn aiur_fn_525( + inp: [G; IN_525], record: &mut QueryRecord, io_buffer: &mut IOBuffer, unconstrained: bool, -) -> Result<[G; OUT_529], ExecError> { +) -> Result<[G; OUT_525], ExecError> { stacker::maybe_grow(64 * 1024, 4 * 1024 * 1024, || { let __v_0: G = inp[0]; let __v_1: G = inp[1]; match __v_0.as_canonical_u64() { 1u64 => { - let __ret: [G; OUT_529] = [__v_1]; - if let Some(result) = record.function_queries[529].get_mut(&inp[..]) { debug_assert_eq!(result.output, &__ret[..]); if !unconstrained { *result.multiplicity += G::ONE; } } else { record.function_queries[529].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained)); }; + let __ret: [G; OUT_525] = [__v_1]; + if let Some(result) = record.function_queries[525].get_mut(&inp[..]) { debug_assert_eq!(result.output, &__ret[..]); if !unconstrained { *result.multiplicity += G::ONE; } } else { record.function_queries[525].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained)); }; return Ok(__ret); }, _ => { - let __ret: [G; OUT_529] = [__v_0]; - if let Some(result) = record.function_queries[529].get_mut(&inp[..]) { debug_assert_eq!(result.output, &__ret[..]); if !unconstrained { *result.multiplicity += G::ONE; } } else { record.function_queries[529].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained)); }; + let __ret: [G; OUT_525] = [__v_0]; + if let Some(result) = record.function_queries[525].get_mut(&inp[..]) { debug_assert_eq!(result.output, &__ret[..]); if !unconstrained { *result.multiplicity += G::ONE; } } else { record.function_queries[525].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained)); }; return Ok(__ret); }, } }) } -const INPUT_SIZE_530: usize = 0; -const IN_530: usize = 0; -const OUT_530: usize = 2; -fn aiur_fn_530( - inp: [G; IN_530], +const INPUT_SIZE_526: usize = 0; +const IN_526: usize = 0; +const OUT_526: usize = 2; +fn aiur_fn_526( + inp: [G; IN_526], record: &mut QueryRecord, io_buffer: &mut IOBuffer, unconstrained: bool, -) -> Result<[G; OUT_530], ExecError> { +) -> Result<[G; OUT_526], ExecError> { stacker::maybe_grow(64 * 1024, 4 * 1024 * 1024, || { let __v_0: G = G::from_u64(0); let __v_1: G = G::from_u64(1); - let __ret: [G; OUT_530] = [__v_0, __v_1]; - if let Some(result) = record.function_queries[530].get_mut(&inp[..]) { debug_assert_eq!(result.output, &__ret[..]); if !unconstrained { *result.multiplicity += G::ONE; } } else { record.function_queries[530].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained)); }; + let __ret: [G; OUT_526] = [__v_0, __v_1]; + if let Some(result) = record.function_queries[526].get_mut(&inp[..]) { debug_assert_eq!(result.output, &__ret[..]); if !unconstrained { *result.multiplicity += G::ONE; } } else { record.function_queries[526].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained)); }; return Ok(__ret); }) } -const INPUT_SIZE_531: usize = 0; -const IN_531: usize = 0; -const OUT_531: usize = 2; -fn aiur_fn_531( - inp: [G; IN_531], +const INPUT_SIZE_527: usize = 0; +const IN_527: usize = 0; +const OUT_527: usize = 2; +fn aiur_fn_527( + inp: [G; IN_527], record: &mut QueryRecord, io_buffer: &mut IOBuffer, unconstrained: bool, -) -> Result<[G; OUT_531], ExecError> { +) -> Result<[G; OUT_527], ExecError> { stacker::maybe_grow(64 * 1024, 4 * 1024 * 1024, || { let __v_0: G = G::from_u64(1); let __v_1: G = G::from_u64(1); - let __ret: [G; OUT_531] = [__v_0, __v_1]; - if let Some(result) = record.function_queries[531].get_mut(&inp[..]) { debug_assert_eq!(result.output, &__ret[..]); if !unconstrained { *result.multiplicity += G::ONE; } } else { record.function_queries[531].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained)); }; + let __ret: [G; OUT_527] = [__v_0, __v_1]; + if let Some(result) = record.function_queries[527].get_mut(&inp[..]) { debug_assert_eq!(result.output, &__ret[..]); if !unconstrained { *result.multiplicity += G::ONE; } } else { record.function_queries[527].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained)); }; return Ok(__ret); }) } -const INPUT_SIZE_532: usize = 0; -const IN_532: usize = 0; -const OUT_532: usize = 2; -fn aiur_fn_532( - inp: [G; IN_532], +const INPUT_SIZE_528: usize = 0; +const IN_528: usize = 0; +const OUT_528: usize = 2; +fn aiur_fn_528( + inp: [G; IN_528], record: &mut QueryRecord, io_buffer: &mut IOBuffer, unconstrained: bool, -) -> Result<[G; OUT_532], ExecError> { +) -> Result<[G; OUT_528], ExecError> { stacker::maybe_grow(64 * 1024, 4 * 1024 * 1024, || { let __v_0: G = G::from_u64(2); let __v_1: G = G::from_u64(1); - let __ret: [G; OUT_532] = [__v_0, __v_1]; - if let Some(result) = record.function_queries[532].get_mut(&inp[..]) { debug_assert_eq!(result.output, &__ret[..]); if !unconstrained { *result.multiplicity += G::ONE; } } else { record.function_queries[532].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained)); }; + let __ret: [G; OUT_528] = [__v_0, __v_1]; + if let Some(result) = record.function_queries[528].get_mut(&inp[..]) { debug_assert_eq!(result.output, &__ret[..]); if !unconstrained { *result.multiplicity += G::ONE; } } else { record.function_queries[528].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained)); }; return Ok(__ret); }) } -const INPUT_SIZE_533: usize = 4; -const IN_533: usize = 4; -const OUT_533: usize = 2; -fn aiur_fn_533( - inp: [G; IN_533], +const INPUT_SIZE_529: usize = 4; +const IN_529: usize = 4; +const OUT_529: usize = 2; +fn aiur_fn_529( + inp: [G; IN_529], record: &mut QueryRecord, io_buffer: &mut IOBuffer, unconstrained: bool, -) -> Result<[G; OUT_533], ExecError> { +) -> Result<[G; OUT_529], ExecError> { stacker::maybe_grow(64 * 1024, 4 * 1024 * 1024, || { let __v_0: G = inp[0]; let __v_1: G = inp[1]; @@ -46233,46 +45949,46 @@ fn aiur_fn_533( match __v_0.as_canonical_u64() { 1u64 => { let __v_4: G = (__v_1 * __v_3); - let __ret: [G; OUT_533] = [__v_2, __v_4]; - if let Some(result) = record.function_queries[533].get_mut(&inp[..]) { debug_assert_eq!(result.output, &__ret[..]); if !unconstrained { *result.multiplicity += G::ONE; } } else { record.function_queries[533].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained)); }; + let __ret: [G; OUT_529] = [__v_2, __v_4]; + if let Some(result) = record.function_queries[529].get_mut(&inp[..]) { debug_assert_eq!(result.output, &__ret[..]); if !unconstrained { *result.multiplicity += G::ONE; } } else { record.function_queries[529].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained)); }; return Ok(__ret); }, _ => { - let __ret: [G; OUT_533] = [__v_0, __v_1]; - if let Some(result) = record.function_queries[533].get_mut(&inp[..]) { debug_assert_eq!(result.output, &__ret[..]); if !unconstrained { *result.multiplicity += G::ONE; } } else { record.function_queries[533].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained)); }; + let __ret: [G; OUT_529] = [__v_0, __v_1]; + if let Some(result) = record.function_queries[529].get_mut(&inp[..]) { debug_assert_eq!(result.output, &__ret[..]); if !unconstrained { *result.multiplicity += G::ONE; } } else { record.function_queries[529].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained)); }; return Ok(__ret); }, } }) } -const INPUT_SIZE_534: usize = 1; -const IN_534: usize = 1; -const OUT_534: usize = 2; -fn aiur_fn_534( - inp: [G; IN_534], +const INPUT_SIZE_530: usize = 1; +const IN_530: usize = 1; +const OUT_530: usize = 2; +fn aiur_fn_530( + inp: [G; IN_530], record: &mut QueryRecord, io_buffer: &mut IOBuffer, unconstrained: bool, -) -> Result<[G; OUT_534], ExecError> { +) -> Result<[G; OUT_530], ExecError> { stacker::maybe_grow(64 * 1024, 4 * 1024 * 1024, || { let __v_0: G = inp[0]; let __v_1: G = G::from_u64(1); - let __ret: [G; OUT_534] = [__v_0, __v_1]; - if let Some(result) = record.function_queries[534].get_mut(&inp[..]) { debug_assert_eq!(result.output, &__ret[..]); if !unconstrained { *result.multiplicity += G::ONE; } } else { record.function_queries[534].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained)); }; + let __ret: [G; OUT_530] = [__v_0, __v_1]; + if let Some(result) = record.function_queries[530].get_mut(&inp[..]) { debug_assert_eq!(result.output, &__ret[..]); if !unconstrained { *result.multiplicity += G::ONE; } } else { record.function_queries[530].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained)); }; return Ok(__ret); }) } -const INPUT_SIZE_535: usize = 2; -const IN_535: usize = 2; -const OUT_535: usize = 1; -fn aiur_fn_535( - inp: [G; IN_535], +const INPUT_SIZE_531: usize = 2; +const IN_531: usize = 2; +const OUT_531: usize = 1; +fn aiur_fn_531( + inp: [G; IN_531], record: &mut QueryRecord, io_buffer: &mut IOBuffer, unconstrained: bool, -) -> Result<[G; OUT_535], ExecError> { +) -> Result<[G; OUT_531], ExecError> { stacker::maybe_grow(64 * 1024, 4 * 1024 * 1024, || { let __v_0: G = inp[0]; let __v_1: G = inp[1]; @@ -46342,51 +46058,51 @@ fn aiur_fn_535( let __v_63: G = __loaded[29]; let __v_64: G = __loaded[30]; let __v_65: G = __loaded[31]; - let __r_arr: [G; OUT_536] = { let __args: [G; IN_536] = [__v_2, __v_3, __v_4, __v_5, __v_34, __v_35, __v_36, __v_37]; let __cu = unconstrained; if let Some(result) = record.function_queries[536].get_mut(&__args[..]) { if !__cu && *result.multiplicity == G::ZERO { aiur_fn_536(__args, record, io_buffer, false)? } else { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_536] = unsafe { *(result.output.as_ptr() as *const [G; OUT_536]) }; __ret } } else { aiur_fn_536(__args, record, io_buffer, __cu)? } }; + let __r_arr: [G; OUT_532] = { let __args: [G; IN_532] = [__v_2, __v_3, __v_4, __v_5, __v_34, __v_35, __v_36, __v_37]; let __cu = unconstrained; if let Some(result) = record.function_queries[532].get_mut(&__args[..]) { if !__cu && *result.multiplicity == G::ZERO { aiur_fn_532(__args, record, io_buffer, false)? } else { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_532] = unsafe { *(result.output.as_ptr() as *const [G; OUT_532]) }; __ret } } else { aiur_fn_532(__args, record, io_buffer, __cu)? } }; let __v_66: G = __r_arr[0]; - let __r_arr: [G; OUT_536] = { let __args: [G; IN_536] = [__v_6, __v_7, __v_8, __v_9, __v_38, __v_39, __v_40, __v_41]; let __cu = unconstrained; if let Some(result) = record.function_queries[536].get_mut(&__args[..]) { if !__cu && *result.multiplicity == G::ZERO { aiur_fn_536(__args, record, io_buffer, false)? } else { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_536] = unsafe { *(result.output.as_ptr() as *const [G; OUT_536]) }; __ret } } else { aiur_fn_536(__args, record, io_buffer, __cu)? } }; + let __r_arr: [G; OUT_532] = { let __args: [G; IN_532] = [__v_6, __v_7, __v_8, __v_9, __v_38, __v_39, __v_40, __v_41]; let __cu = unconstrained; if let Some(result) = record.function_queries[532].get_mut(&__args[..]) { if !__cu && *result.multiplicity == G::ZERO { aiur_fn_532(__args, record, io_buffer, false)? } else { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_532] = unsafe { *(result.output.as_ptr() as *const [G; OUT_532]) }; __ret } } else { aiur_fn_532(__args, record, io_buffer, __cu)? } }; let __v_67: G = __r_arr[0]; - let __r_arr: [G; OUT_536] = { let __args: [G; IN_536] = [__v_10, __v_11, __v_12, __v_13, __v_42, __v_43, __v_44, __v_45]; let __cu = unconstrained; if let Some(result) = record.function_queries[536].get_mut(&__args[..]) { if !__cu && *result.multiplicity == G::ZERO { aiur_fn_536(__args, record, io_buffer, false)? } else { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_536] = unsafe { *(result.output.as_ptr() as *const [G; OUT_536]) }; __ret } } else { aiur_fn_536(__args, record, io_buffer, __cu)? } }; + let __r_arr: [G; OUT_532] = { let __args: [G; IN_532] = [__v_10, __v_11, __v_12, __v_13, __v_42, __v_43, __v_44, __v_45]; let __cu = unconstrained; if let Some(result) = record.function_queries[532].get_mut(&__args[..]) { if !__cu && *result.multiplicity == G::ZERO { aiur_fn_532(__args, record, io_buffer, false)? } else { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_532] = unsafe { *(result.output.as_ptr() as *const [G; OUT_532]) }; __ret } } else { aiur_fn_532(__args, record, io_buffer, __cu)? } }; let __v_68: G = __r_arr[0]; - let __r_arr: [G; OUT_536] = { let __args: [G; IN_536] = [__v_14, __v_15, __v_16, __v_17, __v_46, __v_47, __v_48, __v_49]; let __cu = unconstrained; if let Some(result) = record.function_queries[536].get_mut(&__args[..]) { if !__cu && *result.multiplicity == G::ZERO { aiur_fn_536(__args, record, io_buffer, false)? } else { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_536] = unsafe { *(result.output.as_ptr() as *const [G; OUT_536]) }; __ret } } else { aiur_fn_536(__args, record, io_buffer, __cu)? } }; + let __r_arr: [G; OUT_532] = { let __args: [G; IN_532] = [__v_14, __v_15, __v_16, __v_17, __v_46, __v_47, __v_48, __v_49]; let __cu = unconstrained; if let Some(result) = record.function_queries[532].get_mut(&__args[..]) { if !__cu && *result.multiplicity == G::ZERO { aiur_fn_532(__args, record, io_buffer, false)? } else { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_532] = unsafe { *(result.output.as_ptr() as *const [G; OUT_532]) }; __ret } } else { aiur_fn_532(__args, record, io_buffer, __cu)? } }; let __v_69: G = __r_arr[0]; - let __r_arr: [G; OUT_536] = { let __args: [G; IN_536] = [__v_18, __v_19, __v_20, __v_21, __v_50, __v_51, __v_52, __v_53]; let __cu = unconstrained; if let Some(result) = record.function_queries[536].get_mut(&__args[..]) { if !__cu && *result.multiplicity == G::ZERO { aiur_fn_536(__args, record, io_buffer, false)? } else { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_536] = unsafe { *(result.output.as_ptr() as *const [G; OUT_536]) }; __ret } } else { aiur_fn_536(__args, record, io_buffer, __cu)? } }; + let __r_arr: [G; OUT_532] = { let __args: [G; IN_532] = [__v_18, __v_19, __v_20, __v_21, __v_50, __v_51, __v_52, __v_53]; let __cu = unconstrained; if let Some(result) = record.function_queries[532].get_mut(&__args[..]) { if !__cu && *result.multiplicity == G::ZERO { aiur_fn_532(__args, record, io_buffer, false)? } else { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_532] = unsafe { *(result.output.as_ptr() as *const [G; OUT_532]) }; __ret } } else { aiur_fn_532(__args, record, io_buffer, __cu)? } }; let __v_70: G = __r_arr[0]; - let __r_arr: [G; OUT_536] = { let __args: [G; IN_536] = [__v_22, __v_23, __v_24, __v_25, __v_54, __v_55, __v_56, __v_57]; let __cu = unconstrained; if let Some(result) = record.function_queries[536].get_mut(&__args[..]) { if !__cu && *result.multiplicity == G::ZERO { aiur_fn_536(__args, record, io_buffer, false)? } else { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_536] = unsafe { *(result.output.as_ptr() as *const [G; OUT_536]) }; __ret } } else { aiur_fn_536(__args, record, io_buffer, __cu)? } }; + let __r_arr: [G; OUT_532] = { let __args: [G; IN_532] = [__v_22, __v_23, __v_24, __v_25, __v_54, __v_55, __v_56, __v_57]; let __cu = unconstrained; if let Some(result) = record.function_queries[532].get_mut(&__args[..]) { if !__cu && *result.multiplicity == G::ZERO { aiur_fn_532(__args, record, io_buffer, false)? } else { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_532] = unsafe { *(result.output.as_ptr() as *const [G; OUT_532]) }; __ret } } else { aiur_fn_532(__args, record, io_buffer, __cu)? } }; let __v_71: G = __r_arr[0]; - let __r_arr: [G; OUT_536] = { let __args: [G; IN_536] = [__v_26, __v_27, __v_28, __v_29, __v_58, __v_59, __v_60, __v_61]; let __cu = unconstrained; if let Some(result) = record.function_queries[536].get_mut(&__args[..]) { if !__cu && *result.multiplicity == G::ZERO { aiur_fn_536(__args, record, io_buffer, false)? } else { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_536] = unsafe { *(result.output.as_ptr() as *const [G; OUT_536]) }; __ret } } else { aiur_fn_536(__args, record, io_buffer, __cu)? } }; + let __r_arr: [G; OUT_532] = { let __args: [G; IN_532] = [__v_26, __v_27, __v_28, __v_29, __v_58, __v_59, __v_60, __v_61]; let __cu = unconstrained; if let Some(result) = record.function_queries[532].get_mut(&__args[..]) { if !__cu && *result.multiplicity == G::ZERO { aiur_fn_532(__args, record, io_buffer, false)? } else { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_532] = unsafe { *(result.output.as_ptr() as *const [G; OUT_532]) }; __ret } } else { aiur_fn_532(__args, record, io_buffer, __cu)? } }; let __v_72: G = __r_arr[0]; - let __r_arr: [G; OUT_536] = { let __args: [G; IN_536] = [__v_30, __v_31, __v_32, __v_33, __v_62, __v_63, __v_64, __v_65]; let __cu = unconstrained; if let Some(result) = record.function_queries[536].get_mut(&__args[..]) { if !__cu && *result.multiplicity == G::ZERO { aiur_fn_536(__args, record, io_buffer, false)? } else { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_536] = unsafe { *(result.output.as_ptr() as *const [G; OUT_536]) }; __ret } } else { aiur_fn_536(__args, record, io_buffer, __cu)? } }; + let __r_arr: [G; OUT_532] = { let __args: [G; IN_532] = [__v_30, __v_31, __v_32, __v_33, __v_62, __v_63, __v_64, __v_65]; let __cu = unconstrained; if let Some(result) = record.function_queries[532].get_mut(&__args[..]) { if !__cu && *result.multiplicity == G::ZERO { aiur_fn_532(__args, record, io_buffer, false)? } else { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_532] = unsafe { *(result.output.as_ptr() as *const [G; OUT_532]) }; __ret } } else { aiur_fn_532(__args, record, io_buffer, __cu)? } }; let __v_73: G = __r_arr[0]; - let __r_arr: [G; OUT_529] = { let __args: [G; IN_529] = [__v_72, __v_73]; let __cu = unconstrained; if let Some(result) = record.function_queries[529].get_mut(&__args[..]) { if !__cu && *result.multiplicity == G::ZERO { aiur_fn_529(__args, record, io_buffer, false)? } else { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_529] = unsafe { *(result.output.as_ptr() as *const [G; OUT_529]) }; __ret } } else { aiur_fn_529(__args, record, io_buffer, __cu)? } }; + let __r_arr: [G; OUT_525] = { let __args: [G; IN_525] = [__v_72, __v_73]; let __cu = unconstrained; if let Some(result) = record.function_queries[525].get_mut(&__args[..]) { if !__cu && *result.multiplicity == G::ZERO { aiur_fn_525(__args, record, io_buffer, false)? } else { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_525] = unsafe { *(result.output.as_ptr() as *const [G; OUT_525]) }; __ret } } else { aiur_fn_525(__args, record, io_buffer, __cu)? } }; let __v_74: G = __r_arr[0]; - let __r_arr: [G; OUT_529] = { let __args: [G; IN_529] = [__v_71, __v_74]; let __cu = unconstrained; if let Some(result) = record.function_queries[529].get_mut(&__args[..]) { if !__cu && *result.multiplicity == G::ZERO { aiur_fn_529(__args, record, io_buffer, false)? } else { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_529] = unsafe { *(result.output.as_ptr() as *const [G; OUT_529]) }; __ret } } else { aiur_fn_529(__args, record, io_buffer, __cu)? } }; + let __r_arr: [G; OUT_525] = { let __args: [G; IN_525] = [__v_71, __v_74]; let __cu = unconstrained; if let Some(result) = record.function_queries[525].get_mut(&__args[..]) { if !__cu && *result.multiplicity == G::ZERO { aiur_fn_525(__args, record, io_buffer, false)? } else { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_525] = unsafe { *(result.output.as_ptr() as *const [G; OUT_525]) }; __ret } } else { aiur_fn_525(__args, record, io_buffer, __cu)? } }; let __v_75: G = __r_arr[0]; - let __r_arr: [G; OUT_529] = { let __args: [G; IN_529] = [__v_70, __v_75]; let __cu = unconstrained; if let Some(result) = record.function_queries[529].get_mut(&__args[..]) { if !__cu && *result.multiplicity == G::ZERO { aiur_fn_529(__args, record, io_buffer, false)? } else { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_529] = unsafe { *(result.output.as_ptr() as *const [G; OUT_529]) }; __ret } } else { aiur_fn_529(__args, record, io_buffer, __cu)? } }; + let __r_arr: [G; OUT_525] = { let __args: [G; IN_525] = [__v_70, __v_75]; let __cu = unconstrained; if let Some(result) = record.function_queries[525].get_mut(&__args[..]) { if !__cu && *result.multiplicity == G::ZERO { aiur_fn_525(__args, record, io_buffer, false)? } else { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_525] = unsafe { *(result.output.as_ptr() as *const [G; OUT_525]) }; __ret } } else { aiur_fn_525(__args, record, io_buffer, __cu)? } }; let __v_76: G = __r_arr[0]; - let __r_arr: [G; OUT_529] = { let __args: [G; IN_529] = [__v_69, __v_76]; let __cu = unconstrained; if let Some(result) = record.function_queries[529].get_mut(&__args[..]) { if !__cu && *result.multiplicity == G::ZERO { aiur_fn_529(__args, record, io_buffer, false)? } else { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_529] = unsafe { *(result.output.as_ptr() as *const [G; OUT_529]) }; __ret } } else { aiur_fn_529(__args, record, io_buffer, __cu)? } }; + let __r_arr: [G; OUT_525] = { let __args: [G; IN_525] = [__v_69, __v_76]; let __cu = unconstrained; if let Some(result) = record.function_queries[525].get_mut(&__args[..]) { if !__cu && *result.multiplicity == G::ZERO { aiur_fn_525(__args, record, io_buffer, false)? } else { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_525] = unsafe { *(result.output.as_ptr() as *const [G; OUT_525]) }; __ret } } else { aiur_fn_525(__args, record, io_buffer, __cu)? } }; let __v_77: G = __r_arr[0]; - let __r_arr: [G; OUT_529] = { let __args: [G; IN_529] = [__v_68, __v_77]; let __cu = unconstrained; if let Some(result) = record.function_queries[529].get_mut(&__args[..]) { if !__cu && *result.multiplicity == G::ZERO { aiur_fn_529(__args, record, io_buffer, false)? } else { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_529] = unsafe { *(result.output.as_ptr() as *const [G; OUT_529]) }; __ret } } else { aiur_fn_529(__args, record, io_buffer, __cu)? } }; + let __r_arr: [G; OUT_525] = { let __args: [G; IN_525] = [__v_68, __v_77]; let __cu = unconstrained; if let Some(result) = record.function_queries[525].get_mut(&__args[..]) { if !__cu && *result.multiplicity == G::ZERO { aiur_fn_525(__args, record, io_buffer, false)? } else { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_525] = unsafe { *(result.output.as_ptr() as *const [G; OUT_525]) }; __ret } } else { aiur_fn_525(__args, record, io_buffer, __cu)? } }; let __v_78: G = __r_arr[0]; - let __r_arr: [G; OUT_529] = { let __args: [G; IN_529] = [__v_67, __v_78]; let __cu = unconstrained; if let Some(result) = record.function_queries[529].get_mut(&__args[..]) { if !__cu && *result.multiplicity == G::ZERO { aiur_fn_529(__args, record, io_buffer, false)? } else { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_529] = unsafe { *(result.output.as_ptr() as *const [G; OUT_529]) }; __ret } } else { aiur_fn_529(__args, record, io_buffer, __cu)? } }; + let __r_arr: [G; OUT_525] = { let __args: [G; IN_525] = [__v_67, __v_78]; let __cu = unconstrained; if let Some(result) = record.function_queries[525].get_mut(&__args[..]) { if !__cu && *result.multiplicity == G::ZERO { aiur_fn_525(__args, record, io_buffer, false)? } else { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_525] = unsafe { *(result.output.as_ptr() as *const [G; OUT_525]) }; __ret } } else { aiur_fn_525(__args, record, io_buffer, __cu)? } }; let __v_79: G = __r_arr[0]; - let __r_arr: [G; OUT_529] = { let __args: [G; IN_529] = [__v_66, __v_79]; let __cu = unconstrained; if let Some(result) = record.function_queries[529].get_mut(&__args[..]) { if !__cu && *result.multiplicity == G::ZERO { aiur_fn_529(__args, record, io_buffer, false)? } else { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_529] = unsafe { *(result.output.as_ptr() as *const [G; OUT_529]) }; __ret } } else { aiur_fn_529(__args, record, io_buffer, __cu)? } }; + let __r_arr: [G; OUT_525] = { let __args: [G; IN_525] = [__v_66, __v_79]; let __cu = unconstrained; if let Some(result) = record.function_queries[525].get_mut(&__args[..]) { if !__cu && *result.multiplicity == G::ZERO { aiur_fn_525(__args, record, io_buffer, false)? } else { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_525] = unsafe { *(result.output.as_ptr() as *const [G; OUT_525]) }; __ret } } else { aiur_fn_525(__args, record, io_buffer, __cu)? } }; let __v_80: G = __r_arr[0]; - let __ret: [G; OUT_535] = [__v_80]; - if let Some(result) = record.function_queries[535].get_mut(&inp[..]) { debug_assert_eq!(result.output, &__ret[..]); if !unconstrained { *result.multiplicity += G::ONE; } } else { record.function_queries[535].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained)); }; + let __ret: [G; OUT_531] = [__v_80]; + if let Some(result) = record.function_queries[531].get_mut(&inp[..]) { debug_assert_eq!(result.output, &__ret[..]); if !unconstrained { *result.multiplicity += G::ONE; } } else { record.function_queries[531].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained)); }; return Ok(__ret); }) } -const INPUT_SIZE_536: usize = 8; -const IN_536: usize = 8; -const OUT_536: usize = 1; -fn aiur_fn_536( - inp: [G; IN_536], +const INPUT_SIZE_532: usize = 8; +const IN_532: usize = 8; +const OUT_532: usize = 1; +fn aiur_fn_532( + inp: [G; IN_532], record: &mut QueryRecord, io_buffer: &mut IOBuffer, unconstrained: bool, -) -> Result<[G; OUT_536], ExecError> { +) -> Result<[G; OUT_532], ExecError> { stacker::maybe_grow(64 * 1024, 4 * 1024 * 1024, || { let __v_0: G = inp[0]; let __v_1: G = inp[1]; @@ -46414,23 +46130,23 @@ fn aiur_fn_536( let __v_23: G = (__v_22 + __v_7); let __v_24: G = (__v_20 + __v_23); let __v_25: G = (__v_18 + __v_24); - let __r_arr: [G; OUT_528] = { let __args: [G; IN_528] = [__v_16, __v_25]; let __cu = unconstrained; if let Some(result) = record.function_queries[528].get_mut(&__args[..]) { if !__cu && *result.multiplicity == G::ZERO { aiur_fn_528(__args, record, io_buffer, false)? } else { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_528] = unsafe { *(result.output.as_ptr() as *const [G; OUT_528]) }; __ret } } else { aiur_fn_528(__args, record, io_buffer, __cu)? } }; + let __r_arr: [G; OUT_524] = { let __args: [G; IN_524] = [__v_16, __v_25]; let __cu = unconstrained; if let Some(result) = record.function_queries[524].get_mut(&__args[..]) { if !__cu && *result.multiplicity == G::ZERO { aiur_fn_524(__args, record, io_buffer, false)? } else { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_524] = unsafe { *(result.output.as_ptr() as *const [G; OUT_524]) }; __ret } } else { aiur_fn_524(__args, record, io_buffer, __cu)? } }; let __v_26: G = __r_arr[0]; - let __ret: [G; OUT_536] = [__v_26]; - if let Some(result) = record.function_queries[536].get_mut(&inp[..]) { debug_assert_eq!(result.output, &__ret[..]); if !unconstrained { *result.multiplicity += G::ONE; } } else { record.function_queries[536].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained)); }; + let __ret: [G; OUT_532] = [__v_26]; + if let Some(result) = record.function_queries[532].get_mut(&inp[..]) { debug_assert_eq!(result.output, &__ret[..]); if !unconstrained { *result.multiplicity += G::ONE; } } else { record.function_queries[532].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained)); }; return Ok(__ret); }) } -const INPUT_SIZE_537: usize = 2; -const IN_537: usize = 2; -const OUT_537: usize = 1; -fn aiur_fn_537( - inp: [G; IN_537], +const INPUT_SIZE_533: usize = 2; +const IN_533: usize = 2; +const OUT_533: usize = 1; +fn aiur_fn_533( + inp: [G; IN_533], record: &mut QueryRecord, io_buffer: &mut IOBuffer, unconstrained: bool, -) -> Result<[G; OUT_537], ExecError> { +) -> Result<[G; OUT_533], ExecError> { stacker::maybe_grow(64 * 1024, 4 * 1024 * 1024, || { let __v_0: G = inp[0]; let __v_1: G = inp[1]; @@ -46442,8 +46158,8 @@ fn aiur_fn_537( match __v_2.as_canonical_u64() { 1u64 => { let __v_6: G = G::from_u64(0); - let __ret: [G; OUT_537] = [__v_6]; - if let Some(result) = record.function_queries[537].get_mut(&inp[..]) { debug_assert_eq!(result.output, &__ret[..]); if !unconstrained { *result.multiplicity += G::ONE; } } else { record.function_queries[537].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained)); }; + let __ret: [G; OUT_533] = [__v_6]; + if let Some(result) = record.function_queries[533].get_mut(&inp[..]) { debug_assert_eq!(result.output, &__ret[..]); if !unconstrained { *result.multiplicity += G::ONE; } } else { record.function_queries[533].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained)); }; return Ok(__ret); }, 0u64 => { @@ -46453,15 +46169,15 @@ fn aiur_fn_537( 1u64 => { let __v_7: G = G::from_u64(1); let __v_8: G = (__v_7 + __v_4); - let __ret: [G; OUT_537] = [__v_8]; - if let Some(result) = record.function_queries[537].get_mut(&inp[..]) { debug_assert_eq!(result.output, &__ret[..]); if !unconstrained { *result.multiplicity += G::ONE; } } else { record.function_queries[537].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained)); }; + let __ret: [G; OUT_533] = [__v_8]; + if let Some(result) = record.function_queries[533].get_mut(&inp[..]) { debug_assert_eq!(result.output, &__ret[..]); if !unconstrained { *result.multiplicity += G::ONE; } } else { record.function_queries[533].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained)); }; return Ok(__ret); }, _ => { - let __r_arr: [G; OUT_537] = { let __args: [G; IN_537] = [__v_0, __v_5]; let __cu = unconstrained; if let Some(result) = record.function_queries[537].get_mut(&__args[..]) { if !__cu && *result.multiplicity == G::ZERO { aiur_fn_537(__args, record, io_buffer, false)? } else { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_537] = unsafe { *(result.output.as_ptr() as *const [G; OUT_537]) }; __ret } } else { aiur_fn_537(__args, record, io_buffer, __cu)? } }; + let __r_arr: [G; OUT_533] = { let __args: [G; IN_533] = [__v_0, __v_5]; let __cu = unconstrained; if let Some(result) = record.function_queries[533].get_mut(&__args[..]) { if !__cu && *result.multiplicity == G::ZERO { aiur_fn_533(__args, record, io_buffer, false)? } else { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_533] = unsafe { *(result.output.as_ptr() as *const [G; OUT_533]) }; __ret } } else { aiur_fn_533(__args, record, io_buffer, __cu)? } }; let __v_7: G = __r_arr[0]; - let __ret: [G; OUT_537] = [__v_7]; - if let Some(result) = record.function_queries[537].get_mut(&inp[..]) { debug_assert_eq!(result.output, &__ret[..]); if !unconstrained { *result.multiplicity += G::ONE; } } else { record.function_queries[537].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained)); }; + let __ret: [G; OUT_533] = [__v_7]; + if let Some(result) = record.function_queries[533].get_mut(&inp[..]) { debug_assert_eq!(result.output, &__ret[..]); if !unconstrained { *result.multiplicity += G::ONE; } } else { record.function_queries[533].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained)); }; return Ok(__ret); }, } @@ -46473,15 +46189,15 @@ fn aiur_fn_537( }) } -const INPUT_SIZE_538: usize = 3; -const IN_538: usize = 3; -const OUT_538: usize = 2; -fn aiur_fn_538( - inp: [G; IN_538], +const INPUT_SIZE_534: usize = 3; +const IN_534: usize = 3; +const OUT_534: usize = 2; +fn aiur_fn_534( + inp: [G; IN_534], record: &mut QueryRecord, io_buffer: &mut IOBuffer, unconstrained: bool, -) -> Result<[G; OUT_538], ExecError> { +) -> Result<[G; OUT_534], ExecError> { stacker::maybe_grow(64 * 1024, 4 * 1024 * 1024, || { let __v_0: G = inp[0]; let __v_1: G = inp[1]; @@ -46490,37 +46206,37 @@ fn aiur_fn_538( let __v_3: G = __r_arr[0]; match __v_3.as_canonical_u64() { 1u64 => { - let __r_arr: [G; OUT_531] = { let __args: [G; IN_531] = []; let __cu = unconstrained; if let Some(result) = record.function_queries[531].get_mut(&__args[..]) { if !__cu && *result.multiplicity == G::ZERO { aiur_fn_531(__args, record, io_buffer, false)? } else { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_531] = unsafe { *(result.output.as_ptr() as *const [G; OUT_531]) }; __ret } } else { aiur_fn_531(__args, record, io_buffer, __cu)? } }; + let __r_arr: [G; OUT_527] = { let __args: [G; IN_527] = []; let __cu = unconstrained; if let Some(result) = record.function_queries[527].get_mut(&__args[..]) { if !__cu && *result.multiplicity == G::ZERO { aiur_fn_527(__args, record, io_buffer, false)? } else { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_527] = unsafe { *(result.output.as_ptr() as *const [G; OUT_527]) }; __ret } } else { aiur_fn_527(__args, record, io_buffer, __cu)? } }; let __v_4: G = __r_arr[0]; let __v_5: G = __r_arr[1]; - let __ret: [G; OUT_538] = [__v_4, __v_5]; - if let Some(result) = record.function_queries[538].get_mut(&inp[..]) { debug_assert_eq!(result.output, &__ret[..]); if !unconstrained { *result.multiplicity += G::ONE; } } else { record.function_queries[538].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained)); }; + let __ret: [G; OUT_534] = [__v_4, __v_5]; + if let Some(result) = record.function_queries[534].get_mut(&inp[..]) { debug_assert_eq!(result.output, &__ret[..]); if !unconstrained { *result.multiplicity += G::ONE; } } else { record.function_queries[534].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained)); }; return Ok(__ret); }, _ => { - let __r_arr: [G; OUT_537] = { let __args: [G; IN_537] = [__v_0, __v_2]; let __cu = unconstrained; if let Some(result) = record.function_queries[537].get_mut(&__args[..]) { if !__cu && *result.multiplicity == G::ZERO { aiur_fn_537(__args, record, io_buffer, false)? } else { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_537] = unsafe { *(result.output.as_ptr() as *const [G; OUT_537]) }; __ret } } else { aiur_fn_537(__args, record, io_buffer, __cu)? } }; + let __r_arr: [G; OUT_533] = { let __args: [G; IN_533] = [__v_0, __v_2]; let __cu = unconstrained; if let Some(result) = record.function_queries[533].get_mut(&__args[..]) { if !__cu && *result.multiplicity == G::ZERO { aiur_fn_533(__args, record, io_buffer, false)? } else { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_533] = unsafe { *(result.output.as_ptr() as *const [G; OUT_533]) }; __ret } } else { aiur_fn_533(__args, record, io_buffer, __cu)? } }; let __v_4: G = __r_arr[0]; - let __r_arr: [G; OUT_537] = { let __args: [G; IN_537] = [__v_1, __v_2]; let __cu = unconstrained; if let Some(result) = record.function_queries[537].get_mut(&__args[..]) { if !__cu && *result.multiplicity == G::ZERO { aiur_fn_537(__args, record, io_buffer, false)? } else { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_537] = unsafe { *(result.output.as_ptr() as *const [G; OUT_537]) }; __ret } } else { aiur_fn_537(__args, record, io_buffer, __cu)? } }; + let __r_arr: [G; OUT_533] = { let __args: [G; IN_533] = [__v_1, __v_2]; let __cu = unconstrained; if let Some(result) = record.function_queries[533].get_mut(&__args[..]) { if !__cu && *result.multiplicity == G::ZERO { aiur_fn_533(__args, record, io_buffer, false)? } else { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_533] = unsafe { *(result.output.as_ptr() as *const [G; OUT_533]) }; __ret } } else { aiur_fn_533(__args, record, io_buffer, __cu)? } }; let __v_5: G = __r_arr[0]; match __v_4.as_canonical_u64() { 0u64 => { match __v_5.as_canonical_u64() { 0u64 => { - let __r_arr: [G; OUT_535] = { let __args: [G; IN_535] = [__v_0, __v_1]; let __cu = unconstrained; if let Some(result) = record.function_queries[535].get_mut(&__args[..]) { if !__cu && *result.multiplicity == G::ZERO { aiur_fn_535(__args, record, io_buffer, false)? } else { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_535] = unsafe { *(result.output.as_ptr() as *const [G; OUT_535]) }; __ret } } else { aiur_fn_535(__args, record, io_buffer, __cu)? } }; + let __r_arr: [G; OUT_531] = { let __args: [G; IN_531] = [__v_0, __v_1]; let __cu = unconstrained; if let Some(result) = record.function_queries[531].get_mut(&__args[..]) { if !__cu && *result.multiplicity == G::ZERO { aiur_fn_531(__args, record, io_buffer, false)? } else { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_531] = unsafe { *(result.output.as_ptr() as *const [G; OUT_531]) }; __ret } } else { aiur_fn_531(__args, record, io_buffer, __cu)? } }; let __v_6: G = __r_arr[0]; - let __r_arr: [G; OUT_534] = { let __args: [G; IN_534] = [__v_6]; let __cu = unconstrained; if let Some(result) = record.function_queries[534].get_mut(&__args[..]) { if !__cu && *result.multiplicity == G::ZERO { aiur_fn_534(__args, record, io_buffer, false)? } else { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_534] = unsafe { *(result.output.as_ptr() as *const [G; OUT_534]) }; __ret } } else { aiur_fn_534(__args, record, io_buffer, __cu)? } }; + let __r_arr: [G; OUT_530] = { let __args: [G; IN_530] = [__v_6]; let __cu = unconstrained; if let Some(result) = record.function_queries[530].get_mut(&__args[..]) { if !__cu && *result.multiplicity == G::ZERO { aiur_fn_530(__args, record, io_buffer, false)? } else { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_530] = unsafe { *(result.output.as_ptr() as *const [G; OUT_530]) }; __ret } } else { aiur_fn_530(__args, record, io_buffer, __cu)? } }; let __v_7: G = __r_arr[0]; let __v_8: G = __r_arr[1]; - let __ret: [G; OUT_538] = [__v_7, __v_8]; - if let Some(result) = record.function_queries[538].get_mut(&inp[..]) { debug_assert_eq!(result.output, &__ret[..]); if !unconstrained { *result.multiplicity += G::ONE; } } else { record.function_queries[538].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained)); }; + let __ret: [G; OUT_534] = [__v_7, __v_8]; + if let Some(result) = record.function_queries[534].get_mut(&inp[..]) { debug_assert_eq!(result.output, &__ret[..]); if !unconstrained { *result.multiplicity += G::ONE; } } else { record.function_queries[534].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained)); }; return Ok(__ret); }, _ => { - let __r_arr: [G; OUT_532] = { let __args: [G; IN_532] = []; let __cu = unconstrained; if let Some(result) = record.function_queries[532].get_mut(&__args[..]) { if !__cu && *result.multiplicity == G::ZERO { aiur_fn_532(__args, record, io_buffer, false)? } else { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_532] = unsafe { *(result.output.as_ptr() as *const [G; OUT_532]) }; __ret } } else { aiur_fn_532(__args, record, io_buffer, __cu)? } }; + let __r_arr: [G; OUT_528] = { let __args: [G; IN_528] = []; let __cu = unconstrained; if let Some(result) = record.function_queries[528].get_mut(&__args[..]) { if !__cu && *result.multiplicity == G::ZERO { aiur_fn_528(__args, record, io_buffer, false)? } else { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_528] = unsafe { *(result.output.as_ptr() as *const [G; OUT_528]) }; __ret } } else { aiur_fn_528(__args, record, io_buffer, __cu)? } }; let __v_6: G = __r_arr[0]; let __v_7: G = __r_arr[1]; - let __ret: [G; OUT_538] = [__v_6, __v_7]; - if let Some(result) = record.function_queries[538].get_mut(&inp[..]) { debug_assert_eq!(result.output, &__ret[..]); if !unconstrained { *result.multiplicity += G::ONE; } } else { record.function_queries[538].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained)); }; + let __ret: [G; OUT_534] = [__v_6, __v_7]; + if let Some(result) = record.function_queries[534].get_mut(&inp[..]) { debug_assert_eq!(result.output, &__ret[..]); if !unconstrained { *result.multiplicity += G::ONE; } } else { record.function_queries[534].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained)); }; return Ok(__ret); }, } @@ -46528,19 +46244,19 @@ fn aiur_fn_538( _ => { match __v_5.as_canonical_u64() { 0u64 => { - let __r_arr: [G; OUT_530] = { let __args: [G; IN_530] = []; let __cu = unconstrained; if let Some(result) = record.function_queries[530].get_mut(&__args[..]) { if !__cu && *result.multiplicity == G::ZERO { aiur_fn_530(__args, record, io_buffer, false)? } else { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_530] = unsafe { *(result.output.as_ptr() as *const [G; OUT_530]) }; __ret } } else { aiur_fn_530(__args, record, io_buffer, __cu)? } }; + let __r_arr: [G; OUT_526] = { let __args: [G; IN_526] = []; let __cu = unconstrained; if let Some(result) = record.function_queries[526].get_mut(&__args[..]) { if !__cu && *result.multiplicity == G::ZERO { aiur_fn_526(__args, record, io_buffer, false)? } else { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_526] = unsafe { *(result.output.as_ptr() as *const [G; OUT_526]) }; __ret } } else { aiur_fn_526(__args, record, io_buffer, __cu)? } }; let __v_6: G = __r_arr[0]; let __v_7: G = __r_arr[1]; - let __ret: [G; OUT_538] = [__v_6, __v_7]; - if let Some(result) = record.function_queries[538].get_mut(&inp[..]) { debug_assert_eq!(result.output, &__ret[..]); if !unconstrained { *result.multiplicity += G::ONE; } } else { record.function_queries[538].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained)); }; + let __ret: [G; OUT_534] = [__v_6, __v_7]; + if let Some(result) = record.function_queries[534].get_mut(&inp[..]) { debug_assert_eq!(result.output, &__ret[..]); if !unconstrained { *result.multiplicity += G::ONE; } } else { record.function_queries[534].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained)); }; return Ok(__ret); }, _ => { - let __r_arr: [G; OUT_528] = { let __args: [G; IN_528] = [__v_4, __v_5]; let __cu = unconstrained; if let Some(result) = record.function_queries[528].get_mut(&__args[..]) { if !__cu && *result.multiplicity == G::ZERO { aiur_fn_528(__args, record, io_buffer, false)? } else { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_528] = unsafe { *(result.output.as_ptr() as *const [G; OUT_528]) }; __ret } } else { aiur_fn_528(__args, record, io_buffer, __cu)? } }; + let __r_arr: [G; OUT_524] = { let __args: [G; IN_524] = [__v_4, __v_5]; let __cu = unconstrained; if let Some(result) = record.function_queries[524].get_mut(&__args[..]) { if !__cu && *result.multiplicity == G::ZERO { aiur_fn_524(__args, record, io_buffer, false)? } else { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_524] = unsafe { *(result.output.as_ptr() as *const [G; OUT_524]) }; __ret } } else { aiur_fn_524(__args, record, io_buffer, __cu)? } }; let __v_6: G = __r_arr[0]; let __v_7: G = G::from_u64(0); - let __ret: [G; OUT_538] = [__v_6, __v_7]; - if let Some(result) = record.function_queries[538].get_mut(&inp[..]) { debug_assert_eq!(result.output, &__ret[..]); if !unconstrained { *result.multiplicity += G::ONE; } } else { record.function_queries[538].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained)); }; + let __ret: [G; OUT_534] = [__v_6, __v_7]; + if let Some(result) = record.function_queries[534].get_mut(&inp[..]) { debug_assert_eq!(result.output, &__ret[..]); if !unconstrained { *result.multiplicity += G::ONE; } } else { record.function_queries[534].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained)); }; return Ok(__ret); }, } @@ -46551,15 +46267,15 @@ fn aiur_fn_538( }) } -const INPUT_SIZE_539: usize = 2; -const IN_539: usize = 2; -const OUT_539: usize = 1; -fn aiur_fn_539( - inp: [G; IN_539], +const INPUT_SIZE_535: usize = 2; +const IN_535: usize = 2; +const OUT_535: usize = 1; +fn aiur_fn_535( + inp: [G; IN_535], record: &mut QueryRecord, io_buffer: &mut IOBuffer, unconstrained: bool, -) -> Result<[G; OUT_539], ExecError> { +) -> Result<[G; OUT_535], ExecError> { stacker::maybe_grow(64 * 1024, 4 * 1024 * 1024, || { let __v_0: G = inp[0]; let __v_1: G = inp[1]; @@ -46576,14 +46292,14 @@ fn aiur_fn_539( match __v_5.as_canonical_u64() { 0u64 => { let __v_8: G = G::from_u64(1); - let __ret: [G; OUT_539] = [__v_8]; - if let Some(result) = record.function_queries[539].get_mut(&inp[..]) { debug_assert_eq!(result.output, &__ret[..]); if !unconstrained { *result.multiplicity += G::ONE; } } else { record.function_queries[539].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained)); }; + let __ret: [G; OUT_535] = [__v_8]; + if let Some(result) = record.function_queries[535].get_mut(&inp[..]) { debug_assert_eq!(result.output, &__ret[..]); if !unconstrained { *result.multiplicity += G::ONE; } } else { record.function_queries[535].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained)); }; return Ok(__ret); }, _ => { let __v_8: G = G::from_u64(0); - let __ret: [G; OUT_539] = [__v_8]; - if let Some(result) = record.function_queries[539].get_mut(&inp[..]) { debug_assert_eq!(result.output, &__ret[..]); if !unconstrained { *result.multiplicity += G::ONE; } } else { record.function_queries[539].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained)); }; + let __ret: [G; OUT_535] = [__v_8]; + if let Some(result) = record.function_queries[535].get_mut(&inp[..]) { debug_assert_eq!(result.output, &__ret[..]); if !unconstrained { *result.multiplicity += G::ONE; } } else { record.function_queries[535].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained)); }; return Ok(__ret); }, } @@ -46596,21 +46312,21 @@ fn aiur_fn_539( match __v_5.as_canonical_u64() { 0u64 => { let __v_8: G = G::from_u64(2); - let __ret: [G; OUT_539] = [__v_8]; - if let Some(result) = record.function_queries[539].get_mut(&inp[..]) { debug_assert_eq!(result.output, &__ret[..]); if !unconstrained { *result.multiplicity += G::ONE; } } else { record.function_queries[539].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained)); }; + let __ret: [G; OUT_535] = [__v_8]; + if let Some(result) = record.function_queries[535].get_mut(&inp[..]) { debug_assert_eq!(result.output, &__ret[..]); if !unconstrained { *result.multiplicity += G::ONE; } } else { record.function_queries[535].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained)); }; return Ok(__ret); }, 1u64 => { - let __r_arr: [G; OUT_539] = { let __args: [G; IN_539] = [__v_3, __v_6]; let __cu = unconstrained; if let Some(result) = record.function_queries[539].get_mut(&__args[..]) { if !__cu && *result.multiplicity == G::ZERO { aiur_fn_539(__args, record, io_buffer, false)? } else { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_539] = unsafe { *(result.output.as_ptr() as *const [G; OUT_539]) }; __ret } } else { aiur_fn_539(__args, record, io_buffer, __cu)? } }; + let __r_arr: [G; OUT_535] = { let __args: [G; IN_535] = [__v_3, __v_6]; let __cu = unconstrained; if let Some(result) = record.function_queries[535].get_mut(&__args[..]) { if !__cu && *result.multiplicity == G::ZERO { aiur_fn_535(__args, record, io_buffer, false)? } else { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_535] = unsafe { *(result.output.as_ptr() as *const [G; OUT_535]) }; __ret } } else { aiur_fn_535(__args, record, io_buffer, __cu)? } }; let __v_8: G = __r_arr[0]; - let __ret: [G; OUT_539] = [__v_8]; - if let Some(result) = record.function_queries[539].get_mut(&inp[..]) { debug_assert_eq!(result.output, &__ret[..]); if !unconstrained { *result.multiplicity += G::ONE; } } else { record.function_queries[539].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained)); }; + let __ret: [G; OUT_535] = [__v_8]; + if let Some(result) = record.function_queries[535].get_mut(&inp[..]) { debug_assert_eq!(result.output, &__ret[..]); if !unconstrained { *result.multiplicity += G::ONE; } } else { record.function_queries[535].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained)); }; return Ok(__ret); }, _ => { let __v_8: G = G::from_u64(0); - let __ret: [G; OUT_539] = [__v_8]; - if let Some(result) = record.function_queries[539].get_mut(&inp[..]) { debug_assert_eq!(result.output, &__ret[..]); if !unconstrained { *result.multiplicity += G::ONE; } } else { record.function_queries[539].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained)); }; + let __ret: [G; OUT_535] = [__v_8]; + if let Some(result) = record.function_queries[535].get_mut(&inp[..]) { debug_assert_eq!(result.output, &__ret[..]); if !unconstrained { *result.multiplicity += G::ONE; } } else { record.function_queries[535].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained)); }; return Ok(__ret); }, } @@ -46623,31 +46339,31 @@ fn aiur_fn_539( match __v_5.as_canonical_u64() { 0u64 => { let __v_8: G = G::from_u64(2); - let __ret: [G; OUT_539] = [__v_8]; - if let Some(result) = record.function_queries[539].get_mut(&inp[..]) { debug_assert_eq!(result.output, &__ret[..]); if !unconstrained { *result.multiplicity += G::ONE; } } else { record.function_queries[539].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained)); }; + let __ret: [G; OUT_535] = [__v_8]; + if let Some(result) = record.function_queries[535].get_mut(&inp[..]) { debug_assert_eq!(result.output, &__ret[..]); if !unconstrained { *result.multiplicity += G::ONE; } } else { record.function_queries[535].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained)); }; return Ok(__ret); }, 1u64 => { let __v_8: G = G::from_u64(2); - let __ret: [G; OUT_539] = [__v_8]; - if let Some(result) = record.function_queries[539].get_mut(&inp[..]) { debug_assert_eq!(result.output, &__ret[..]); if !unconstrained { *result.multiplicity += G::ONE; } } else { record.function_queries[539].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained)); }; + let __ret: [G; OUT_535] = [__v_8]; + if let Some(result) = record.function_queries[535].get_mut(&inp[..]) { debug_assert_eq!(result.output, &__ret[..]); if !unconstrained { *result.multiplicity += G::ONE; } } else { record.function_queries[535].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained)); }; return Ok(__ret); }, 2u64 => { - let __r_arr: [G; OUT_539] = { let __args: [G; IN_539] = [__v_3, __v_6]; let __cu = unconstrained; if let Some(result) = record.function_queries[539].get_mut(&__args[..]) { if !__cu && *result.multiplicity == G::ZERO { aiur_fn_539(__args, record, io_buffer, false)? } else { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_539] = unsafe { *(result.output.as_ptr() as *const [G; OUT_539]) }; __ret } } else { aiur_fn_539(__args, record, io_buffer, __cu)? } }; + let __r_arr: [G; OUT_535] = { let __args: [G; IN_535] = [__v_3, __v_6]; let __cu = unconstrained; if let Some(result) = record.function_queries[535].get_mut(&__args[..]) { if !__cu && *result.multiplicity == G::ZERO { aiur_fn_535(__args, record, io_buffer, false)? } else { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_535] = unsafe { *(result.output.as_ptr() as *const [G; OUT_535]) }; __ret } } else { aiur_fn_535(__args, record, io_buffer, __cu)? } }; let __v_8: G = __r_arr[0]; - let __r_arr: [G; OUT_539] = { let __args: [G; IN_539] = [__v_4, __v_7]; let __cu = unconstrained; if let Some(result) = record.function_queries[539].get_mut(&__args[..]) { if !__cu && *result.multiplicity == G::ZERO { aiur_fn_539(__args, record, io_buffer, false)? } else { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_539] = unsafe { *(result.output.as_ptr() as *const [G; OUT_539]) }; __ret } } else { aiur_fn_539(__args, record, io_buffer, __cu)? } }; + let __r_arr: [G; OUT_535] = { let __args: [G; IN_535] = [__v_4, __v_7]; let __cu = unconstrained; if let Some(result) = record.function_queries[535].get_mut(&__args[..]) { if !__cu && *result.multiplicity == G::ZERO { aiur_fn_535(__args, record, io_buffer, false)? } else { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_535] = unsafe { *(result.output.as_ptr() as *const [G; OUT_535]) }; __ret } } else { aiur_fn_535(__args, record, io_buffer, __cu)? } }; let __v_9: G = __r_arr[0]; - let __r_arr: [G; OUT_529] = { let __args: [G; IN_529] = [__v_8, __v_9]; let __cu = unconstrained; if let Some(result) = record.function_queries[529].get_mut(&__args[..]) { if !__cu && *result.multiplicity == G::ZERO { aiur_fn_529(__args, record, io_buffer, false)? } else { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_529] = unsafe { *(result.output.as_ptr() as *const [G; OUT_529]) }; __ret } } else { aiur_fn_529(__args, record, io_buffer, __cu)? } }; + let __r_arr: [G; OUT_525] = { let __args: [G; IN_525] = [__v_8, __v_9]; let __cu = unconstrained; if let Some(result) = record.function_queries[525].get_mut(&__args[..]) { if !__cu && *result.multiplicity == G::ZERO { aiur_fn_525(__args, record, io_buffer, false)? } else { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_525] = unsafe { *(result.output.as_ptr() as *const [G; OUT_525]) }; __ret } } else { aiur_fn_525(__args, record, io_buffer, __cu)? } }; let __v_10: G = __r_arr[0]; - let __ret: [G; OUT_539] = [__v_10]; - if let Some(result) = record.function_queries[539].get_mut(&inp[..]) { debug_assert_eq!(result.output, &__ret[..]); if !unconstrained { *result.multiplicity += G::ONE; } } else { record.function_queries[539].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained)); }; + let __ret: [G; OUT_535] = [__v_10]; + if let Some(result) = record.function_queries[535].get_mut(&inp[..]) { debug_assert_eq!(result.output, &__ret[..]); if !unconstrained { *result.multiplicity += G::ONE; } } else { record.function_queries[535].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained)); }; return Ok(__ret); }, _ => { let __v_8: G = G::from_u64(0); - let __ret: [G; OUT_539] = [__v_8]; - if let Some(result) = record.function_queries[539].get_mut(&inp[..]) { debug_assert_eq!(result.output, &__ret[..]); if !unconstrained { *result.multiplicity += G::ONE; } } else { record.function_queries[539].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained)); }; + let __ret: [G; OUT_535] = [__v_8]; + if let Some(result) = record.function_queries[535].get_mut(&inp[..]) { debug_assert_eq!(result.output, &__ret[..]); if !unconstrained { *result.multiplicity += G::ONE; } } else { record.function_queries[535].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained)); }; return Ok(__ret); }, } @@ -46660,37 +46376,37 @@ fn aiur_fn_539( match __v_5.as_canonical_u64() { 0u64 => { let __v_8: G = G::from_u64(2); - let __ret: [G; OUT_539] = [__v_8]; - if let Some(result) = record.function_queries[539].get_mut(&inp[..]) { debug_assert_eq!(result.output, &__ret[..]); if !unconstrained { *result.multiplicity += G::ONE; } } else { record.function_queries[539].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained)); }; + let __ret: [G; OUT_535] = [__v_8]; + if let Some(result) = record.function_queries[535].get_mut(&inp[..]) { debug_assert_eq!(result.output, &__ret[..]); if !unconstrained { *result.multiplicity += G::ONE; } } else { record.function_queries[535].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained)); }; return Ok(__ret); }, 1u64 => { let __v_8: G = G::from_u64(2); - let __ret: [G; OUT_539] = [__v_8]; - if let Some(result) = record.function_queries[539].get_mut(&inp[..]) { debug_assert_eq!(result.output, &__ret[..]); if !unconstrained { *result.multiplicity += G::ONE; } } else { record.function_queries[539].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained)); }; + let __ret: [G; OUT_535] = [__v_8]; + if let Some(result) = record.function_queries[535].get_mut(&inp[..]) { debug_assert_eq!(result.output, &__ret[..]); if !unconstrained { *result.multiplicity += G::ONE; } } else { record.function_queries[535].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained)); }; return Ok(__ret); }, 2u64 => { let __v_8: G = G::from_u64(2); - let __ret: [G; OUT_539] = [__v_8]; - if let Some(result) = record.function_queries[539].get_mut(&inp[..]) { debug_assert_eq!(result.output, &__ret[..]); if !unconstrained { *result.multiplicity += G::ONE; } } else { record.function_queries[539].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained)); }; + let __ret: [G; OUT_535] = [__v_8]; + if let Some(result) = record.function_queries[535].get_mut(&inp[..]) { debug_assert_eq!(result.output, &__ret[..]); if !unconstrained { *result.multiplicity += G::ONE; } } else { record.function_queries[535].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained)); }; return Ok(__ret); }, 3u64 => { - let __r_arr: [G; OUT_539] = { let __args: [G; IN_539] = [__v_3, __v_6]; let __cu = unconstrained; if let Some(result) = record.function_queries[539].get_mut(&__args[..]) { if !__cu && *result.multiplicity == G::ZERO { aiur_fn_539(__args, record, io_buffer, false)? } else { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_539] = unsafe { *(result.output.as_ptr() as *const [G; OUT_539]) }; __ret } } else { aiur_fn_539(__args, record, io_buffer, __cu)? } }; + let __r_arr: [G; OUT_535] = { let __args: [G; IN_535] = [__v_3, __v_6]; let __cu = unconstrained; if let Some(result) = record.function_queries[535].get_mut(&__args[..]) { if !__cu && *result.multiplicity == G::ZERO { aiur_fn_535(__args, record, io_buffer, false)? } else { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_535] = unsafe { *(result.output.as_ptr() as *const [G; OUT_535]) }; __ret } } else { aiur_fn_535(__args, record, io_buffer, __cu)? } }; let __v_8: G = __r_arr[0]; - let __r_arr: [G; OUT_539] = { let __args: [G; IN_539] = [__v_4, __v_7]; let __cu = unconstrained; if let Some(result) = record.function_queries[539].get_mut(&__args[..]) { if !__cu && *result.multiplicity == G::ZERO { aiur_fn_539(__args, record, io_buffer, false)? } else { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_539] = unsafe { *(result.output.as_ptr() as *const [G; OUT_539]) }; __ret } } else { aiur_fn_539(__args, record, io_buffer, __cu)? } }; + let __r_arr: [G; OUT_535] = { let __args: [G; IN_535] = [__v_4, __v_7]; let __cu = unconstrained; if let Some(result) = record.function_queries[535].get_mut(&__args[..]) { if !__cu && *result.multiplicity == G::ZERO { aiur_fn_535(__args, record, io_buffer, false)? } else { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_535] = unsafe { *(result.output.as_ptr() as *const [G; OUT_535]) }; __ret } } else { aiur_fn_535(__args, record, io_buffer, __cu)? } }; let __v_9: G = __r_arr[0]; - let __r_arr: [G; OUT_529] = { let __args: [G; IN_529] = [__v_8, __v_9]; let __cu = unconstrained; if let Some(result) = record.function_queries[529].get_mut(&__args[..]) { if !__cu && *result.multiplicity == G::ZERO { aiur_fn_529(__args, record, io_buffer, false)? } else { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_529] = unsafe { *(result.output.as_ptr() as *const [G; OUT_529]) }; __ret } } else { aiur_fn_529(__args, record, io_buffer, __cu)? } }; + let __r_arr: [G; OUT_525] = { let __args: [G; IN_525] = [__v_8, __v_9]; let __cu = unconstrained; if let Some(result) = record.function_queries[525].get_mut(&__args[..]) { if !__cu && *result.multiplicity == G::ZERO { aiur_fn_525(__args, record, io_buffer, false)? } else { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_525] = unsafe { *(result.output.as_ptr() as *const [G; OUT_525]) }; __ret } } else { aiur_fn_525(__args, record, io_buffer, __cu)? } }; let __v_10: G = __r_arr[0]; - let __ret: [G; OUT_539] = [__v_10]; - if let Some(result) = record.function_queries[539].get_mut(&inp[..]) { debug_assert_eq!(result.output, &__ret[..]); if !unconstrained { *result.multiplicity += G::ONE; } } else { record.function_queries[539].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained)); }; + let __ret: [G; OUT_535] = [__v_10]; + if let Some(result) = record.function_queries[535].get_mut(&inp[..]) { debug_assert_eq!(result.output, &__ret[..]); if !unconstrained { *result.multiplicity += G::ONE; } } else { record.function_queries[535].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained)); }; return Ok(__ret); }, 4u64 => { let __v_8: G = G::from_u64(0); - let __ret: [G; OUT_539] = [__v_8]; - if let Some(result) = record.function_queries[539].get_mut(&inp[..]) { debug_assert_eq!(result.output, &__ret[..]); if !unconstrained { *result.multiplicity += G::ONE; } } else { record.function_queries[539].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained)); }; + let __ret: [G; OUT_535] = [__v_8]; + if let Some(result) = record.function_queries[535].get_mut(&inp[..]) { debug_assert_eq!(result.output, &__ret[..]); if !unconstrained { *result.multiplicity += G::ONE; } } else { record.function_queries[535].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained)); }; return Ok(__ret); }, _ => { @@ -46705,16 +46421,16 @@ fn aiur_fn_539( let __v_7: G = __loaded[2]; match __v_5.as_canonical_u64() { 4u64 => { - let __r_arr: [G; OUT_528] = { let __args: [G; IN_528] = [__v_3, __v_6]; let __cu = unconstrained; if let Some(result) = record.function_queries[528].get_mut(&__args[..]) { if !__cu && *result.multiplicity == G::ZERO { aiur_fn_528(__args, record, io_buffer, false)? } else { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_528] = unsafe { *(result.output.as_ptr() as *const [G; OUT_528]) }; __ret } } else { aiur_fn_528(__args, record, io_buffer, __cu)? } }; + let __r_arr: [G; OUT_524] = { let __args: [G; IN_524] = [__v_3, __v_6]; let __cu = unconstrained; if let Some(result) = record.function_queries[524].get_mut(&__args[..]) { if !__cu && *result.multiplicity == G::ZERO { aiur_fn_524(__args, record, io_buffer, false)? } else { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_524] = unsafe { *(result.output.as_ptr() as *const [G; OUT_524]) }; __ret } } else { aiur_fn_524(__args, record, io_buffer, __cu)? } }; let __v_8: G = __r_arr[0]; - let __ret: [G; OUT_539] = [__v_8]; - if let Some(result) = record.function_queries[539].get_mut(&inp[..]) { debug_assert_eq!(result.output, &__ret[..]); if !unconstrained { *result.multiplicity += G::ONE; } } else { record.function_queries[539].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained)); }; + let __ret: [G; OUT_535] = [__v_8]; + if let Some(result) = record.function_queries[535].get_mut(&inp[..]) { debug_assert_eq!(result.output, &__ret[..]); if !unconstrained { *result.multiplicity += G::ONE; } } else { record.function_queries[535].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained)); }; return Ok(__ret); }, _ => { let __v_8: G = G::from_u64(2); - let __ret: [G; OUT_539] = [__v_8]; - if let Some(result) = record.function_queries[539].get_mut(&inp[..]) { debug_assert_eq!(result.output, &__ret[..]); if !unconstrained { *result.multiplicity += G::ONE; } } else { record.function_queries[539].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained)); }; + let __ret: [G; OUT_535] = [__v_8]; + if let Some(result) = record.function_queries[535].get_mut(&inp[..]) { debug_assert_eq!(result.output, &__ret[..]); if !unconstrained { *result.multiplicity += G::ONE; } } else { record.function_queries[535].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained)); }; return Ok(__ret); }, } @@ -46726,15 +46442,15 @@ fn aiur_fn_539( }) } -const INPUT_SIZE_540: usize = 2; -const IN_540: usize = 2; -const OUT_540: usize = 1; -fn aiur_fn_540( - inp: [G; IN_540], +const INPUT_SIZE_536: usize = 2; +const IN_536: usize = 2; +const OUT_536: usize = 1; +fn aiur_fn_536( + inp: [G; IN_536], record: &mut QueryRecord, io_buffer: &mut IOBuffer, unconstrained: bool, -) -> Result<[G; OUT_540], ExecError> { +) -> Result<[G; OUT_536], ExecError> { stacker::maybe_grow(64 * 1024, 4 * 1024 * 1024, || { let __v_0: G = inp[0]; let __v_1: G = inp[1]; @@ -46751,14 +46467,14 @@ fn aiur_fn_540( match __v_5.as_canonical_u64() { 1u64 => { let __v_8: G = G::from_u64(1); - let __ret: [G; OUT_540] = [__v_8]; - if let Some(result) = record.function_queries[540].get_mut(&inp[..]) { debug_assert_eq!(result.output, &__ret[..]); if !unconstrained { *result.multiplicity += G::ONE; } } else { record.function_queries[540].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained)); }; + let __ret: [G; OUT_536] = [__v_8]; + if let Some(result) = record.function_queries[536].get_mut(&inp[..]) { debug_assert_eq!(result.output, &__ret[..]); if !unconstrained { *result.multiplicity += G::ONE; } } else { record.function_queries[536].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained)); }; return Ok(__ret); }, _ => { let __v_8: G = G::from_u64(0); - let __ret: [G; OUT_540] = [__v_8]; - if let Some(result) = record.function_queries[540].get_mut(&inp[..]) { debug_assert_eq!(result.output, &__ret[..]); if !unconstrained { *result.multiplicity += G::ONE; } } else { record.function_queries[540].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained)); }; + let __ret: [G; OUT_536] = [__v_8]; + if let Some(result) = record.function_queries[536].get_mut(&inp[..]) { debug_assert_eq!(result.output, &__ret[..]); if !unconstrained { *result.multiplicity += G::ONE; } } else { record.function_queries[536].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained)); }; return Ok(__ret); }, } @@ -46771,19 +46487,19 @@ fn aiur_fn_540( match __v_5.as_canonical_u64() { 1u64 => { let __v_8: G = G::from_u64(2); - let __ret: [G; OUT_540] = [__v_8]; - if let Some(result) = record.function_queries[540].get_mut(&inp[..]) { debug_assert_eq!(result.output, &__ret[..]); if !unconstrained { *result.multiplicity += G::ONE; } } else { record.function_queries[540].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained)); }; + let __ret: [G; OUT_536] = [__v_8]; + if let Some(result) = record.function_queries[536].get_mut(&inp[..]) { debug_assert_eq!(result.output, &__ret[..]); if !unconstrained { *result.multiplicity += G::ONE; } } else { record.function_queries[536].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained)); }; return Ok(__ret); }, 0u64 => { - let __r_arr: [G; OUT_539] = { let __args: [G; IN_539] = [__v_3, __v_6]; let __cu = unconstrained; if let Some(result) = record.function_queries[539].get_mut(&__args[..]) { if !__cu && *result.multiplicity == G::ZERO { aiur_fn_539(__args, record, io_buffer, false)? } else { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_539] = unsafe { *(result.output.as_ptr() as *const [G; OUT_539]) }; __ret } } else { aiur_fn_539(__args, record, io_buffer, __cu)? } }; + let __r_arr: [G; OUT_535] = { let __args: [G; IN_535] = [__v_3, __v_6]; let __cu = unconstrained; if let Some(result) = record.function_queries[535].get_mut(&__args[..]) { if !__cu && *result.multiplicity == G::ZERO { aiur_fn_535(__args, record, io_buffer, false)? } else { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_535] = unsafe { *(result.output.as_ptr() as *const [G; OUT_535]) }; __ret } } else { aiur_fn_535(__args, record, io_buffer, __cu)? } }; let __v_8: G = __r_arr[0]; - let __r_arr: [G; OUT_540] = { let __args: [G; IN_540] = [__v_4, __v_7]; let __cu = unconstrained; if let Some(result) = record.function_queries[540].get_mut(&__args[..]) { if !__cu && *result.multiplicity == G::ZERO { aiur_fn_540(__args, record, io_buffer, false)? } else { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_540] = unsafe { *(result.output.as_ptr() as *const [G; OUT_540]) }; __ret } } else { aiur_fn_540(__args, record, io_buffer, __cu)? } }; + let __r_arr: [G; OUT_536] = { let __args: [G; IN_536] = [__v_4, __v_7]; let __cu = unconstrained; if let Some(result) = record.function_queries[536].get_mut(&__args[..]) { if !__cu && *result.multiplicity == G::ZERO { aiur_fn_536(__args, record, io_buffer, false)? } else { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_536] = unsafe { *(result.output.as_ptr() as *const [G; OUT_536]) }; __ret } } else { aiur_fn_536(__args, record, io_buffer, __cu)? } }; let __v_9: G = __r_arr[0]; - let __r_arr: [G; OUT_529] = { let __args: [G; IN_529] = [__v_8, __v_9]; let __cu = unconstrained; if let Some(result) = record.function_queries[529].get_mut(&__args[..]) { if !__cu && *result.multiplicity == G::ZERO { aiur_fn_529(__args, record, io_buffer, false)? } else { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_529] = unsafe { *(result.output.as_ptr() as *const [G; OUT_529]) }; __ret } } else { aiur_fn_529(__args, record, io_buffer, __cu)? } }; + let __r_arr: [G; OUT_525] = { let __args: [G; IN_525] = [__v_8, __v_9]; let __cu = unconstrained; if let Some(result) = record.function_queries[525].get_mut(&__args[..]) { if !__cu && *result.multiplicity == G::ZERO { aiur_fn_525(__args, record, io_buffer, false)? } else { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_525] = unsafe { *(result.output.as_ptr() as *const [G; OUT_525]) }; __ret } } else { aiur_fn_525(__args, record, io_buffer, __cu)? } }; let __v_10: G = __r_arr[0]; - let __ret: [G; OUT_540] = [__v_10]; - if let Some(result) = record.function_queries[540].get_mut(&inp[..]) { debug_assert_eq!(result.output, &__ret[..]); if !unconstrained { *result.multiplicity += G::ONE; } } else { record.function_queries[540].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained)); }; + let __ret: [G; OUT_536] = [__v_10]; + if let Some(result) = record.function_queries[536].get_mut(&inp[..]) { debug_assert_eq!(result.output, &__ret[..]); if !unconstrained { *result.multiplicity += G::ONE; } } else { record.function_queries[536].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained)); }; return Ok(__ret); }, _ => { @@ -46798,15 +46514,15 @@ fn aiur_fn_540( }) } -const INPUT_SIZE_541: usize = 4; -const IN_541: usize = 4; -const OUT_541: usize = 1; -fn aiur_fn_541( - inp: [G; IN_541], +const INPUT_SIZE_537: usize = 4; +const IN_537: usize = 4; +const OUT_537: usize = 1; +fn aiur_fn_537( + inp: [G; IN_537], record: &mut QueryRecord, io_buffer: &mut IOBuffer, unconstrained: bool, -) -> Result<[G; OUT_541], ExecError> { +) -> Result<[G; OUT_537], ExecError> { stacker::maybe_grow(64 * 1024, 4 * 1024 * 1024, || { let __v_0: G = inp[0]; let __v_1: G = inp[1]; @@ -46816,16 +46532,16 @@ fn aiur_fn_541( 0u64 => { match __v_2.as_canonical_u64() { 0u64 => { - let __r_arr: [G; OUT_542] = { let __args: [G; IN_542] = [__v_1, __v_3]; let __cu = unconstrained; if let Some(result) = record.function_queries[542].get_mut(&__args[..]) { if !__cu && *result.multiplicity == G::ZERO { aiur_fn_542(__args, record, io_buffer, false)? } else { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_542] = unsafe { *(result.output.as_ptr() as *const [G; OUT_542]) }; __ret } } else { aiur_fn_542(__args, record, io_buffer, __cu)? } }; + let __r_arr: [G; OUT_538] = { let __args: [G; IN_538] = [__v_1, __v_3]; let __cu = unconstrained; if let Some(result) = record.function_queries[538].get_mut(&__args[..]) { if !__cu && *result.multiplicity == G::ZERO { aiur_fn_538(__args, record, io_buffer, false)? } else { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_538] = unsafe { *(result.output.as_ptr() as *const [G; OUT_538]) }; __ret } } else { aiur_fn_538(__args, record, io_buffer, __cu)? } }; let __v_4: G = __r_arr[0]; - let __ret: [G; OUT_541] = [__v_4]; - if let Some(result) = record.function_queries[541].get_mut(&inp[..]) { debug_assert_eq!(result.output, &__ret[..]); if !unconstrained { *result.multiplicity += G::ONE; } } else { record.function_queries[541].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained)); }; + let __ret: [G; OUT_537] = [__v_4]; + if let Some(result) = record.function_queries[537].get_mut(&inp[..]) { debug_assert_eq!(result.output, &__ret[..]); if !unconstrained { *result.multiplicity += G::ONE; } } else { record.function_queries[537].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained)); }; return Ok(__ret); }, 1u64 => { let __v_4: G = G::from_u64(0); - let __ret: [G; OUT_541] = [__v_4]; - if let Some(result) = record.function_queries[541].get_mut(&inp[..]) { debug_assert_eq!(result.output, &__ret[..]); if !unconstrained { *result.multiplicity += G::ONE; } } else { record.function_queries[541].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained)); }; + let __ret: [G; OUT_537] = [__v_4]; + if let Some(result) = record.function_queries[537].get_mut(&inp[..]) { debug_assert_eq!(result.output, &__ret[..]); if !unconstrained { *result.multiplicity += G::ONE; } } else { record.function_queries[537].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained)); }; return Ok(__ret); }, _ => { @@ -46837,15 +46553,15 @@ fn aiur_fn_541( match __v_2.as_canonical_u64() { 0u64 => { let __v_4: G = G::from_u64(2); - let __ret: [G; OUT_541] = [__v_4]; - if let Some(result) = record.function_queries[541].get_mut(&inp[..]) { debug_assert_eq!(result.output, &__ret[..]); if !unconstrained { *result.multiplicity += G::ONE; } } else { record.function_queries[541].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained)); }; + let __ret: [G; OUT_537] = [__v_4]; + if let Some(result) = record.function_queries[537].get_mut(&inp[..]) { debug_assert_eq!(result.output, &__ret[..]); if !unconstrained { *result.multiplicity += G::ONE; } } else { record.function_queries[537].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained)); }; return Ok(__ret); }, 1u64 => { - let __r_arr: [G; OUT_545] = { let __args: [G; IN_545] = [__v_1, __v_3]; let __cu = unconstrained; if let Some(result) = record.function_queries[545].get_mut(&__args[..]) { if !__cu && *result.multiplicity == G::ZERO { aiur_fn_545(__args, record, io_buffer, false)? } else { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_545] = unsafe { *(result.output.as_ptr() as *const [G; OUT_545]) }; __ret } } else { aiur_fn_545(__args, record, io_buffer, __cu)? } }; + let __r_arr: [G; OUT_541] = { let __args: [G; IN_541] = [__v_1, __v_3]; let __cu = unconstrained; if let Some(result) = record.function_queries[541].get_mut(&__args[..]) { if !__cu && *result.multiplicity == G::ZERO { aiur_fn_541(__args, record, io_buffer, false)? } else { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_541] = unsafe { *(result.output.as_ptr() as *const [G; OUT_541]) }; __ret } } else { aiur_fn_541(__args, record, io_buffer, __cu)? } }; let __v_4: G = __r_arr[0]; - let __ret: [G; OUT_541] = [__v_4]; - if let Some(result) = record.function_queries[541].get_mut(&inp[..]) { debug_assert_eq!(result.output, &__ret[..]); if !unconstrained { *result.multiplicity += G::ONE; } } else { record.function_queries[541].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained)); }; + let __ret: [G; OUT_537] = [__v_4]; + if let Some(result) = record.function_queries[537].get_mut(&inp[..]) { debug_assert_eq!(result.output, &__ret[..]); if !unconstrained { *result.multiplicity += G::ONE; } } else { record.function_queries[537].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained)); }; return Ok(__ret); }, _ => { @@ -46860,15 +46576,15 @@ fn aiur_fn_541( }) } -const INPUT_SIZE_542: usize = 2; -const IN_542: usize = 2; -const OUT_542: usize = 1; -fn aiur_fn_542( - inp: [G; IN_542], +const INPUT_SIZE_538: usize = 2; +const IN_538: usize = 2; +const OUT_538: usize = 1; +fn aiur_fn_538( + inp: [G; IN_538], record: &mut QueryRecord, io_buffer: &mut IOBuffer, unconstrained: bool, -) -> Result<[G; OUT_542], ExecError> { +) -> Result<[G; OUT_538], ExecError> { stacker::maybe_grow(64 * 1024, 4 * 1024 * 1024, || { let __v_0: G = inp[0]; let __v_1: G = inp[1]; @@ -46876,38 +46592,38 @@ fn aiur_fn_542( let __v_2: G = __r_arr[0]; let __r_arr: [G; OUT_118] = { let __args: [G; IN_118] = [__v_1]; let __cu = unconstrained; if let Some(result) = record.function_queries[118].get_mut(&__args[..]) { if !__cu && *result.multiplicity == G::ZERO { aiur_fn_118(__args, record, io_buffer, false)? } else { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_118] = unsafe { *(result.output.as_ptr() as *const [G; OUT_118]) }; __ret } } else { aiur_fn_118(__args, record, io_buffer, __cu)? } }; let __v_3: G = __r_arr[0]; - let __r_arr: [G; OUT_767] = { let __args: [G; IN_767] = [__v_2]; let __cu = unconstrained; if let Some(result) = record.function_queries[767].get_mut(&__args[..]) { if !__cu && *result.multiplicity == G::ZERO { aiur_fn_767(__args, record, io_buffer, false)? } else { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_767] = unsafe { *(result.output.as_ptr() as *const [G; OUT_767]) }; __ret } } else { aiur_fn_767(__args, record, io_buffer, __cu)? } }; + let __r_arr: [G; OUT_763] = { let __args: [G; IN_763] = [__v_2]; let __cu = unconstrained; if let Some(result) = record.function_queries[763].get_mut(&__args[..]) { if !__cu && *result.multiplicity == G::ZERO { aiur_fn_763(__args, record, io_buffer, false)? } else { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_763] = unsafe { *(result.output.as_ptr() as *const [G; OUT_763]) }; __ret } } else { aiur_fn_763(__args, record, io_buffer, __cu)? } }; let __v_4: G = __r_arr[0]; - let __r_arr: [G; OUT_767] = { let __args: [G; IN_767] = [__v_3]; let __cu = unconstrained; if let Some(result) = record.function_queries[767].get_mut(&__args[..]) { if !__cu && *result.multiplicity == G::ZERO { aiur_fn_767(__args, record, io_buffer, false)? } else { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_767] = unsafe { *(result.output.as_ptr() as *const [G; OUT_767]) }; __ret } } else { aiur_fn_767(__args, record, io_buffer, __cu)? } }; + let __r_arr: [G; OUT_763] = { let __args: [G; IN_763] = [__v_3]; let __cu = unconstrained; if let Some(result) = record.function_queries[763].get_mut(&__args[..]) { if !__cu && *result.multiplicity == G::ZERO { aiur_fn_763(__args, record, io_buffer, false)? } else { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_763] = unsafe { *(result.output.as_ptr() as *const [G; OUT_763]) }; __ret } } else { aiur_fn_763(__args, record, io_buffer, __cu)? } }; let __v_5: G = __r_arr[0]; - let __r_arr: [G; OUT_528] = { let __args: [G; IN_528] = [__v_4, __v_5]; let __cu = unconstrained; if let Some(result) = record.function_queries[528].get_mut(&__args[..]) { if !__cu && *result.multiplicity == G::ZERO { aiur_fn_528(__args, record, io_buffer, false)? } else { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_528] = unsafe { *(result.output.as_ptr() as *const [G; OUT_528]) }; __ret } } else { aiur_fn_528(__args, record, io_buffer, __cu)? } }; + let __r_arr: [G; OUT_524] = { let __args: [G; IN_524] = [__v_4, __v_5]; let __cu = unconstrained; if let Some(result) = record.function_queries[524].get_mut(&__args[..]) { if !__cu && *result.multiplicity == G::ZERO { aiur_fn_524(__args, record, io_buffer, false)? } else { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_524] = unsafe { *(result.output.as_ptr() as *const [G; OUT_524]) }; __ret } } else { aiur_fn_524(__args, record, io_buffer, __cu)? } }; let __v_6: G = __r_arr[0]; match __v_6.as_canonical_u64() { 1u64 => { - let __r_arr: [G; OUT_543] = { let __args: [G; IN_543] = [__v_2, __v_3]; let __cu = unconstrained; if let Some(result) = record.function_queries[543].get_mut(&__args[..]) { if !__cu && *result.multiplicity == G::ZERO { aiur_fn_543(__args, record, io_buffer, false)? } else { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_543] = unsafe { *(result.output.as_ptr() as *const [G; OUT_543]) }; __ret } } else { aiur_fn_543(__args, record, io_buffer, __cu)? } }; + let __r_arr: [G; OUT_539] = { let __args: [G; IN_539] = [__v_2, __v_3]; let __cu = unconstrained; if let Some(result) = record.function_queries[539].get_mut(&__args[..]) { if !__cu && *result.multiplicity == G::ZERO { aiur_fn_539(__args, record, io_buffer, false)? } else { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_539] = unsafe { *(result.output.as_ptr() as *const [G; OUT_539]) }; __ret } } else { aiur_fn_539(__args, record, io_buffer, __cu)? } }; let __v_7: G = __r_arr[0]; - let __ret: [G; OUT_542] = [__v_7]; - if let Some(result) = record.function_queries[542].get_mut(&inp[..]) { debug_assert_eq!(result.output, &__ret[..]); if !unconstrained { *result.multiplicity += G::ONE; } } else { record.function_queries[542].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained)); }; + let __ret: [G; OUT_538] = [__v_7]; + if let Some(result) = record.function_queries[538].get_mut(&inp[..]) { debug_assert_eq!(result.output, &__ret[..]); if !unconstrained { *result.multiplicity += G::ONE; } } else { record.function_queries[538].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained)); }; return Ok(__ret); }, _ => { - let __ret: [G; OUT_542] = [__v_6]; - if let Some(result) = record.function_queries[542].get_mut(&inp[..]) { debug_assert_eq!(result.output, &__ret[..]); if !unconstrained { *result.multiplicity += G::ONE; } } else { record.function_queries[542].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained)); }; + let __ret: [G; OUT_538] = [__v_6]; + if let Some(result) = record.function_queries[538].get_mut(&inp[..]) { debug_assert_eq!(result.output, &__ret[..]); if !unconstrained { *result.multiplicity += G::ONE; } } else { record.function_queries[538].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained)); }; return Ok(__ret); }, } }) } -const INPUT_SIZE_543: usize = 2; -const IN_543: usize = 2; -const OUT_543: usize = 1; -fn aiur_fn_543( - inp: [G; IN_543], +const INPUT_SIZE_539: usize = 2; +const IN_539: usize = 2; +const OUT_539: usize = 1; +fn aiur_fn_539( + inp: [G; IN_539], record: &mut QueryRecord, io_buffer: &mut IOBuffer, unconstrained: bool, -) -> Result<[G; OUT_543], ExecError> { +) -> Result<[G; OUT_539], ExecError> { stacker::maybe_grow(64 * 1024, 4 * 1024 * 1024, || { let __v_0: G = inp[0]; let __v_1: G = inp[1]; @@ -46925,8 +46641,8 @@ fn aiur_fn_543( match __v_2.as_canonical_u64() { 1u64 => { let __v_12: G = G::from_u64(1); - let __ret: [G; OUT_543] = [__v_12]; - if let Some(result) = record.function_queries[543].get_mut(&inp[..]) { debug_assert_eq!(result.output, &__ret[..]); if !unconstrained { *result.multiplicity += G::ONE; } } else { record.function_queries[543].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained)); }; + let __ret: [G; OUT_539] = [__v_12]; + if let Some(result) = record.function_queries[539].get_mut(&inp[..]) { debug_assert_eq!(result.output, &__ret[..]); if !unconstrained { *result.multiplicity += G::ONE; } } else { record.function_queries[539].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained)); }; return Ok(__ret); }, 0u64 => { @@ -46943,14 +46659,14 @@ fn aiur_fn_543( let __v_21: G = __loaded[9]; match __v_12.as_canonical_u64() { 0u64 => { - let __r_arr: [G; OUT_543] = { let __args: [G; IN_543] = [__v_11, __v_21]; let __cu = unconstrained; if let Some(result) = record.function_queries[543].get_mut(&__args[..]) { if !__cu && *result.multiplicity == G::ZERO { aiur_fn_543(__args, record, io_buffer, false)? } else { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_543] = unsafe { *(result.output.as_ptr() as *const [G; OUT_543]) }; __ret } } else { aiur_fn_543(__args, record, io_buffer, __cu)? } }; + let __r_arr: [G; OUT_539] = { let __args: [G; IN_539] = [__v_11, __v_21]; let __cu = unconstrained; if let Some(result) = record.function_queries[539].get_mut(&__args[..]) { if !__cu && *result.multiplicity == G::ZERO { aiur_fn_539(__args, record, io_buffer, false)? } else { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_539] = unsafe { *(result.output.as_ptr() as *const [G; OUT_539]) }; __ret } } else { aiur_fn_539(__args, record, io_buffer, __cu)? } }; let __v_22: G = __r_arr[0]; - let __r_arr: [G; OUT_544] = { let __args: [G; IN_544] = [__v_3, __v_4, __v_5, __v_6, __v_7, __v_8, __v_9, __v_10, __v_13, __v_14, __v_15, __v_16, __v_17, __v_18, __v_19, __v_20]; let __cu = unconstrained; if let Some(result) = record.function_queries[544].get_mut(&__args[..]) { if !__cu && *result.multiplicity == G::ZERO { aiur_fn_544(__args, record, io_buffer, false)? } else { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_544] = unsafe { *(result.output.as_ptr() as *const [G; OUT_544]) }; __ret } } else { aiur_fn_544(__args, record, io_buffer, __cu)? } }; + let __r_arr: [G; OUT_540] = { let __args: [G; IN_540] = [__v_3, __v_4, __v_5, __v_6, __v_7, __v_8, __v_9, __v_10, __v_13, __v_14, __v_15, __v_16, __v_17, __v_18, __v_19, __v_20]; let __cu = unconstrained; if let Some(result) = record.function_queries[540].get_mut(&__args[..]) { if !__cu && *result.multiplicity == G::ZERO { aiur_fn_540(__args, record, io_buffer, false)? } else { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_540] = unsafe { *(result.output.as_ptr() as *const [G; OUT_540]) }; __ret } } else { aiur_fn_540(__args, record, io_buffer, __cu)? } }; let __v_23: G = __r_arr[0]; - let __r_arr: [G; OUT_529] = { let __args: [G; IN_529] = [__v_22, __v_23]; let __cu = unconstrained; if let Some(result) = record.function_queries[529].get_mut(&__args[..]) { if !__cu && *result.multiplicity == G::ZERO { aiur_fn_529(__args, record, io_buffer, false)? } else { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_529] = unsafe { *(result.output.as_ptr() as *const [G; OUT_529]) }; __ret } } else { aiur_fn_529(__args, record, io_buffer, __cu)? } }; + let __r_arr: [G; OUT_525] = { let __args: [G; IN_525] = [__v_22, __v_23]; let __cu = unconstrained; if let Some(result) = record.function_queries[525].get_mut(&__args[..]) { if !__cu && *result.multiplicity == G::ZERO { aiur_fn_525(__args, record, io_buffer, false)? } else { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_525] = unsafe { *(result.output.as_ptr() as *const [G; OUT_525]) }; __ret } } else { aiur_fn_525(__args, record, io_buffer, __cu)? } }; let __v_24: G = __r_arr[0]; - let __ret: [G; OUT_543] = [__v_24]; - if let Some(result) = record.function_queries[543].get_mut(&inp[..]) { debug_assert_eq!(result.output, &__ret[..]); if !unconstrained { *result.multiplicity += G::ONE; } } else { record.function_queries[543].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained)); }; + let __ret: [G; OUT_539] = [__v_24]; + if let Some(result) = record.function_queries[539].get_mut(&inp[..]) { debug_assert_eq!(result.output, &__ret[..]); if !unconstrained { *result.multiplicity += G::ONE; } } else { record.function_queries[539].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained)); }; return Ok(__ret); }, _ => { @@ -46965,15 +46681,15 @@ fn aiur_fn_543( }) } -const INPUT_SIZE_544: usize = 16; -const IN_544: usize = 16; -const OUT_544: usize = 1; -fn aiur_fn_544( - inp: [G; IN_544], +const INPUT_SIZE_540: usize = 16; +const IN_540: usize = 16; +const OUT_540: usize = 1; +fn aiur_fn_540( + inp: [G; IN_540], record: &mut QueryRecord, io_buffer: &mut IOBuffer, unconstrained: bool, -) -> Result<[G; OUT_544], ExecError> { +) -> Result<[G; OUT_540], ExecError> { stacker::maybe_grow(64 * 1024, 4 * 1024 * 1024, || { let __v_0: G = inp[0]; let __v_1: G = inp[1]; @@ -46991,51 +46707,51 @@ fn aiur_fn_544( let __v_13: G = inp[13]; let __v_14: G = inp[14]; let __v_15: G = inp[15]; - let __r_arr: [G; OUT_528] = { let __args: [G; IN_528] = [__v_7, __v_15]; let __cu = unconstrained; if let Some(result) = record.function_queries[528].get_mut(&__args[..]) { if !__cu && *result.multiplicity == G::ZERO { aiur_fn_528(__args, record, io_buffer, false)? } else { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_528] = unsafe { *(result.output.as_ptr() as *const [G; OUT_528]) }; __ret } } else { aiur_fn_528(__args, record, io_buffer, __cu)? } }; + let __r_arr: [G; OUT_524] = { let __args: [G; IN_524] = [__v_7, __v_15]; let __cu = unconstrained; if let Some(result) = record.function_queries[524].get_mut(&__args[..]) { if !__cu && *result.multiplicity == G::ZERO { aiur_fn_524(__args, record, io_buffer, false)? } else { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_524] = unsafe { *(result.output.as_ptr() as *const [G; OUT_524]) }; __ret } } else { aiur_fn_524(__args, record, io_buffer, __cu)? } }; let __v_16: G = __r_arr[0]; - let __r_arr: [G; OUT_528] = { let __args: [G; IN_528] = [__v_6, __v_14]; let __cu = unconstrained; if let Some(result) = record.function_queries[528].get_mut(&__args[..]) { if !__cu && *result.multiplicity == G::ZERO { aiur_fn_528(__args, record, io_buffer, false)? } else { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_528] = unsafe { *(result.output.as_ptr() as *const [G; OUT_528]) }; __ret } } else { aiur_fn_528(__args, record, io_buffer, __cu)? } }; + let __r_arr: [G; OUT_524] = { let __args: [G; IN_524] = [__v_6, __v_14]; let __cu = unconstrained; if let Some(result) = record.function_queries[524].get_mut(&__args[..]) { if !__cu && *result.multiplicity == G::ZERO { aiur_fn_524(__args, record, io_buffer, false)? } else { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_524] = unsafe { *(result.output.as_ptr() as *const [G; OUT_524]) }; __ret } } else { aiur_fn_524(__args, record, io_buffer, __cu)? } }; let __v_17: G = __r_arr[0]; - let __r_arr: [G; OUT_528] = { let __args: [G; IN_528] = [__v_5, __v_13]; let __cu = unconstrained; if let Some(result) = record.function_queries[528].get_mut(&__args[..]) { if !__cu && *result.multiplicity == G::ZERO { aiur_fn_528(__args, record, io_buffer, false)? } else { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_528] = unsafe { *(result.output.as_ptr() as *const [G; OUT_528]) }; __ret } } else { aiur_fn_528(__args, record, io_buffer, __cu)? } }; + let __r_arr: [G; OUT_524] = { let __args: [G; IN_524] = [__v_5, __v_13]; let __cu = unconstrained; if let Some(result) = record.function_queries[524].get_mut(&__args[..]) { if !__cu && *result.multiplicity == G::ZERO { aiur_fn_524(__args, record, io_buffer, false)? } else { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_524] = unsafe { *(result.output.as_ptr() as *const [G; OUT_524]) }; __ret } } else { aiur_fn_524(__args, record, io_buffer, __cu)? } }; let __v_18: G = __r_arr[0]; - let __r_arr: [G; OUT_528] = { let __args: [G; IN_528] = [__v_4, __v_12]; let __cu = unconstrained; if let Some(result) = record.function_queries[528].get_mut(&__args[..]) { if !__cu && *result.multiplicity == G::ZERO { aiur_fn_528(__args, record, io_buffer, false)? } else { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_528] = unsafe { *(result.output.as_ptr() as *const [G; OUT_528]) }; __ret } } else { aiur_fn_528(__args, record, io_buffer, __cu)? } }; + let __r_arr: [G; OUT_524] = { let __args: [G; IN_524] = [__v_4, __v_12]; let __cu = unconstrained; if let Some(result) = record.function_queries[524].get_mut(&__args[..]) { if !__cu && *result.multiplicity == G::ZERO { aiur_fn_524(__args, record, io_buffer, false)? } else { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_524] = unsafe { *(result.output.as_ptr() as *const [G; OUT_524]) }; __ret } } else { aiur_fn_524(__args, record, io_buffer, __cu)? } }; let __v_19: G = __r_arr[0]; - let __r_arr: [G; OUT_528] = { let __args: [G; IN_528] = [__v_3, __v_11]; let __cu = unconstrained; if let Some(result) = record.function_queries[528].get_mut(&__args[..]) { if !__cu && *result.multiplicity == G::ZERO { aiur_fn_528(__args, record, io_buffer, false)? } else { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_528] = unsafe { *(result.output.as_ptr() as *const [G; OUT_528]) }; __ret } } else { aiur_fn_528(__args, record, io_buffer, __cu)? } }; + let __r_arr: [G; OUT_524] = { let __args: [G; IN_524] = [__v_3, __v_11]; let __cu = unconstrained; if let Some(result) = record.function_queries[524].get_mut(&__args[..]) { if !__cu && *result.multiplicity == G::ZERO { aiur_fn_524(__args, record, io_buffer, false)? } else { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_524] = unsafe { *(result.output.as_ptr() as *const [G; OUT_524]) }; __ret } } else { aiur_fn_524(__args, record, io_buffer, __cu)? } }; let __v_20: G = __r_arr[0]; - let __r_arr: [G; OUT_528] = { let __args: [G; IN_528] = [__v_2, __v_10]; let __cu = unconstrained; if let Some(result) = record.function_queries[528].get_mut(&__args[..]) { if !__cu && *result.multiplicity == G::ZERO { aiur_fn_528(__args, record, io_buffer, false)? } else { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_528] = unsafe { *(result.output.as_ptr() as *const [G; OUT_528]) }; __ret } } else { aiur_fn_528(__args, record, io_buffer, __cu)? } }; + let __r_arr: [G; OUT_524] = { let __args: [G; IN_524] = [__v_2, __v_10]; let __cu = unconstrained; if let Some(result) = record.function_queries[524].get_mut(&__args[..]) { if !__cu && *result.multiplicity == G::ZERO { aiur_fn_524(__args, record, io_buffer, false)? } else { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_524] = unsafe { *(result.output.as_ptr() as *const [G; OUT_524]) }; __ret } } else { aiur_fn_524(__args, record, io_buffer, __cu)? } }; let __v_21: G = __r_arr[0]; - let __r_arr: [G; OUT_528] = { let __args: [G; IN_528] = [__v_1, __v_9]; let __cu = unconstrained; if let Some(result) = record.function_queries[528].get_mut(&__args[..]) { if !__cu && *result.multiplicity == G::ZERO { aiur_fn_528(__args, record, io_buffer, false)? } else { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_528] = unsafe { *(result.output.as_ptr() as *const [G; OUT_528]) }; __ret } } else { aiur_fn_528(__args, record, io_buffer, __cu)? } }; + let __r_arr: [G; OUT_524] = { let __args: [G; IN_524] = [__v_1, __v_9]; let __cu = unconstrained; if let Some(result) = record.function_queries[524].get_mut(&__args[..]) { if !__cu && *result.multiplicity == G::ZERO { aiur_fn_524(__args, record, io_buffer, false)? } else { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_524] = unsafe { *(result.output.as_ptr() as *const [G; OUT_524]) }; __ret } } else { aiur_fn_524(__args, record, io_buffer, __cu)? } }; let __v_22: G = __r_arr[0]; - let __r_arr: [G; OUT_528] = { let __args: [G; IN_528] = [__v_0, __v_8]; let __cu = unconstrained; if let Some(result) = record.function_queries[528].get_mut(&__args[..]) { if !__cu && *result.multiplicity == G::ZERO { aiur_fn_528(__args, record, io_buffer, false)? } else { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_528] = unsafe { *(result.output.as_ptr() as *const [G; OUT_528]) }; __ret } } else { aiur_fn_528(__args, record, io_buffer, __cu)? } }; + let __r_arr: [G; OUT_524] = { let __args: [G; IN_524] = [__v_0, __v_8]; let __cu = unconstrained; if let Some(result) = record.function_queries[524].get_mut(&__args[..]) { if !__cu && *result.multiplicity == G::ZERO { aiur_fn_524(__args, record, io_buffer, false)? } else { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_524] = unsafe { *(result.output.as_ptr() as *const [G; OUT_524]) }; __ret } } else { aiur_fn_524(__args, record, io_buffer, __cu)? } }; let __v_23: G = __r_arr[0]; - let __r_arr: [G; OUT_529] = { let __args: [G; IN_529] = [__v_22, __v_23]; let __cu = unconstrained; if let Some(result) = record.function_queries[529].get_mut(&__args[..]) { if !__cu && *result.multiplicity == G::ZERO { aiur_fn_529(__args, record, io_buffer, false)? } else { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_529] = unsafe { *(result.output.as_ptr() as *const [G; OUT_529]) }; __ret } } else { aiur_fn_529(__args, record, io_buffer, __cu)? } }; + let __r_arr: [G; OUT_525] = { let __args: [G; IN_525] = [__v_22, __v_23]; let __cu = unconstrained; if let Some(result) = record.function_queries[525].get_mut(&__args[..]) { if !__cu && *result.multiplicity == G::ZERO { aiur_fn_525(__args, record, io_buffer, false)? } else { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_525] = unsafe { *(result.output.as_ptr() as *const [G; OUT_525]) }; __ret } } else { aiur_fn_525(__args, record, io_buffer, __cu)? } }; let __v_24: G = __r_arr[0]; - let __r_arr: [G; OUT_529] = { let __args: [G; IN_529] = [__v_21, __v_24]; let __cu = unconstrained; if let Some(result) = record.function_queries[529].get_mut(&__args[..]) { if !__cu && *result.multiplicity == G::ZERO { aiur_fn_529(__args, record, io_buffer, false)? } else { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_529] = unsafe { *(result.output.as_ptr() as *const [G; OUT_529]) }; __ret } } else { aiur_fn_529(__args, record, io_buffer, __cu)? } }; + let __r_arr: [G; OUT_525] = { let __args: [G; IN_525] = [__v_21, __v_24]; let __cu = unconstrained; if let Some(result) = record.function_queries[525].get_mut(&__args[..]) { if !__cu && *result.multiplicity == G::ZERO { aiur_fn_525(__args, record, io_buffer, false)? } else { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_525] = unsafe { *(result.output.as_ptr() as *const [G; OUT_525]) }; __ret } } else { aiur_fn_525(__args, record, io_buffer, __cu)? } }; let __v_25: G = __r_arr[0]; - let __r_arr: [G; OUT_529] = { let __args: [G; IN_529] = [__v_20, __v_25]; let __cu = unconstrained; if let Some(result) = record.function_queries[529].get_mut(&__args[..]) { if !__cu && *result.multiplicity == G::ZERO { aiur_fn_529(__args, record, io_buffer, false)? } else { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_529] = unsafe { *(result.output.as_ptr() as *const [G; OUT_529]) }; __ret } } else { aiur_fn_529(__args, record, io_buffer, __cu)? } }; + let __r_arr: [G; OUT_525] = { let __args: [G; IN_525] = [__v_20, __v_25]; let __cu = unconstrained; if let Some(result) = record.function_queries[525].get_mut(&__args[..]) { if !__cu && *result.multiplicity == G::ZERO { aiur_fn_525(__args, record, io_buffer, false)? } else { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_525] = unsafe { *(result.output.as_ptr() as *const [G; OUT_525]) }; __ret } } else { aiur_fn_525(__args, record, io_buffer, __cu)? } }; let __v_26: G = __r_arr[0]; - let __r_arr: [G; OUT_529] = { let __args: [G; IN_529] = [__v_19, __v_26]; let __cu = unconstrained; if let Some(result) = record.function_queries[529].get_mut(&__args[..]) { if !__cu && *result.multiplicity == G::ZERO { aiur_fn_529(__args, record, io_buffer, false)? } else { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_529] = unsafe { *(result.output.as_ptr() as *const [G; OUT_529]) }; __ret } } else { aiur_fn_529(__args, record, io_buffer, __cu)? } }; + let __r_arr: [G; OUT_525] = { let __args: [G; IN_525] = [__v_19, __v_26]; let __cu = unconstrained; if let Some(result) = record.function_queries[525].get_mut(&__args[..]) { if !__cu && *result.multiplicity == G::ZERO { aiur_fn_525(__args, record, io_buffer, false)? } else { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_525] = unsafe { *(result.output.as_ptr() as *const [G; OUT_525]) }; __ret } } else { aiur_fn_525(__args, record, io_buffer, __cu)? } }; let __v_27: G = __r_arr[0]; - let __r_arr: [G; OUT_529] = { let __args: [G; IN_529] = [__v_18, __v_27]; let __cu = unconstrained; if let Some(result) = record.function_queries[529].get_mut(&__args[..]) { if !__cu && *result.multiplicity == G::ZERO { aiur_fn_529(__args, record, io_buffer, false)? } else { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_529] = unsafe { *(result.output.as_ptr() as *const [G; OUT_529]) }; __ret } } else { aiur_fn_529(__args, record, io_buffer, __cu)? } }; + let __r_arr: [G; OUT_525] = { let __args: [G; IN_525] = [__v_18, __v_27]; let __cu = unconstrained; if let Some(result) = record.function_queries[525].get_mut(&__args[..]) { if !__cu && *result.multiplicity == G::ZERO { aiur_fn_525(__args, record, io_buffer, false)? } else { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_525] = unsafe { *(result.output.as_ptr() as *const [G; OUT_525]) }; __ret } } else { aiur_fn_525(__args, record, io_buffer, __cu)? } }; let __v_28: G = __r_arr[0]; - let __r_arr: [G; OUT_529] = { let __args: [G; IN_529] = [__v_17, __v_28]; let __cu = unconstrained; if let Some(result) = record.function_queries[529].get_mut(&__args[..]) { if !__cu && *result.multiplicity == G::ZERO { aiur_fn_529(__args, record, io_buffer, false)? } else { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_529] = unsafe { *(result.output.as_ptr() as *const [G; OUT_529]) }; __ret } } else { aiur_fn_529(__args, record, io_buffer, __cu)? } }; + let __r_arr: [G; OUT_525] = { let __args: [G; IN_525] = [__v_17, __v_28]; let __cu = unconstrained; if let Some(result) = record.function_queries[525].get_mut(&__args[..]) { if !__cu && *result.multiplicity == G::ZERO { aiur_fn_525(__args, record, io_buffer, false)? } else { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_525] = unsafe { *(result.output.as_ptr() as *const [G; OUT_525]) }; __ret } } else { aiur_fn_525(__args, record, io_buffer, __cu)? } }; let __v_29: G = __r_arr[0]; - let __r_arr: [G; OUT_529] = { let __args: [G; IN_529] = [__v_16, __v_29]; let __cu = unconstrained; if let Some(result) = record.function_queries[529].get_mut(&__args[..]) { if !__cu && *result.multiplicity == G::ZERO { aiur_fn_529(__args, record, io_buffer, false)? } else { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_529] = unsafe { *(result.output.as_ptr() as *const [G; OUT_529]) }; __ret } } else { aiur_fn_529(__args, record, io_buffer, __cu)? } }; + let __r_arr: [G; OUT_525] = { let __args: [G; IN_525] = [__v_16, __v_29]; let __cu = unconstrained; if let Some(result) = record.function_queries[525].get_mut(&__args[..]) { if !__cu && *result.multiplicity == G::ZERO { aiur_fn_525(__args, record, io_buffer, false)? } else { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_525] = unsafe { *(result.output.as_ptr() as *const [G; OUT_525]) }; __ret } } else { aiur_fn_525(__args, record, io_buffer, __cu)? } }; let __v_30: G = __r_arr[0]; - let __ret: [G; OUT_544] = [__v_30]; - if let Some(result) = record.function_queries[544].get_mut(&inp[..]) { debug_assert_eq!(result.output, &__ret[..]); if !unconstrained { *result.multiplicity += G::ONE; } } else { record.function_queries[544].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained)); }; + let __ret: [G; OUT_540] = [__v_30]; + if let Some(result) = record.function_queries[540].get_mut(&inp[..]) { debug_assert_eq!(result.output, &__ret[..]); if !unconstrained { *result.multiplicity += G::ONE; } } else { record.function_queries[540].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained)); }; return Ok(__ret); }) } -const INPUT_SIZE_545: usize = 2; -const IN_545: usize = 2; -const OUT_545: usize = 1; -fn aiur_fn_545( - inp: [G; IN_545], +const INPUT_SIZE_541: usize = 2; +const IN_541: usize = 2; +const OUT_541: usize = 1; +fn aiur_fn_541( + inp: [G; IN_541], record: &mut QueryRecord, io_buffer: &mut IOBuffer, unconstrained: bool, -) -> Result<[G; OUT_545], ExecError> { +) -> Result<[G; OUT_541], ExecError> { stacker::maybe_grow(64 * 1024, 4 * 1024 * 1024, || { let __v_0: G = inp[0]; let __v_1: G = inp[1]; @@ -47052,14 +46768,14 @@ fn aiur_fn_545( match __v_5.as_canonical_u64() { 1u64 => { let __v_8: G = G::from_u64(1); - let __ret: [G; OUT_545] = [__v_8]; - if let Some(result) = record.function_queries[545].get_mut(&inp[..]) { debug_assert_eq!(result.output, &__ret[..]); if !unconstrained { *result.multiplicity += G::ONE; } } else { record.function_queries[545].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained)); }; + let __ret: [G; OUT_541] = [__v_8]; + if let Some(result) = record.function_queries[541].get_mut(&inp[..]) { debug_assert_eq!(result.output, &__ret[..]); if !unconstrained { *result.multiplicity += G::ONE; } } else { record.function_queries[541].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained)); }; return Ok(__ret); }, _ => { let __v_8: G = G::from_u64(0); - let __ret: [G; OUT_545] = [__v_8]; - if let Some(result) = record.function_queries[545].get_mut(&inp[..]) { debug_assert_eq!(result.output, &__ret[..]); if !unconstrained { *result.multiplicity += G::ONE; } } else { record.function_queries[545].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained)); }; + let __ret: [G; OUT_541] = [__v_8]; + if let Some(result) = record.function_queries[541].get_mut(&inp[..]) { debug_assert_eq!(result.output, &__ret[..]); if !unconstrained { *result.multiplicity += G::ONE; } } else { record.function_queries[541].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained)); }; return Ok(__ret); }, } @@ -47072,19 +46788,19 @@ fn aiur_fn_545( match __v_5.as_canonical_u64() { 1u64 => { let __v_8: G = G::from_u64(2); - let __ret: [G; OUT_545] = [__v_8]; - if let Some(result) = record.function_queries[545].get_mut(&inp[..]) { debug_assert_eq!(result.output, &__ret[..]); if !unconstrained { *result.multiplicity += G::ONE; } } else { record.function_queries[545].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained)); }; + let __ret: [G; OUT_541] = [__v_8]; + if let Some(result) = record.function_queries[541].get_mut(&inp[..]) { debug_assert_eq!(result.output, &__ret[..]); if !unconstrained { *result.multiplicity += G::ONE; } } else { record.function_queries[541].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained)); }; return Ok(__ret); }, 0u64 => { - let __r_arr: [G; OUT_528] = { let __args: [G; IN_528] = [__v_3, __v_6]; let __cu = unconstrained; if let Some(result) = record.function_queries[528].get_mut(&__args[..]) { if !__cu && *result.multiplicity == G::ZERO { aiur_fn_528(__args, record, io_buffer, false)? } else { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_528] = unsafe { *(result.output.as_ptr() as *const [G; OUT_528]) }; __ret } } else { aiur_fn_528(__args, record, io_buffer, __cu)? } }; + let __r_arr: [G; OUT_524] = { let __args: [G; IN_524] = [__v_3, __v_6]; let __cu = unconstrained; if let Some(result) = record.function_queries[524].get_mut(&__args[..]) { if !__cu && *result.multiplicity == G::ZERO { aiur_fn_524(__args, record, io_buffer, false)? } else { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_524] = unsafe { *(result.output.as_ptr() as *const [G; OUT_524]) }; __ret } } else { aiur_fn_524(__args, record, io_buffer, __cu)? } }; let __v_8: G = __r_arr[0]; - let __r_arr: [G; OUT_545] = { let __args: [G; IN_545] = [__v_4, __v_7]; let __cu = unconstrained; if let Some(result) = record.function_queries[545].get_mut(&__args[..]) { if !__cu && *result.multiplicity == G::ZERO { aiur_fn_545(__args, record, io_buffer, false)? } else { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_545] = unsafe { *(result.output.as_ptr() as *const [G; OUT_545]) }; __ret } } else { aiur_fn_545(__args, record, io_buffer, __cu)? } }; + let __r_arr: [G; OUT_541] = { let __args: [G; IN_541] = [__v_4, __v_7]; let __cu = unconstrained; if let Some(result) = record.function_queries[541].get_mut(&__args[..]) { if !__cu && *result.multiplicity == G::ZERO { aiur_fn_541(__args, record, io_buffer, false)? } else { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_541] = unsafe { *(result.output.as_ptr() as *const [G; OUT_541]) }; __ret } } else { aiur_fn_541(__args, record, io_buffer, __cu)? } }; let __v_9: G = __r_arr[0]; - let __r_arr: [G; OUT_529] = { let __args: [G; IN_529] = [__v_8, __v_9]; let __cu = unconstrained; if let Some(result) = record.function_queries[529].get_mut(&__args[..]) { if !__cu && *result.multiplicity == G::ZERO { aiur_fn_529(__args, record, io_buffer, false)? } else { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_529] = unsafe { *(result.output.as_ptr() as *const [G; OUT_529]) }; __ret } } else { aiur_fn_529(__args, record, io_buffer, __cu)? } }; + let __r_arr: [G; OUT_525] = { let __args: [G; IN_525] = [__v_8, __v_9]; let __cu = unconstrained; if let Some(result) = record.function_queries[525].get_mut(&__args[..]) { if !__cu && *result.multiplicity == G::ZERO { aiur_fn_525(__args, record, io_buffer, false)? } else { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_525] = unsafe { *(result.output.as_ptr() as *const [G; OUT_525]) }; __ret } } else { aiur_fn_525(__args, record, io_buffer, __cu)? } }; let __v_10: G = __r_arr[0]; - let __ret: [G; OUT_545] = [__v_10]; - if let Some(result) = record.function_queries[545].get_mut(&inp[..]) { debug_assert_eq!(result.output, &__ret[..]); if !unconstrained { *result.multiplicity += G::ONE; } } else { record.function_queries[545].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained)); }; + let __ret: [G; OUT_541] = [__v_10]; + if let Some(result) = record.function_queries[541].get_mut(&inp[..]) { debug_assert_eq!(result.output, &__ret[..]); if !unconstrained { *result.multiplicity += G::ONE; } } else { record.function_queries[541].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained)); }; return Ok(__ret); }, _ => { @@ -47099,15 +46815,15 @@ fn aiur_fn_545( }) } -const INPUT_SIZE_546: usize = 3; -const IN_546: usize = 3; -const OUT_546: usize = 2; -fn aiur_fn_546( - inp: [G; IN_546], +const INPUT_SIZE_542: usize = 3; +const IN_542: usize = 3; +const OUT_542: usize = 2; +fn aiur_fn_542( + inp: [G; IN_542], record: &mut QueryRecord, io_buffer: &mut IOBuffer, unconstrained: bool, -) -> Result<[G; OUT_546], ExecError> { +) -> Result<[G; OUT_542], ExecError> { stacker::maybe_grow(64 * 1024, 4 * 1024 * 1024, || { let __v_0: G = inp[0]; let __v_1: G = inp[1]; @@ -47115,11 +46831,11 @@ fn aiur_fn_546( let __v_3: G = (__v_0 - __v_1); match __v_3.as_canonical_u64() { 0u64 => { - let __r_arr: [G; OUT_531] = { let __args: [G; IN_531] = []; let __cu = unconstrained; if let Some(result) = record.function_queries[531].get_mut(&__args[..]) { if !__cu && *result.multiplicity == G::ZERO { aiur_fn_531(__args, record, io_buffer, false)? } else { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_531] = unsafe { *(result.output.as_ptr() as *const [G; OUT_531]) }; __ret } } else { aiur_fn_531(__args, record, io_buffer, __cu)? } }; + let __r_arr: [G; OUT_527] = { let __args: [G; IN_527] = []; let __cu = unconstrained; if let Some(result) = record.function_queries[527].get_mut(&__args[..]) { if !__cu && *result.multiplicity == G::ZERO { aiur_fn_527(__args, record, io_buffer, false)? } else { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_527] = unsafe { *(result.output.as_ptr() as *const [G; OUT_527]) }; __ret } } else { aiur_fn_527(__args, record, io_buffer, __cu)? } }; let __v_4: G = __r_arr[0]; let __v_5: G = __r_arr[1]; - let __ret: [G; OUT_546] = [__v_4, __v_5]; - if let Some(result) = record.function_queries[546].get_mut(&inp[..]) { debug_assert_eq!(result.output, &__ret[..]); if !unconstrained { *result.multiplicity += G::ONE; } } else { record.function_queries[546].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained)); }; + let __ret: [G; OUT_542] = [__v_4, __v_5]; + if let Some(result) = record.function_queries[542].get_mut(&inp[..]) { debug_assert_eq!(result.output, &__ret[..]); if !unconstrained { *result.multiplicity += G::ONE; } } else { record.function_queries[542].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained)); }; return Ok(__ret); }, _ => { @@ -47133,26 +46849,26 @@ fn aiur_fn_546( let __v_9: G = __loaded[1]; let __v_10: G = __loaded[2]; let __v_11: G = __loaded[3]; - let __r_arr: [G; OUT_547] = { let __args: [G; IN_547] = [__v_4, __v_5, __v_6, __v_7, __v_8, __v_9, __v_10, __v_11, __v_2]; let __cu = unconstrained; if let Some(result) = record.function_queries[547].get_mut(&__args[..]) { if !__cu && *result.multiplicity == G::ZERO { aiur_fn_547(__args, record, io_buffer, false)? } else { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_547] = unsafe { *(result.output.as_ptr() as *const [G; OUT_547]) }; __ret } } else { aiur_fn_547(__args, record, io_buffer, __cu)? } }; + let __r_arr: [G; OUT_543] = { let __args: [G; IN_543] = [__v_4, __v_5, __v_6, __v_7, __v_8, __v_9, __v_10, __v_11, __v_2]; let __cu = unconstrained; if let Some(result) = record.function_queries[543].get_mut(&__args[..]) { if !__cu && *result.multiplicity == G::ZERO { aiur_fn_543(__args, record, io_buffer, false)? } else { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_543] = unsafe { *(result.output.as_ptr() as *const [G; OUT_543]) }; __ret } } else { aiur_fn_543(__args, record, io_buffer, __cu)? } }; let __v_12: G = __r_arr[0]; let __v_13: G = __r_arr[1]; - let __ret: [G; OUT_546] = [__v_12, __v_13]; - if let Some(result) = record.function_queries[546].get_mut(&inp[..]) { debug_assert_eq!(result.output, &__ret[..]); if !unconstrained { *result.multiplicity += G::ONE; } } else { record.function_queries[546].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained)); }; + let __ret: [G; OUT_542] = [__v_12, __v_13]; + if let Some(result) = record.function_queries[542].get_mut(&inp[..]) { debug_assert_eq!(result.output, &__ret[..]); if !unconstrained { *result.multiplicity += G::ONE; } } else { record.function_queries[542].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained)); }; return Ok(__ret); }, } }) } -const INPUT_SIZE_547: usize = 9; -const IN_547: usize = 9; -const OUT_547: usize = 2; -fn aiur_fn_547( - inp: [G; IN_547], +const INPUT_SIZE_543: usize = 9; +const IN_543: usize = 9; +const OUT_543: usize = 2; +fn aiur_fn_543( + inp: [G; IN_543], record: &mut QueryRecord, io_buffer: &mut IOBuffer, unconstrained: bool, -) -> Result<[G; OUT_547], ExecError> { +) -> Result<[G; OUT_543], ExecError> { stacker::maybe_grow(64 * 1024, 4 * 1024 * 1024, || { let __v_0: G = inp[0]; let __v_1: G = inp[1]; @@ -47167,21 +46883,21 @@ fn aiur_fn_547( 0u64 => { match __v_4.as_canonical_u64() { 0u64 => { - let __r_arr: [G; OUT_528] = { let __args: [G; IN_528] = [__v_1, __v_5]; let __cu = unconstrained; if let Some(result) = record.function_queries[528].get_mut(&__args[..]) { if !__cu && *result.multiplicity == G::ZERO { aiur_fn_528(__args, record, io_buffer, false)? } else { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_528] = unsafe { *(result.output.as_ptr() as *const [G; OUT_528]) }; __ret } } else { aiur_fn_528(__args, record, io_buffer, __cu)? } }; + let __r_arr: [G; OUT_524] = { let __args: [G; IN_524] = [__v_1, __v_5]; let __cu = unconstrained; if let Some(result) = record.function_queries[524].get_mut(&__args[..]) { if !__cu && *result.multiplicity == G::ZERO { aiur_fn_524(__args, record, io_buffer, false)? } else { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_524] = unsafe { *(result.output.as_ptr() as *const [G; OUT_524]) }; __ret } } else { aiur_fn_524(__args, record, io_buffer, __cu)? } }; let __v_9: G = __r_arr[0]; - let __r_arr: [G; OUT_534] = { let __args: [G; IN_534] = [__v_9]; let __cu = unconstrained; if let Some(result) = record.function_queries[534].get_mut(&__args[..]) { if !__cu && *result.multiplicity == G::ZERO { aiur_fn_534(__args, record, io_buffer, false)? } else { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_534] = unsafe { *(result.output.as_ptr() as *const [G; OUT_534]) }; __ret } } else { aiur_fn_534(__args, record, io_buffer, __cu)? } }; + let __r_arr: [G; OUT_530] = { let __args: [G; IN_530] = [__v_9]; let __cu = unconstrained; if let Some(result) = record.function_queries[530].get_mut(&__args[..]) { if !__cu && *result.multiplicity == G::ZERO { aiur_fn_530(__args, record, io_buffer, false)? } else { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_530] = unsafe { *(result.output.as_ptr() as *const [G; OUT_530]) }; __ret } } else { aiur_fn_530(__args, record, io_buffer, __cu)? } }; let __v_10: G = __r_arr[0]; let __v_11: G = __r_arr[1]; - let __ret: [G; OUT_547] = [__v_10, __v_11]; - if let Some(result) = record.function_queries[547].get_mut(&inp[..]) { debug_assert_eq!(result.output, &__ret[..]); if !unconstrained { *result.multiplicity += G::ONE; } } else { record.function_queries[547].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained)); }; + let __ret: [G; OUT_543] = [__v_10, __v_11]; + if let Some(result) = record.function_queries[543].get_mut(&inp[..]) { debug_assert_eq!(result.output, &__ret[..]); if !unconstrained { *result.multiplicity += G::ONE; } } else { record.function_queries[543].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained)); }; return Ok(__ret); }, _ => { - let __r_arr: [G; OUT_530] = { let __args: [G; IN_530] = []; let __cu = unconstrained; if let Some(result) = record.function_queries[530].get_mut(&__args[..]) { if !__cu && *result.multiplicity == G::ZERO { aiur_fn_530(__args, record, io_buffer, false)? } else { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_530] = unsafe { *(result.output.as_ptr() as *const [G; OUT_530]) }; __ret } } else { aiur_fn_530(__args, record, io_buffer, __cu)? } }; + let __r_arr: [G; OUT_526] = { let __args: [G; IN_526] = []; let __cu = unconstrained; if let Some(result) = record.function_queries[526].get_mut(&__args[..]) { if !__cu && *result.multiplicity == G::ZERO { aiur_fn_526(__args, record, io_buffer, false)? } else { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_526] = unsafe { *(result.output.as_ptr() as *const [G; OUT_526]) }; __ret } } else { aiur_fn_526(__args, record, io_buffer, __cu)? } }; let __v_9: G = __r_arr[0]; let __v_10: G = __r_arr[1]; - let __ret: [G; OUT_547] = [__v_9, __v_10]; - if let Some(result) = record.function_queries[547].get_mut(&inp[..]) { debug_assert_eq!(result.output, &__ret[..]); if !unconstrained { *result.multiplicity += G::ONE; } } else { record.function_queries[547].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained)); }; + let __ret: [G; OUT_543] = [__v_9, __v_10]; + if let Some(result) = record.function_queries[543].get_mut(&inp[..]) { debug_assert_eq!(result.output, &__ret[..]); if !unconstrained { *result.multiplicity += G::ONE; } } else { record.function_queries[543].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained)); }; return Ok(__ret); }, } @@ -47189,29 +46905,29 @@ fn aiur_fn_547( 1u64 => { match __v_4.as_canonical_u64() { 0u64 => { - let __r_arr: [G; OUT_532] = { let __args: [G; IN_532] = []; let __cu = unconstrained; if let Some(result) = record.function_queries[532].get_mut(&__args[..]) { if !__cu && *result.multiplicity == G::ZERO { aiur_fn_532(__args, record, io_buffer, false)? } else { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_532] = unsafe { *(result.output.as_ptr() as *const [G; OUT_532]) }; __ret } } else { aiur_fn_532(__args, record, io_buffer, __cu)? } }; + let __r_arr: [G; OUT_528] = { let __args: [G; IN_528] = []; let __cu = unconstrained; if let Some(result) = record.function_queries[528].get_mut(&__args[..]) { if !__cu && *result.multiplicity == G::ZERO { aiur_fn_528(__args, record, io_buffer, false)? } else { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_528] = unsafe { *(result.output.as_ptr() as *const [G; OUT_528]) }; __ret } } else { aiur_fn_528(__args, record, io_buffer, __cu)? } }; let __v_9: G = __r_arr[0]; let __v_10: G = __r_arr[1]; - let __ret: [G; OUT_547] = [__v_9, __v_10]; - if let Some(result) = record.function_queries[547].get_mut(&inp[..]) { debug_assert_eq!(result.output, &__ret[..]); if !unconstrained { *result.multiplicity += G::ONE; } } else { record.function_queries[547].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained)); }; + let __ret: [G; OUT_543] = [__v_9, __v_10]; + if let Some(result) = record.function_queries[543].get_mut(&inp[..]) { debug_assert_eq!(result.output, &__ret[..]); if !unconstrained { *result.multiplicity += G::ONE; } } else { record.function_queries[543].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained)); }; return Ok(__ret); }, 1u64 => { - let __r_arr: [G; OUT_539] = { let __args: [G; IN_539] = [__v_1, __v_5]; let __cu = unconstrained; if let Some(result) = record.function_queries[539].get_mut(&__args[..]) { if !__cu && *result.multiplicity == G::ZERO { aiur_fn_539(__args, record, io_buffer, false)? } else { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_539] = unsafe { *(result.output.as_ptr() as *const [G; OUT_539]) }; __ret } } else { aiur_fn_539(__args, record, io_buffer, __cu)? } }; + let __r_arr: [G; OUT_535] = { let __args: [G; IN_535] = [__v_1, __v_5]; let __cu = unconstrained; if let Some(result) = record.function_queries[535].get_mut(&__args[..]) { if !__cu && *result.multiplicity == G::ZERO { aiur_fn_535(__args, record, io_buffer, false)? } else { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_535] = unsafe { *(result.output.as_ptr() as *const [G; OUT_535]) }; __ret } } else { aiur_fn_535(__args, record, io_buffer, __cu)? } }; let __v_9: G = __r_arr[0]; - let __r_arr: [G; OUT_534] = { let __args: [G; IN_534] = [__v_9]; let __cu = unconstrained; if let Some(result) = record.function_queries[534].get_mut(&__args[..]) { if !__cu && *result.multiplicity == G::ZERO { aiur_fn_534(__args, record, io_buffer, false)? } else { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_534] = unsafe { *(result.output.as_ptr() as *const [G; OUT_534]) }; __ret } } else { aiur_fn_534(__args, record, io_buffer, __cu)? } }; + let __r_arr: [G; OUT_530] = { let __args: [G; IN_530] = [__v_9]; let __cu = unconstrained; if let Some(result) = record.function_queries[530].get_mut(&__args[..]) { if !__cu && *result.multiplicity == G::ZERO { aiur_fn_530(__args, record, io_buffer, false)? } else { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_530] = unsafe { *(result.output.as_ptr() as *const [G; OUT_530]) }; __ret } } else { aiur_fn_530(__args, record, io_buffer, __cu)? } }; let __v_10: G = __r_arr[0]; let __v_11: G = __r_arr[1]; - let __ret: [G; OUT_547] = [__v_10, __v_11]; - if let Some(result) = record.function_queries[547].get_mut(&inp[..]) { debug_assert_eq!(result.output, &__ret[..]); if !unconstrained { *result.multiplicity += G::ONE; } } else { record.function_queries[547].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained)); }; + let __ret: [G; OUT_543] = [__v_10, __v_11]; + if let Some(result) = record.function_queries[543].get_mut(&inp[..]) { debug_assert_eq!(result.output, &__ret[..]); if !unconstrained { *result.multiplicity += G::ONE; } } else { record.function_queries[543].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained)); }; return Ok(__ret); }, _ => { - let __r_arr: [G; OUT_530] = { let __args: [G; IN_530] = []; let __cu = unconstrained; if let Some(result) = record.function_queries[530].get_mut(&__args[..]) { if !__cu && *result.multiplicity == G::ZERO { aiur_fn_530(__args, record, io_buffer, false)? } else { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_530] = unsafe { *(result.output.as_ptr() as *const [G; OUT_530]) }; __ret } } else { aiur_fn_530(__args, record, io_buffer, __cu)? } }; + let __r_arr: [G; OUT_526] = { let __args: [G; IN_526] = []; let __cu = unconstrained; if let Some(result) = record.function_queries[526].get_mut(&__args[..]) { if !__cu && *result.multiplicity == G::ZERO { aiur_fn_526(__args, record, io_buffer, false)? } else { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_526] = unsafe { *(result.output.as_ptr() as *const [G; OUT_526]) }; __ret } } else { aiur_fn_526(__args, record, io_buffer, __cu)? } }; let __v_9: G = __r_arr[0]; let __v_10: G = __r_arr[1]; - let __ret: [G; OUT_547] = [__v_9, __v_10]; - if let Some(result) = record.function_queries[547].get_mut(&inp[..]) { debug_assert_eq!(result.output, &__ret[..]); if !unconstrained { *result.multiplicity += G::ONE; } } else { record.function_queries[547].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained)); }; + let __ret: [G; OUT_543] = [__v_9, __v_10]; + if let Some(result) = record.function_queries[543].get_mut(&inp[..]) { debug_assert_eq!(result.output, &__ret[..]); if !unconstrained { *result.multiplicity += G::ONE; } } else { record.function_queries[543].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained)); }; return Ok(__ret); }, } @@ -47219,43 +46935,43 @@ fn aiur_fn_547( 2u64 => { match __v_4.as_canonical_u64() { 0u64 => { - let __r_arr: [G; OUT_532] = { let __args: [G; IN_532] = []; let __cu = unconstrained; if let Some(result) = record.function_queries[532].get_mut(&__args[..]) { if !__cu && *result.multiplicity == G::ZERO { aiur_fn_532(__args, record, io_buffer, false)? } else { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_532] = unsafe { *(result.output.as_ptr() as *const [G; OUT_532]) }; __ret } } else { aiur_fn_532(__args, record, io_buffer, __cu)? } }; + let __r_arr: [G; OUT_528] = { let __args: [G; IN_528] = []; let __cu = unconstrained; if let Some(result) = record.function_queries[528].get_mut(&__args[..]) { if !__cu && *result.multiplicity == G::ZERO { aiur_fn_528(__args, record, io_buffer, false)? } else { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_528] = unsafe { *(result.output.as_ptr() as *const [G; OUT_528]) }; __ret } } else { aiur_fn_528(__args, record, io_buffer, __cu)? } }; let __v_9: G = __r_arr[0]; let __v_10: G = __r_arr[1]; - let __ret: [G; OUT_547] = [__v_9, __v_10]; - if let Some(result) = record.function_queries[547].get_mut(&inp[..]) { debug_assert_eq!(result.output, &__ret[..]); if !unconstrained { *result.multiplicity += G::ONE; } } else { record.function_queries[547].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained)); }; + let __ret: [G; OUT_543] = [__v_9, __v_10]; + if let Some(result) = record.function_queries[543].get_mut(&inp[..]) { debug_assert_eq!(result.output, &__ret[..]); if !unconstrained { *result.multiplicity += G::ONE; } } else { record.function_queries[543].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained)); }; return Ok(__ret); }, 1u64 => { - let __r_arr: [G; OUT_532] = { let __args: [G; IN_532] = []; let __cu = unconstrained; if let Some(result) = record.function_queries[532].get_mut(&__args[..]) { if !__cu && *result.multiplicity == G::ZERO { aiur_fn_532(__args, record, io_buffer, false)? } else { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_532] = unsafe { *(result.output.as_ptr() as *const [G; OUT_532]) }; __ret } } else { aiur_fn_532(__args, record, io_buffer, __cu)? } }; + let __r_arr: [G; OUT_528] = { let __args: [G; IN_528] = []; let __cu = unconstrained; if let Some(result) = record.function_queries[528].get_mut(&__args[..]) { if !__cu && *result.multiplicity == G::ZERO { aiur_fn_528(__args, record, io_buffer, false)? } else { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_528] = unsafe { *(result.output.as_ptr() as *const [G; OUT_528]) }; __ret } } else { aiur_fn_528(__args, record, io_buffer, __cu)? } }; let __v_9: G = __r_arr[0]; let __v_10: G = __r_arr[1]; - let __ret: [G; OUT_547] = [__v_9, __v_10]; - if let Some(result) = record.function_queries[547].get_mut(&inp[..]) { debug_assert_eq!(result.output, &__ret[..]); if !unconstrained { *result.multiplicity += G::ONE; } } else { record.function_queries[547].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained)); }; + let __ret: [G; OUT_543] = [__v_9, __v_10]; + if let Some(result) = record.function_queries[543].get_mut(&inp[..]) { debug_assert_eq!(result.output, &__ret[..]); if !unconstrained { *result.multiplicity += G::ONE; } } else { record.function_queries[543].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained)); }; return Ok(__ret); }, 2u64 => { - let __r_arr: [G; OUT_540] = { let __args: [G; IN_540] = [__v_2, __v_6]; let __cu = unconstrained; if let Some(result) = record.function_queries[540].get_mut(&__args[..]) { if !__cu && *result.multiplicity == G::ZERO { aiur_fn_540(__args, record, io_buffer, false)? } else { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_540] = unsafe { *(result.output.as_ptr() as *const [G; OUT_540]) }; __ret } } else { aiur_fn_540(__args, record, io_buffer, __cu)? } }; + let __r_arr: [G; OUT_536] = { let __args: [G; IN_536] = [__v_2, __v_6]; let __cu = unconstrained; if let Some(result) = record.function_queries[536].get_mut(&__args[..]) { if !__cu && *result.multiplicity == G::ZERO { aiur_fn_536(__args, record, io_buffer, false)? } else { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_536] = unsafe { *(result.output.as_ptr() as *const [G; OUT_536]) }; __ret } } else { aiur_fn_536(__args, record, io_buffer, __cu)? } }; let __v_9: G = __r_arr[0]; - let __r_arr: [G; OUT_534] = { let __args: [G; IN_534] = [__v_9]; let __cu = unconstrained; if let Some(result) = record.function_queries[534].get_mut(&__args[..]) { if !__cu && *result.multiplicity == G::ZERO { aiur_fn_534(__args, record, io_buffer, false)? } else { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_534] = unsafe { *(result.output.as_ptr() as *const [G; OUT_534]) }; __ret } } else { aiur_fn_534(__args, record, io_buffer, __cu)? } }; + let __r_arr: [G; OUT_530] = { let __args: [G; IN_530] = [__v_9]; let __cu = unconstrained; if let Some(result) = record.function_queries[530].get_mut(&__args[..]) { if !__cu && *result.multiplicity == G::ZERO { aiur_fn_530(__args, record, io_buffer, false)? } else { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_530] = unsafe { *(result.output.as_ptr() as *const [G; OUT_530]) }; __ret } } else { aiur_fn_530(__args, record, io_buffer, __cu)? } }; let __v_10: G = __r_arr[0]; let __v_11: G = __r_arr[1]; - let __r_arr: [G; OUT_538] = { let __args: [G; IN_538] = [__v_1, __v_5, __v_8]; let __cu = unconstrained; if let Some(result) = record.function_queries[538].get_mut(&__args[..]) { if !__cu && *result.multiplicity == G::ZERO { aiur_fn_538(__args, record, io_buffer, false)? } else { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_538] = unsafe { *(result.output.as_ptr() as *const [G; OUT_538]) }; __ret } } else { aiur_fn_538(__args, record, io_buffer, __cu)? } }; + let __r_arr: [G; OUT_534] = { let __args: [G; IN_534] = [__v_1, __v_5, __v_8]; let __cu = unconstrained; if let Some(result) = record.function_queries[534].get_mut(&__args[..]) { if !__cu && *result.multiplicity == G::ZERO { aiur_fn_534(__args, record, io_buffer, false)? } else { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_534] = unsafe { *(result.output.as_ptr() as *const [G; OUT_534]) }; __ret } } else { aiur_fn_534(__args, record, io_buffer, __cu)? } }; let __v_12: G = __r_arr[0]; let __v_13: G = __r_arr[1]; - let __r_arr: [G; OUT_533] = { let __args: [G; IN_533] = [__v_10, __v_11, __v_12, __v_13]; let __cu = unconstrained; if let Some(result) = record.function_queries[533].get_mut(&__args[..]) { if !__cu && *result.multiplicity == G::ZERO { aiur_fn_533(__args, record, io_buffer, false)? } else { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_533] = unsafe { *(result.output.as_ptr() as *const [G; OUT_533]) }; __ret } } else { aiur_fn_533(__args, record, io_buffer, __cu)? } }; + let __r_arr: [G; OUT_529] = { let __args: [G; IN_529] = [__v_10, __v_11, __v_12, __v_13]; let __cu = unconstrained; if let Some(result) = record.function_queries[529].get_mut(&__args[..]) { if !__cu && *result.multiplicity == G::ZERO { aiur_fn_529(__args, record, io_buffer, false)? } else { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_529] = unsafe { *(result.output.as_ptr() as *const [G; OUT_529]) }; __ret } } else { aiur_fn_529(__args, record, io_buffer, __cu)? } }; let __v_14: G = __r_arr[0]; let __v_15: G = __r_arr[1]; - let __ret: [G; OUT_547] = [__v_14, __v_15]; - if let Some(result) = record.function_queries[547].get_mut(&inp[..]) { debug_assert_eq!(result.output, &__ret[..]); if !unconstrained { *result.multiplicity += G::ONE; } } else { record.function_queries[547].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained)); }; + let __ret: [G; OUT_543] = [__v_14, __v_15]; + if let Some(result) = record.function_queries[543].get_mut(&inp[..]) { debug_assert_eq!(result.output, &__ret[..]); if !unconstrained { *result.multiplicity += G::ONE; } } else { record.function_queries[543].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained)); }; return Ok(__ret); }, _ => { - let __r_arr: [G; OUT_530] = { let __args: [G; IN_530] = []; let __cu = unconstrained; if let Some(result) = record.function_queries[530].get_mut(&__args[..]) { if !__cu && *result.multiplicity == G::ZERO { aiur_fn_530(__args, record, io_buffer, false)? } else { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_530] = unsafe { *(result.output.as_ptr() as *const [G; OUT_530]) }; __ret } } else { aiur_fn_530(__args, record, io_buffer, __cu)? } }; + let __r_arr: [G; OUT_526] = { let __args: [G; IN_526] = []; let __cu = unconstrained; if let Some(result) = record.function_queries[526].get_mut(&__args[..]) { if !__cu && *result.multiplicity == G::ZERO { aiur_fn_526(__args, record, io_buffer, false)? } else { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_526] = unsafe { *(result.output.as_ptr() as *const [G; OUT_526]) }; __ret } } else { aiur_fn_526(__args, record, io_buffer, __cu)? } }; let __v_9: G = __r_arr[0]; let __v_10: G = __r_arr[1]; - let __ret: [G; OUT_547] = [__v_9, __v_10]; - if let Some(result) = record.function_queries[547].get_mut(&inp[..]) { debug_assert_eq!(result.output, &__ret[..]); if !unconstrained { *result.multiplicity += G::ONE; } } else { record.function_queries[547].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained)); }; + let __ret: [G; OUT_543] = [__v_9, __v_10]; + if let Some(result) = record.function_queries[543].get_mut(&inp[..]) { debug_assert_eq!(result.output, &__ret[..]); if !unconstrained { *result.multiplicity += G::ONE; } } else { record.function_queries[543].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained)); }; return Ok(__ret); }, } @@ -47263,49 +46979,49 @@ fn aiur_fn_547( 3u64 => { match __v_4.as_canonical_u64() { 0u64 => { - let __r_arr: [G; OUT_532] = { let __args: [G; IN_532] = []; let __cu = unconstrained; if let Some(result) = record.function_queries[532].get_mut(&__args[..]) { if !__cu && *result.multiplicity == G::ZERO { aiur_fn_532(__args, record, io_buffer, false)? } else { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_532] = unsafe { *(result.output.as_ptr() as *const [G; OUT_532]) }; __ret } } else { aiur_fn_532(__args, record, io_buffer, __cu)? } }; + let __r_arr: [G; OUT_528] = { let __args: [G; IN_528] = []; let __cu = unconstrained; if let Some(result) = record.function_queries[528].get_mut(&__args[..]) { if !__cu && *result.multiplicity == G::ZERO { aiur_fn_528(__args, record, io_buffer, false)? } else { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_528] = unsafe { *(result.output.as_ptr() as *const [G; OUT_528]) }; __ret } } else { aiur_fn_528(__args, record, io_buffer, __cu)? } }; let __v_9: G = __r_arr[0]; let __v_10: G = __r_arr[1]; - let __ret: [G; OUT_547] = [__v_9, __v_10]; - if let Some(result) = record.function_queries[547].get_mut(&inp[..]) { debug_assert_eq!(result.output, &__ret[..]); if !unconstrained { *result.multiplicity += G::ONE; } } else { record.function_queries[547].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained)); }; + let __ret: [G; OUT_543] = [__v_9, __v_10]; + if let Some(result) = record.function_queries[543].get_mut(&inp[..]) { debug_assert_eq!(result.output, &__ret[..]); if !unconstrained { *result.multiplicity += G::ONE; } } else { record.function_queries[543].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained)); }; return Ok(__ret); }, 1u64 => { - let __r_arr: [G; OUT_532] = { let __args: [G; IN_532] = []; let __cu = unconstrained; if let Some(result) = record.function_queries[532].get_mut(&__args[..]) { if !__cu && *result.multiplicity == G::ZERO { aiur_fn_532(__args, record, io_buffer, false)? } else { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_532] = unsafe { *(result.output.as_ptr() as *const [G; OUT_532]) }; __ret } } else { aiur_fn_532(__args, record, io_buffer, __cu)? } }; + let __r_arr: [G; OUT_528] = { let __args: [G; IN_528] = []; let __cu = unconstrained; if let Some(result) = record.function_queries[528].get_mut(&__args[..]) { if !__cu && *result.multiplicity == G::ZERO { aiur_fn_528(__args, record, io_buffer, false)? } else { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_528] = unsafe { *(result.output.as_ptr() as *const [G; OUT_528]) }; __ret } } else { aiur_fn_528(__args, record, io_buffer, __cu)? } }; let __v_9: G = __r_arr[0]; let __v_10: G = __r_arr[1]; - let __ret: [G; OUT_547] = [__v_9, __v_10]; - if let Some(result) = record.function_queries[547].get_mut(&inp[..]) { debug_assert_eq!(result.output, &__ret[..]); if !unconstrained { *result.multiplicity += G::ONE; } } else { record.function_queries[547].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained)); }; + let __ret: [G; OUT_543] = [__v_9, __v_10]; + if let Some(result) = record.function_queries[543].get_mut(&inp[..]) { debug_assert_eq!(result.output, &__ret[..]); if !unconstrained { *result.multiplicity += G::ONE; } } else { record.function_queries[543].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained)); }; return Ok(__ret); }, 2u64 => { - let __r_arr: [G; OUT_532] = { let __args: [G; IN_532] = []; let __cu = unconstrained; if let Some(result) = record.function_queries[532].get_mut(&__args[..]) { if !__cu && *result.multiplicity == G::ZERO { aiur_fn_532(__args, record, io_buffer, false)? } else { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_532] = unsafe { *(result.output.as_ptr() as *const [G; OUT_532]) }; __ret } } else { aiur_fn_532(__args, record, io_buffer, __cu)? } }; + let __r_arr: [G; OUT_528] = { let __args: [G; IN_528] = []; let __cu = unconstrained; if let Some(result) = record.function_queries[528].get_mut(&__args[..]) { if !__cu && *result.multiplicity == G::ZERO { aiur_fn_528(__args, record, io_buffer, false)? } else { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_528] = unsafe { *(result.output.as_ptr() as *const [G; OUT_528]) }; __ret } } else { aiur_fn_528(__args, record, io_buffer, __cu)? } }; let __v_9: G = __r_arr[0]; let __v_10: G = __r_arr[1]; - let __ret: [G; OUT_547] = [__v_9, __v_10]; - if let Some(result) = record.function_queries[547].get_mut(&inp[..]) { debug_assert_eq!(result.output, &__ret[..]); if !unconstrained { *result.multiplicity += G::ONE; } } else { record.function_queries[547].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained)); }; + let __ret: [G; OUT_543] = [__v_9, __v_10]; + if let Some(result) = record.function_queries[543].get_mut(&inp[..]) { debug_assert_eq!(result.output, &__ret[..]); if !unconstrained { *result.multiplicity += G::ONE; } } else { record.function_queries[543].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained)); }; return Ok(__ret); }, 3u64 => { - let __r_arr: [G; OUT_546] = { let __args: [G; IN_546] = [__v_1, __v_5, __v_8]; let __cu = unconstrained; if let Some(result) = record.function_queries[546].get_mut(&__args[..]) { if !__cu && *result.multiplicity == G::ZERO { aiur_fn_546(__args, record, io_buffer, false)? } else { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_546] = unsafe { *(result.output.as_ptr() as *const [G; OUT_546]) }; __ret } } else { aiur_fn_546(__args, record, io_buffer, __cu)? } }; + let __r_arr: [G; OUT_542] = { let __args: [G; IN_542] = [__v_1, __v_5, __v_8]; let __cu = unconstrained; if let Some(result) = record.function_queries[542].get_mut(&__args[..]) { if !__cu && *result.multiplicity == G::ZERO { aiur_fn_542(__args, record, io_buffer, false)? } else { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_542] = unsafe { *(result.output.as_ptr() as *const [G; OUT_542]) }; __ret } } else { aiur_fn_542(__args, record, io_buffer, __cu)? } }; let __v_9: G = __r_arr[0]; let __v_10: G = __r_arr[1]; - let __r_arr: [G; OUT_546] = { let __args: [G; IN_546] = [__v_2, __v_6, __v_8]; let __cu = unconstrained; if let Some(result) = record.function_queries[546].get_mut(&__args[..]) { if !__cu && *result.multiplicity == G::ZERO { aiur_fn_546(__args, record, io_buffer, false)? } else { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_546] = unsafe { *(result.output.as_ptr() as *const [G; OUT_546]) }; __ret } } else { aiur_fn_546(__args, record, io_buffer, __cu)? } }; + let __r_arr: [G; OUT_542] = { let __args: [G; IN_542] = [__v_2, __v_6, __v_8]; let __cu = unconstrained; if let Some(result) = record.function_queries[542].get_mut(&__args[..]) { if !__cu && *result.multiplicity == G::ZERO { aiur_fn_542(__args, record, io_buffer, false)? } else { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_542] = unsafe { *(result.output.as_ptr() as *const [G; OUT_542]) }; __ret } } else { aiur_fn_542(__args, record, io_buffer, __cu)? } }; let __v_11: G = __r_arr[0]; let __v_12: G = __r_arr[1]; - let __r_arr: [G; OUT_533] = { let __args: [G; IN_533] = [__v_9, __v_10, __v_11, __v_12]; let __cu = unconstrained; if let Some(result) = record.function_queries[533].get_mut(&__args[..]) { if !__cu && *result.multiplicity == G::ZERO { aiur_fn_533(__args, record, io_buffer, false)? } else { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_533] = unsafe { *(result.output.as_ptr() as *const [G; OUT_533]) }; __ret } } else { aiur_fn_533(__args, record, io_buffer, __cu)? } }; + let __r_arr: [G; OUT_529] = { let __args: [G; IN_529] = [__v_9, __v_10, __v_11, __v_12]; let __cu = unconstrained; if let Some(result) = record.function_queries[529].get_mut(&__args[..]) { if !__cu && *result.multiplicity == G::ZERO { aiur_fn_529(__args, record, io_buffer, false)? } else { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_529] = unsafe { *(result.output.as_ptr() as *const [G; OUT_529]) }; __ret } } else { aiur_fn_529(__args, record, io_buffer, __cu)? } }; let __v_13: G = __r_arr[0]; let __v_14: G = __r_arr[1]; - let __ret: [G; OUT_547] = [__v_13, __v_14]; - if let Some(result) = record.function_queries[547].get_mut(&inp[..]) { debug_assert_eq!(result.output, &__ret[..]); if !unconstrained { *result.multiplicity += G::ONE; } } else { record.function_queries[547].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained)); }; + let __ret: [G; OUT_543] = [__v_13, __v_14]; + if let Some(result) = record.function_queries[543].get_mut(&inp[..]) { debug_assert_eq!(result.output, &__ret[..]); if !unconstrained { *result.multiplicity += G::ONE; } } else { record.function_queries[543].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained)); }; return Ok(__ret); }, _ => { - let __r_arr: [G; OUT_530] = { let __args: [G; IN_530] = []; let __cu = unconstrained; if let Some(result) = record.function_queries[530].get_mut(&__args[..]) { if !__cu && *result.multiplicity == G::ZERO { aiur_fn_530(__args, record, io_buffer, false)? } else { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_530] = unsafe { *(result.output.as_ptr() as *const [G; OUT_530]) }; __ret } } else { aiur_fn_530(__args, record, io_buffer, __cu)? } }; + let __r_arr: [G; OUT_526] = { let __args: [G; IN_526] = []; let __cu = unconstrained; if let Some(result) = record.function_queries[526].get_mut(&__args[..]) { if !__cu && *result.multiplicity == G::ZERO { aiur_fn_526(__args, record, io_buffer, false)? } else { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_526] = unsafe { *(result.output.as_ptr() as *const [G; OUT_526]) }; __ret } } else { aiur_fn_526(__args, record, io_buffer, __cu)? } }; let __v_9: G = __r_arr[0]; let __v_10: G = __r_arr[1]; - let __ret: [G; OUT_547] = [__v_9, __v_10]; - if let Some(result) = record.function_queries[547].get_mut(&inp[..]) { debug_assert_eq!(result.output, &__ret[..]); if !unconstrained { *result.multiplicity += G::ONE; } } else { record.function_queries[547].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained)); }; + let __ret: [G; OUT_543] = [__v_9, __v_10]; + if let Some(result) = record.function_queries[543].get_mut(&inp[..]) { debug_assert_eq!(result.output, &__ret[..]); if !unconstrained { *result.multiplicity += G::ONE; } } else { record.function_queries[543].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained)); }; return Ok(__ret); }, } @@ -47313,57 +47029,57 @@ fn aiur_fn_547( 4u64 => { match __v_4.as_canonical_u64() { 0u64 => { - let __r_arr: [G; OUT_532] = { let __args: [G; IN_532] = []; let __cu = unconstrained; if let Some(result) = record.function_queries[532].get_mut(&__args[..]) { if !__cu && *result.multiplicity == G::ZERO { aiur_fn_532(__args, record, io_buffer, false)? } else { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_532] = unsafe { *(result.output.as_ptr() as *const [G; OUT_532]) }; __ret } } else { aiur_fn_532(__args, record, io_buffer, __cu)? } }; + let __r_arr: [G; OUT_528] = { let __args: [G; IN_528] = []; let __cu = unconstrained; if let Some(result) = record.function_queries[528].get_mut(&__args[..]) { if !__cu && *result.multiplicity == G::ZERO { aiur_fn_528(__args, record, io_buffer, false)? } else { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_528] = unsafe { *(result.output.as_ptr() as *const [G; OUT_528]) }; __ret } } else { aiur_fn_528(__args, record, io_buffer, __cu)? } }; let __v_9: G = __r_arr[0]; let __v_10: G = __r_arr[1]; - let __ret: [G; OUT_547] = [__v_9, __v_10]; - if let Some(result) = record.function_queries[547].get_mut(&inp[..]) { debug_assert_eq!(result.output, &__ret[..]); if !unconstrained { *result.multiplicity += G::ONE; } } else { record.function_queries[547].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained)); }; + let __ret: [G; OUT_543] = [__v_9, __v_10]; + if let Some(result) = record.function_queries[543].get_mut(&inp[..]) { debug_assert_eq!(result.output, &__ret[..]); if !unconstrained { *result.multiplicity += G::ONE; } } else { record.function_queries[543].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained)); }; return Ok(__ret); }, 1u64 => { - let __r_arr: [G; OUT_532] = { let __args: [G; IN_532] = []; let __cu = unconstrained; if let Some(result) = record.function_queries[532].get_mut(&__args[..]) { if !__cu && *result.multiplicity == G::ZERO { aiur_fn_532(__args, record, io_buffer, false)? } else { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_532] = unsafe { *(result.output.as_ptr() as *const [G; OUT_532]) }; __ret } } else { aiur_fn_532(__args, record, io_buffer, __cu)? } }; + let __r_arr: [G; OUT_528] = { let __args: [G; IN_528] = []; let __cu = unconstrained; if let Some(result) = record.function_queries[528].get_mut(&__args[..]) { if !__cu && *result.multiplicity == G::ZERO { aiur_fn_528(__args, record, io_buffer, false)? } else { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_528] = unsafe { *(result.output.as_ptr() as *const [G; OUT_528]) }; __ret } } else { aiur_fn_528(__args, record, io_buffer, __cu)? } }; let __v_9: G = __r_arr[0]; let __v_10: G = __r_arr[1]; - let __ret: [G; OUT_547] = [__v_9, __v_10]; - if let Some(result) = record.function_queries[547].get_mut(&inp[..]) { debug_assert_eq!(result.output, &__ret[..]); if !unconstrained { *result.multiplicity += G::ONE; } } else { record.function_queries[547].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained)); }; + let __ret: [G; OUT_543] = [__v_9, __v_10]; + if let Some(result) = record.function_queries[543].get_mut(&inp[..]) { debug_assert_eq!(result.output, &__ret[..]); if !unconstrained { *result.multiplicity += G::ONE; } } else { record.function_queries[543].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained)); }; return Ok(__ret); }, 2u64 => { - let __r_arr: [G; OUT_532] = { let __args: [G; IN_532] = []; let __cu = unconstrained; if let Some(result) = record.function_queries[532].get_mut(&__args[..]) { if !__cu && *result.multiplicity == G::ZERO { aiur_fn_532(__args, record, io_buffer, false)? } else { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_532] = unsafe { *(result.output.as_ptr() as *const [G; OUT_532]) }; __ret } } else { aiur_fn_532(__args, record, io_buffer, __cu)? } }; + let __r_arr: [G; OUT_528] = { let __args: [G; IN_528] = []; let __cu = unconstrained; if let Some(result) = record.function_queries[528].get_mut(&__args[..]) { if !__cu && *result.multiplicity == G::ZERO { aiur_fn_528(__args, record, io_buffer, false)? } else { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_528] = unsafe { *(result.output.as_ptr() as *const [G; OUT_528]) }; __ret } } else { aiur_fn_528(__args, record, io_buffer, __cu)? } }; let __v_9: G = __r_arr[0]; let __v_10: G = __r_arr[1]; - let __ret: [G; OUT_547] = [__v_9, __v_10]; - if let Some(result) = record.function_queries[547].get_mut(&inp[..]) { debug_assert_eq!(result.output, &__ret[..]); if !unconstrained { *result.multiplicity += G::ONE; } } else { record.function_queries[547].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained)); }; + let __ret: [G; OUT_543] = [__v_9, __v_10]; + if let Some(result) = record.function_queries[543].get_mut(&inp[..]) { debug_assert_eq!(result.output, &__ret[..]); if !unconstrained { *result.multiplicity += G::ONE; } } else { record.function_queries[543].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained)); }; return Ok(__ret); }, 3u64 => { - let __r_arr: [G; OUT_532] = { let __args: [G; IN_532] = []; let __cu = unconstrained; if let Some(result) = record.function_queries[532].get_mut(&__args[..]) { if !__cu && *result.multiplicity == G::ZERO { aiur_fn_532(__args, record, io_buffer, false)? } else { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_532] = unsafe { *(result.output.as_ptr() as *const [G; OUT_532]) }; __ret } } else { aiur_fn_532(__args, record, io_buffer, __cu)? } }; + let __r_arr: [G; OUT_528] = { let __args: [G; IN_528] = []; let __cu = unconstrained; if let Some(result) = record.function_queries[528].get_mut(&__args[..]) { if !__cu && *result.multiplicity == G::ZERO { aiur_fn_528(__args, record, io_buffer, false)? } else { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_528] = unsafe { *(result.output.as_ptr() as *const [G; OUT_528]) }; __ret } } else { aiur_fn_528(__args, record, io_buffer, __cu)? } }; let __v_9: G = __r_arr[0]; let __v_10: G = __r_arr[1]; - let __ret: [G; OUT_547] = [__v_9, __v_10]; - if let Some(result) = record.function_queries[547].get_mut(&inp[..]) { debug_assert_eq!(result.output, &__ret[..]); if !unconstrained { *result.multiplicity += G::ONE; } } else { record.function_queries[547].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained)); }; + let __ret: [G; OUT_543] = [__v_9, __v_10]; + if let Some(result) = record.function_queries[543].get_mut(&inp[..]) { debug_assert_eq!(result.output, &__ret[..]); if !unconstrained { *result.multiplicity += G::ONE; } } else { record.function_queries[543].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained)); }; return Ok(__ret); }, 4u64 => { - let __r_arr: [G; OUT_546] = { let __args: [G; IN_546] = [__v_1, __v_5, __v_8]; let __cu = unconstrained; if let Some(result) = record.function_queries[546].get_mut(&__args[..]) { if !__cu && *result.multiplicity == G::ZERO { aiur_fn_546(__args, record, io_buffer, false)? } else { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_546] = unsafe { *(result.output.as_ptr() as *const [G; OUT_546]) }; __ret } } else { aiur_fn_546(__args, record, io_buffer, __cu)? } }; + let __r_arr: [G; OUT_542] = { let __args: [G; IN_542] = [__v_1, __v_5, __v_8]; let __cu = unconstrained; if let Some(result) = record.function_queries[542].get_mut(&__args[..]) { if !__cu && *result.multiplicity == G::ZERO { aiur_fn_542(__args, record, io_buffer, false)? } else { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_542] = unsafe { *(result.output.as_ptr() as *const [G; OUT_542]) }; __ret } } else { aiur_fn_542(__args, record, io_buffer, __cu)? } }; let __v_9: G = __r_arr[0]; let __v_10: G = __r_arr[1]; - let __r_arr: [G; OUT_546] = { let __args: [G; IN_546] = [__v_2, __v_6, __v_8]; let __cu = unconstrained; if let Some(result) = record.function_queries[546].get_mut(&__args[..]) { if !__cu && *result.multiplicity == G::ZERO { aiur_fn_546(__args, record, io_buffer, false)? } else { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_546] = unsafe { *(result.output.as_ptr() as *const [G; OUT_546]) }; __ret } } else { aiur_fn_546(__args, record, io_buffer, __cu)? } }; + let __r_arr: [G; OUT_542] = { let __args: [G; IN_542] = [__v_2, __v_6, __v_8]; let __cu = unconstrained; if let Some(result) = record.function_queries[542].get_mut(&__args[..]) { if !__cu && *result.multiplicity == G::ZERO { aiur_fn_542(__args, record, io_buffer, false)? } else { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_542] = unsafe { *(result.output.as_ptr() as *const [G; OUT_542]) }; __ret } } else { aiur_fn_542(__args, record, io_buffer, __cu)? } }; let __v_11: G = __r_arr[0]; let __v_12: G = __r_arr[1]; - let __r_arr: [G; OUT_533] = { let __args: [G; IN_533] = [__v_9, __v_10, __v_11, __v_12]; let __cu = unconstrained; if let Some(result) = record.function_queries[533].get_mut(&__args[..]) { if !__cu && *result.multiplicity == G::ZERO { aiur_fn_533(__args, record, io_buffer, false)? } else { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_533] = unsafe { *(result.output.as_ptr() as *const [G; OUT_533]) }; __ret } } else { aiur_fn_533(__args, record, io_buffer, __cu)? } }; + let __r_arr: [G; OUT_529] = { let __args: [G; IN_529] = [__v_9, __v_10, __v_11, __v_12]; let __cu = unconstrained; if let Some(result) = record.function_queries[529].get_mut(&__args[..]) { if !__cu && *result.multiplicity == G::ZERO { aiur_fn_529(__args, record, io_buffer, false)? } else { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_529] = unsafe { *(result.output.as_ptr() as *const [G; OUT_529]) }; __ret } } else { aiur_fn_529(__args, record, io_buffer, __cu)? } }; let __v_13: G = __r_arr[0]; let __v_14: G = __r_arr[1]; - let __ret: [G; OUT_547] = [__v_13, __v_14]; - if let Some(result) = record.function_queries[547].get_mut(&inp[..]) { debug_assert_eq!(result.output, &__ret[..]); if !unconstrained { *result.multiplicity += G::ONE; } } else { record.function_queries[547].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained)); }; + let __ret: [G; OUT_543] = [__v_13, __v_14]; + if let Some(result) = record.function_queries[543].get_mut(&inp[..]) { debug_assert_eq!(result.output, &__ret[..]); if !unconstrained { *result.multiplicity += G::ONE; } } else { record.function_queries[543].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained)); }; return Ok(__ret); }, _ => { - let __r_arr: [G; OUT_530] = { let __args: [G; IN_530] = []; let __cu = unconstrained; if let Some(result) = record.function_queries[530].get_mut(&__args[..]) { if !__cu && *result.multiplicity == G::ZERO { aiur_fn_530(__args, record, io_buffer, false)? } else { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_530] = unsafe { *(result.output.as_ptr() as *const [G; OUT_530]) }; __ret } } else { aiur_fn_530(__args, record, io_buffer, __cu)? } }; + let __r_arr: [G; OUT_526] = { let __args: [G; IN_526] = []; let __cu = unconstrained; if let Some(result) = record.function_queries[526].get_mut(&__args[..]) { if !__cu && *result.multiplicity == G::ZERO { aiur_fn_526(__args, record, io_buffer, false)? } else { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_526] = unsafe { *(result.output.as_ptr() as *const [G; OUT_526]) }; __ret } } else { aiur_fn_526(__args, record, io_buffer, __cu)? } }; let __v_9: G = __r_arr[0]; let __v_10: G = __r_arr[1]; - let __ret: [G; OUT_547] = [__v_9, __v_10]; - if let Some(result) = record.function_queries[547].get_mut(&inp[..]) { debug_assert_eq!(result.output, &__ret[..]); if !unconstrained { *result.multiplicity += G::ONE; } } else { record.function_queries[547].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained)); }; + let __ret: [G; OUT_543] = [__v_9, __v_10]; + if let Some(result) = record.function_queries[543].get_mut(&inp[..]) { debug_assert_eq!(result.output, &__ret[..]); if !unconstrained { *result.multiplicity += G::ONE; } } else { record.function_queries[543].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained)); }; return Ok(__ret); }, } @@ -47371,65 +47087,65 @@ fn aiur_fn_547( 5u64 => { match __v_4.as_canonical_u64() { 0u64 => { - let __r_arr: [G; OUT_532] = { let __args: [G; IN_532] = []; let __cu = unconstrained; if let Some(result) = record.function_queries[532].get_mut(&__args[..]) { if !__cu && *result.multiplicity == G::ZERO { aiur_fn_532(__args, record, io_buffer, false)? } else { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_532] = unsafe { *(result.output.as_ptr() as *const [G; OUT_532]) }; __ret } } else { aiur_fn_532(__args, record, io_buffer, __cu)? } }; + let __r_arr: [G; OUT_528] = { let __args: [G; IN_528] = []; let __cu = unconstrained; if let Some(result) = record.function_queries[528].get_mut(&__args[..]) { if !__cu && *result.multiplicity == G::ZERO { aiur_fn_528(__args, record, io_buffer, false)? } else { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_528] = unsafe { *(result.output.as_ptr() as *const [G; OUT_528]) }; __ret } } else { aiur_fn_528(__args, record, io_buffer, __cu)? } }; let __v_9: G = __r_arr[0]; let __v_10: G = __r_arr[1]; - let __ret: [G; OUT_547] = [__v_9, __v_10]; - if let Some(result) = record.function_queries[547].get_mut(&inp[..]) { debug_assert_eq!(result.output, &__ret[..]); if !unconstrained { *result.multiplicity += G::ONE; } } else { record.function_queries[547].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained)); }; + let __ret: [G; OUT_543] = [__v_9, __v_10]; + if let Some(result) = record.function_queries[543].get_mut(&inp[..]) { debug_assert_eq!(result.output, &__ret[..]); if !unconstrained { *result.multiplicity += G::ONE; } } else { record.function_queries[543].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained)); }; return Ok(__ret); }, 1u64 => { - let __r_arr: [G; OUT_532] = { let __args: [G; IN_532] = []; let __cu = unconstrained; if let Some(result) = record.function_queries[532].get_mut(&__args[..]) { if !__cu && *result.multiplicity == G::ZERO { aiur_fn_532(__args, record, io_buffer, false)? } else { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_532] = unsafe { *(result.output.as_ptr() as *const [G; OUT_532]) }; __ret } } else { aiur_fn_532(__args, record, io_buffer, __cu)? } }; + let __r_arr: [G; OUT_528] = { let __args: [G; IN_528] = []; let __cu = unconstrained; if let Some(result) = record.function_queries[528].get_mut(&__args[..]) { if !__cu && *result.multiplicity == G::ZERO { aiur_fn_528(__args, record, io_buffer, false)? } else { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_528] = unsafe { *(result.output.as_ptr() as *const [G; OUT_528]) }; __ret } } else { aiur_fn_528(__args, record, io_buffer, __cu)? } }; let __v_9: G = __r_arr[0]; let __v_10: G = __r_arr[1]; - let __ret: [G; OUT_547] = [__v_9, __v_10]; - if let Some(result) = record.function_queries[547].get_mut(&inp[..]) { debug_assert_eq!(result.output, &__ret[..]); if !unconstrained { *result.multiplicity += G::ONE; } } else { record.function_queries[547].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained)); }; + let __ret: [G; OUT_543] = [__v_9, __v_10]; + if let Some(result) = record.function_queries[543].get_mut(&inp[..]) { debug_assert_eq!(result.output, &__ret[..]); if !unconstrained { *result.multiplicity += G::ONE; } } else { record.function_queries[543].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained)); }; return Ok(__ret); }, 2u64 => { - let __r_arr: [G; OUT_532] = { let __args: [G; IN_532] = []; let __cu = unconstrained; if let Some(result) = record.function_queries[532].get_mut(&__args[..]) { if !__cu && *result.multiplicity == G::ZERO { aiur_fn_532(__args, record, io_buffer, false)? } else { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_532] = unsafe { *(result.output.as_ptr() as *const [G; OUT_532]) }; __ret } } else { aiur_fn_532(__args, record, io_buffer, __cu)? } }; + let __r_arr: [G; OUT_528] = { let __args: [G; IN_528] = []; let __cu = unconstrained; if let Some(result) = record.function_queries[528].get_mut(&__args[..]) { if !__cu && *result.multiplicity == G::ZERO { aiur_fn_528(__args, record, io_buffer, false)? } else { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_528] = unsafe { *(result.output.as_ptr() as *const [G; OUT_528]) }; __ret } } else { aiur_fn_528(__args, record, io_buffer, __cu)? } }; let __v_9: G = __r_arr[0]; let __v_10: G = __r_arr[1]; - let __ret: [G; OUT_547] = [__v_9, __v_10]; - if let Some(result) = record.function_queries[547].get_mut(&inp[..]) { debug_assert_eq!(result.output, &__ret[..]); if !unconstrained { *result.multiplicity += G::ONE; } } else { record.function_queries[547].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained)); }; + let __ret: [G; OUT_543] = [__v_9, __v_10]; + if let Some(result) = record.function_queries[543].get_mut(&inp[..]) { debug_assert_eq!(result.output, &__ret[..]); if !unconstrained { *result.multiplicity += G::ONE; } } else { record.function_queries[543].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained)); }; return Ok(__ret); }, 3u64 => { - let __r_arr: [G; OUT_532] = { let __args: [G; IN_532] = []; let __cu = unconstrained; if let Some(result) = record.function_queries[532].get_mut(&__args[..]) { if !__cu && *result.multiplicity == G::ZERO { aiur_fn_532(__args, record, io_buffer, false)? } else { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_532] = unsafe { *(result.output.as_ptr() as *const [G; OUT_532]) }; __ret } } else { aiur_fn_532(__args, record, io_buffer, __cu)? } }; + let __r_arr: [G; OUT_528] = { let __args: [G; IN_528] = []; let __cu = unconstrained; if let Some(result) = record.function_queries[528].get_mut(&__args[..]) { if !__cu && *result.multiplicity == G::ZERO { aiur_fn_528(__args, record, io_buffer, false)? } else { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_528] = unsafe { *(result.output.as_ptr() as *const [G; OUT_528]) }; __ret } } else { aiur_fn_528(__args, record, io_buffer, __cu)? } }; let __v_9: G = __r_arr[0]; let __v_10: G = __r_arr[1]; - let __ret: [G; OUT_547] = [__v_9, __v_10]; - if let Some(result) = record.function_queries[547].get_mut(&inp[..]) { debug_assert_eq!(result.output, &__ret[..]); if !unconstrained { *result.multiplicity += G::ONE; } } else { record.function_queries[547].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained)); }; + let __ret: [G; OUT_543] = [__v_9, __v_10]; + if let Some(result) = record.function_queries[543].get_mut(&inp[..]) { debug_assert_eq!(result.output, &__ret[..]); if !unconstrained { *result.multiplicity += G::ONE; } } else { record.function_queries[543].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained)); }; return Ok(__ret); }, 4u64 => { - let __r_arr: [G; OUT_532] = { let __args: [G; IN_532] = []; let __cu = unconstrained; if let Some(result) = record.function_queries[532].get_mut(&__args[..]) { if !__cu && *result.multiplicity == G::ZERO { aiur_fn_532(__args, record, io_buffer, false)? } else { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_532] = unsafe { *(result.output.as_ptr() as *const [G; OUT_532]) }; __ret } } else { aiur_fn_532(__args, record, io_buffer, __cu)? } }; + let __r_arr: [G; OUT_528] = { let __args: [G; IN_528] = []; let __cu = unconstrained; if let Some(result) = record.function_queries[528].get_mut(&__args[..]) { if !__cu && *result.multiplicity == G::ZERO { aiur_fn_528(__args, record, io_buffer, false)? } else { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_528] = unsafe { *(result.output.as_ptr() as *const [G; OUT_528]) }; __ret } } else { aiur_fn_528(__args, record, io_buffer, __cu)? } }; let __v_9: G = __r_arr[0]; let __v_10: G = __r_arr[1]; - let __ret: [G; OUT_547] = [__v_9, __v_10]; - if let Some(result) = record.function_queries[547].get_mut(&inp[..]) { debug_assert_eq!(result.output, &__ret[..]); if !unconstrained { *result.multiplicity += G::ONE; } } else { record.function_queries[547].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained)); }; + let __ret: [G; OUT_543] = [__v_9, __v_10]; + if let Some(result) = record.function_queries[543].get_mut(&inp[..]) { debug_assert_eq!(result.output, &__ret[..]); if !unconstrained { *result.multiplicity += G::ONE; } } else { record.function_queries[543].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained)); }; return Ok(__ret); }, 5u64 => { - let __r_arr: [G; OUT_546] = { let __args: [G; IN_546] = [__v_1, __v_5, __v_8]; let __cu = unconstrained; if let Some(result) = record.function_queries[546].get_mut(&__args[..]) { if !__cu && *result.multiplicity == G::ZERO { aiur_fn_546(__args, record, io_buffer, false)? } else { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_546] = unsafe { *(result.output.as_ptr() as *const [G; OUT_546]) }; __ret } } else { aiur_fn_546(__args, record, io_buffer, __cu)? } }; + let __r_arr: [G; OUT_542] = { let __args: [G; IN_542] = [__v_1, __v_5, __v_8]; let __cu = unconstrained; if let Some(result) = record.function_queries[542].get_mut(&__args[..]) { if !__cu && *result.multiplicity == G::ZERO { aiur_fn_542(__args, record, io_buffer, false)? } else { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_542] = unsafe { *(result.output.as_ptr() as *const [G; OUT_542]) }; __ret } } else { aiur_fn_542(__args, record, io_buffer, __cu)? } }; let __v_9: G = __r_arr[0]; let __v_10: G = __r_arr[1]; - let __r_arr: [G; OUT_546] = { let __args: [G; IN_546] = [__v_2, __v_6, __v_8]; let __cu = unconstrained; if let Some(result) = record.function_queries[546].get_mut(&__args[..]) { if !__cu && *result.multiplicity == G::ZERO { aiur_fn_546(__args, record, io_buffer, false)? } else { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_546] = unsafe { *(result.output.as_ptr() as *const [G; OUT_546]) }; __ret } } else { aiur_fn_546(__args, record, io_buffer, __cu)? } }; + let __r_arr: [G; OUT_542] = { let __args: [G; IN_542] = [__v_2, __v_6, __v_8]; let __cu = unconstrained; if let Some(result) = record.function_queries[542].get_mut(&__args[..]) { if !__cu && *result.multiplicity == G::ZERO { aiur_fn_542(__args, record, io_buffer, false)? } else { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_542] = unsafe { *(result.output.as_ptr() as *const [G; OUT_542]) }; __ret } } else { aiur_fn_542(__args, record, io_buffer, __cu)? } }; let __v_11: G = __r_arr[0]; let __v_12: G = __r_arr[1]; - let __r_arr: [G; OUT_533] = { let __args: [G; IN_533] = [__v_9, __v_10, __v_11, __v_12]; let __cu = unconstrained; if let Some(result) = record.function_queries[533].get_mut(&__args[..]) { if !__cu && *result.multiplicity == G::ZERO { aiur_fn_533(__args, record, io_buffer, false)? } else { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_533] = unsafe { *(result.output.as_ptr() as *const [G; OUT_533]) }; __ret } } else { aiur_fn_533(__args, record, io_buffer, __cu)? } }; + let __r_arr: [G; OUT_529] = { let __args: [G; IN_529] = [__v_9, __v_10, __v_11, __v_12]; let __cu = unconstrained; if let Some(result) = record.function_queries[529].get_mut(&__args[..]) { if !__cu && *result.multiplicity == G::ZERO { aiur_fn_529(__args, record, io_buffer, false)? } else { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_529] = unsafe { *(result.output.as_ptr() as *const [G; OUT_529]) }; __ret } } else { aiur_fn_529(__args, record, io_buffer, __cu)? } }; let __v_13: G = __r_arr[0]; let __v_14: G = __r_arr[1]; - let __ret: [G; OUT_547] = [__v_13, __v_14]; - if let Some(result) = record.function_queries[547].get_mut(&inp[..]) { debug_assert_eq!(result.output, &__ret[..]); if !unconstrained { *result.multiplicity += G::ONE; } } else { record.function_queries[547].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained)); }; + let __ret: [G; OUT_543] = [__v_13, __v_14]; + if let Some(result) = record.function_queries[543].get_mut(&inp[..]) { debug_assert_eq!(result.output, &__ret[..]); if !unconstrained { *result.multiplicity += G::ONE; } } else { record.function_queries[543].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained)); }; return Ok(__ret); }, _ => { - let __r_arr: [G; OUT_530] = { let __args: [G; IN_530] = []; let __cu = unconstrained; if let Some(result) = record.function_queries[530].get_mut(&__args[..]) { if !__cu && *result.multiplicity == G::ZERO { aiur_fn_530(__args, record, io_buffer, false)? } else { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_530] = unsafe { *(result.output.as_ptr() as *const [G; OUT_530]) }; __ret } } else { aiur_fn_530(__args, record, io_buffer, __cu)? } }; + let __r_arr: [G; OUT_526] = { let __args: [G; IN_526] = []; let __cu = unconstrained; if let Some(result) = record.function_queries[526].get_mut(&__args[..]) { if !__cu && *result.multiplicity == G::ZERO { aiur_fn_526(__args, record, io_buffer, false)? } else { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_526] = unsafe { *(result.output.as_ptr() as *const [G; OUT_526]) }; __ret } } else { aiur_fn_526(__args, record, io_buffer, __cu)? } }; let __v_9: G = __r_arr[0]; let __v_10: G = __r_arr[1]; - let __ret: [G; OUT_547] = [__v_9, __v_10]; - if let Some(result) = record.function_queries[547].get_mut(&inp[..]) { debug_assert_eq!(result.output, &__ret[..]); if !unconstrained { *result.multiplicity += G::ONE; } } else { record.function_queries[547].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained)); }; + let __ret: [G; OUT_543] = [__v_9, __v_10]; + if let Some(result) = record.function_queries[543].get_mut(&inp[..]) { debug_assert_eq!(result.output, &__ret[..]); if !unconstrained { *result.multiplicity += G::ONE; } } else { record.function_queries[543].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained)); }; return Ok(__ret); }, } @@ -47437,79 +47153,79 @@ fn aiur_fn_547( 6u64 => { match __v_4.as_canonical_u64() { 0u64 => { - let __r_arr: [G; OUT_532] = { let __args: [G; IN_532] = []; let __cu = unconstrained; if let Some(result) = record.function_queries[532].get_mut(&__args[..]) { if !__cu && *result.multiplicity == G::ZERO { aiur_fn_532(__args, record, io_buffer, false)? } else { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_532] = unsafe { *(result.output.as_ptr() as *const [G; OUT_532]) }; __ret } } else { aiur_fn_532(__args, record, io_buffer, __cu)? } }; + let __r_arr: [G; OUT_528] = { let __args: [G; IN_528] = []; let __cu = unconstrained; if let Some(result) = record.function_queries[528].get_mut(&__args[..]) { if !__cu && *result.multiplicity == G::ZERO { aiur_fn_528(__args, record, io_buffer, false)? } else { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_528] = unsafe { *(result.output.as_ptr() as *const [G; OUT_528]) }; __ret } } else { aiur_fn_528(__args, record, io_buffer, __cu)? } }; let __v_9: G = __r_arr[0]; let __v_10: G = __r_arr[1]; - let __ret: [G; OUT_547] = [__v_9, __v_10]; - if let Some(result) = record.function_queries[547].get_mut(&inp[..]) { debug_assert_eq!(result.output, &__ret[..]); if !unconstrained { *result.multiplicity += G::ONE; } } else { record.function_queries[547].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained)); }; + let __ret: [G; OUT_543] = [__v_9, __v_10]; + if let Some(result) = record.function_queries[543].get_mut(&inp[..]) { debug_assert_eq!(result.output, &__ret[..]); if !unconstrained { *result.multiplicity += G::ONE; } } else { record.function_queries[543].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained)); }; return Ok(__ret); }, 1u64 => { - let __r_arr: [G; OUT_532] = { let __args: [G; IN_532] = []; let __cu = unconstrained; if let Some(result) = record.function_queries[532].get_mut(&__args[..]) { if !__cu && *result.multiplicity == G::ZERO { aiur_fn_532(__args, record, io_buffer, false)? } else { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_532] = unsafe { *(result.output.as_ptr() as *const [G; OUT_532]) }; __ret } } else { aiur_fn_532(__args, record, io_buffer, __cu)? } }; + let __r_arr: [G; OUT_528] = { let __args: [G; IN_528] = []; let __cu = unconstrained; if let Some(result) = record.function_queries[528].get_mut(&__args[..]) { if !__cu && *result.multiplicity == G::ZERO { aiur_fn_528(__args, record, io_buffer, false)? } else { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_528] = unsafe { *(result.output.as_ptr() as *const [G; OUT_528]) }; __ret } } else { aiur_fn_528(__args, record, io_buffer, __cu)? } }; let __v_9: G = __r_arr[0]; let __v_10: G = __r_arr[1]; - let __ret: [G; OUT_547] = [__v_9, __v_10]; - if let Some(result) = record.function_queries[547].get_mut(&inp[..]) { debug_assert_eq!(result.output, &__ret[..]); if !unconstrained { *result.multiplicity += G::ONE; } } else { record.function_queries[547].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained)); }; + let __ret: [G; OUT_543] = [__v_9, __v_10]; + if let Some(result) = record.function_queries[543].get_mut(&inp[..]) { debug_assert_eq!(result.output, &__ret[..]); if !unconstrained { *result.multiplicity += G::ONE; } } else { record.function_queries[543].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained)); }; return Ok(__ret); }, 2u64 => { - let __r_arr: [G; OUT_532] = { let __args: [G; IN_532] = []; let __cu = unconstrained; if let Some(result) = record.function_queries[532].get_mut(&__args[..]) { if !__cu && *result.multiplicity == G::ZERO { aiur_fn_532(__args, record, io_buffer, false)? } else { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_532] = unsafe { *(result.output.as_ptr() as *const [G; OUT_532]) }; __ret } } else { aiur_fn_532(__args, record, io_buffer, __cu)? } }; + let __r_arr: [G; OUT_528] = { let __args: [G; IN_528] = []; let __cu = unconstrained; if let Some(result) = record.function_queries[528].get_mut(&__args[..]) { if !__cu && *result.multiplicity == G::ZERO { aiur_fn_528(__args, record, io_buffer, false)? } else { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_528] = unsafe { *(result.output.as_ptr() as *const [G; OUT_528]) }; __ret } } else { aiur_fn_528(__args, record, io_buffer, __cu)? } }; let __v_9: G = __r_arr[0]; let __v_10: G = __r_arr[1]; - let __ret: [G; OUT_547] = [__v_9, __v_10]; - if let Some(result) = record.function_queries[547].get_mut(&inp[..]) { debug_assert_eq!(result.output, &__ret[..]); if !unconstrained { *result.multiplicity += G::ONE; } } else { record.function_queries[547].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained)); }; + let __ret: [G; OUT_543] = [__v_9, __v_10]; + if let Some(result) = record.function_queries[543].get_mut(&inp[..]) { debug_assert_eq!(result.output, &__ret[..]); if !unconstrained { *result.multiplicity += G::ONE; } } else { record.function_queries[543].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained)); }; return Ok(__ret); }, 3u64 => { - let __r_arr: [G; OUT_532] = { let __args: [G; IN_532] = []; let __cu = unconstrained; if let Some(result) = record.function_queries[532].get_mut(&__args[..]) { if !__cu && *result.multiplicity == G::ZERO { aiur_fn_532(__args, record, io_buffer, false)? } else { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_532] = unsafe { *(result.output.as_ptr() as *const [G; OUT_532]) }; __ret } } else { aiur_fn_532(__args, record, io_buffer, __cu)? } }; + let __r_arr: [G; OUT_528] = { let __args: [G; IN_528] = []; let __cu = unconstrained; if let Some(result) = record.function_queries[528].get_mut(&__args[..]) { if !__cu && *result.multiplicity == G::ZERO { aiur_fn_528(__args, record, io_buffer, false)? } else { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_528] = unsafe { *(result.output.as_ptr() as *const [G; OUT_528]) }; __ret } } else { aiur_fn_528(__args, record, io_buffer, __cu)? } }; let __v_9: G = __r_arr[0]; let __v_10: G = __r_arr[1]; - let __ret: [G; OUT_547] = [__v_9, __v_10]; - if let Some(result) = record.function_queries[547].get_mut(&inp[..]) { debug_assert_eq!(result.output, &__ret[..]); if !unconstrained { *result.multiplicity += G::ONE; } } else { record.function_queries[547].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained)); }; + let __ret: [G; OUT_543] = [__v_9, __v_10]; + if let Some(result) = record.function_queries[543].get_mut(&inp[..]) { debug_assert_eq!(result.output, &__ret[..]); if !unconstrained { *result.multiplicity += G::ONE; } } else { record.function_queries[543].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained)); }; return Ok(__ret); }, 4u64 => { - let __r_arr: [G; OUT_532] = { let __args: [G; IN_532] = []; let __cu = unconstrained; if let Some(result) = record.function_queries[532].get_mut(&__args[..]) { if !__cu && *result.multiplicity == G::ZERO { aiur_fn_532(__args, record, io_buffer, false)? } else { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_532] = unsafe { *(result.output.as_ptr() as *const [G; OUT_532]) }; __ret } } else { aiur_fn_532(__args, record, io_buffer, __cu)? } }; + let __r_arr: [G; OUT_528] = { let __args: [G; IN_528] = []; let __cu = unconstrained; if let Some(result) = record.function_queries[528].get_mut(&__args[..]) { if !__cu && *result.multiplicity == G::ZERO { aiur_fn_528(__args, record, io_buffer, false)? } else { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_528] = unsafe { *(result.output.as_ptr() as *const [G; OUT_528]) }; __ret } } else { aiur_fn_528(__args, record, io_buffer, __cu)? } }; let __v_9: G = __r_arr[0]; let __v_10: G = __r_arr[1]; - let __ret: [G; OUT_547] = [__v_9, __v_10]; - if let Some(result) = record.function_queries[547].get_mut(&inp[..]) { debug_assert_eq!(result.output, &__ret[..]); if !unconstrained { *result.multiplicity += G::ONE; } } else { record.function_queries[547].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained)); }; + let __ret: [G; OUT_543] = [__v_9, __v_10]; + if let Some(result) = record.function_queries[543].get_mut(&inp[..]) { debug_assert_eq!(result.output, &__ret[..]); if !unconstrained { *result.multiplicity += G::ONE; } } else { record.function_queries[543].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained)); }; return Ok(__ret); }, 5u64 => { - let __r_arr: [G; OUT_532] = { let __args: [G; IN_532] = []; let __cu = unconstrained; if let Some(result) = record.function_queries[532].get_mut(&__args[..]) { if !__cu && *result.multiplicity == G::ZERO { aiur_fn_532(__args, record, io_buffer, false)? } else { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_532] = unsafe { *(result.output.as_ptr() as *const [G; OUT_532]) }; __ret } } else { aiur_fn_532(__args, record, io_buffer, __cu)? } }; + let __r_arr: [G; OUT_528] = { let __args: [G; IN_528] = []; let __cu = unconstrained; if let Some(result) = record.function_queries[528].get_mut(&__args[..]) { if !__cu && *result.multiplicity == G::ZERO { aiur_fn_528(__args, record, io_buffer, false)? } else { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_528] = unsafe { *(result.output.as_ptr() as *const [G; OUT_528]) }; __ret } } else { aiur_fn_528(__args, record, io_buffer, __cu)? } }; let __v_9: G = __r_arr[0]; let __v_10: G = __r_arr[1]; - let __ret: [G; OUT_547] = [__v_9, __v_10]; - if let Some(result) = record.function_queries[547].get_mut(&inp[..]) { debug_assert_eq!(result.output, &__ret[..]); if !unconstrained { *result.multiplicity += G::ONE; } } else { record.function_queries[547].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained)); }; + let __ret: [G; OUT_543] = [__v_9, __v_10]; + if let Some(result) = record.function_queries[543].get_mut(&inp[..]) { debug_assert_eq!(result.output, &__ret[..]); if !unconstrained { *result.multiplicity += G::ONE; } } else { record.function_queries[543].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained)); }; return Ok(__ret); }, 6u64 => { - let __r_arr: [G; OUT_546] = { let __args: [G; IN_546] = [__v_1, __v_5, __v_8]; let __cu = unconstrained; if let Some(result) = record.function_queries[546].get_mut(&__args[..]) { if !__cu && *result.multiplicity == G::ZERO { aiur_fn_546(__args, record, io_buffer, false)? } else { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_546] = unsafe { *(result.output.as_ptr() as *const [G; OUT_546]) }; __ret } } else { aiur_fn_546(__args, record, io_buffer, __cu)? } }; + let __r_arr: [G; OUT_542] = { let __args: [G; IN_542] = [__v_1, __v_5, __v_8]; let __cu = unconstrained; if let Some(result) = record.function_queries[542].get_mut(&__args[..]) { if !__cu && *result.multiplicity == G::ZERO { aiur_fn_542(__args, record, io_buffer, false)? } else { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_542] = unsafe { *(result.output.as_ptr() as *const [G; OUT_542]) }; __ret } } else { aiur_fn_542(__args, record, io_buffer, __cu)? } }; let __v_9: G = __r_arr[0]; let __v_10: G = __r_arr[1]; - let __r_arr: [G; OUT_546] = { let __args: [G; IN_546] = [__v_2, __v_6, __v_8]; let __cu = unconstrained; if let Some(result) = record.function_queries[546].get_mut(&__args[..]) { if !__cu && *result.multiplicity == G::ZERO { aiur_fn_546(__args, record, io_buffer, false)? } else { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_546] = unsafe { *(result.output.as_ptr() as *const [G; OUT_546]) }; __ret } } else { aiur_fn_546(__args, record, io_buffer, __cu)? } }; + let __r_arr: [G; OUT_542] = { let __args: [G; IN_542] = [__v_2, __v_6, __v_8]; let __cu = unconstrained; if let Some(result) = record.function_queries[542].get_mut(&__args[..]) { if !__cu && *result.multiplicity == G::ZERO { aiur_fn_542(__args, record, io_buffer, false)? } else { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_542] = unsafe { *(result.output.as_ptr() as *const [G; OUT_542]) }; __ret } } else { aiur_fn_542(__args, record, io_buffer, __cu)? } }; let __v_11: G = __r_arr[0]; let __v_12: G = __r_arr[1]; - let __r_arr: [G; OUT_546] = { let __args: [G; IN_546] = [__v_3, __v_7, __v_8]; let __cu = unconstrained; if let Some(result) = record.function_queries[546].get_mut(&__args[..]) { if !__cu && *result.multiplicity == G::ZERO { aiur_fn_546(__args, record, io_buffer, false)? } else { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_546] = unsafe { *(result.output.as_ptr() as *const [G; OUT_546]) }; __ret } } else { aiur_fn_546(__args, record, io_buffer, __cu)? } }; + let __r_arr: [G; OUT_542] = { let __args: [G; IN_542] = [__v_3, __v_7, __v_8]; let __cu = unconstrained; if let Some(result) = record.function_queries[542].get_mut(&__args[..]) { if !__cu && *result.multiplicity == G::ZERO { aiur_fn_542(__args, record, io_buffer, false)? } else { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_542] = unsafe { *(result.output.as_ptr() as *const [G; OUT_542]) }; __ret } } else { aiur_fn_542(__args, record, io_buffer, __cu)? } }; let __v_13: G = __r_arr[0]; let __v_14: G = __r_arr[1]; - let __r_arr: [G; OUT_533] = { let __args: [G; IN_533] = [__v_11, __v_12, __v_13, __v_14]; let __cu = unconstrained; if let Some(result) = record.function_queries[533].get_mut(&__args[..]) { if !__cu && *result.multiplicity == G::ZERO { aiur_fn_533(__args, record, io_buffer, false)? } else { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_533] = unsafe { *(result.output.as_ptr() as *const [G; OUT_533]) }; __ret } } else { aiur_fn_533(__args, record, io_buffer, __cu)? } }; + let __r_arr: [G; OUT_529] = { let __args: [G; IN_529] = [__v_11, __v_12, __v_13, __v_14]; let __cu = unconstrained; if let Some(result) = record.function_queries[529].get_mut(&__args[..]) { if !__cu && *result.multiplicity == G::ZERO { aiur_fn_529(__args, record, io_buffer, false)? } else { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_529] = unsafe { *(result.output.as_ptr() as *const [G; OUT_529]) }; __ret } } else { aiur_fn_529(__args, record, io_buffer, __cu)? } }; let __v_15: G = __r_arr[0]; let __v_16: G = __r_arr[1]; - let __r_arr: [G; OUT_533] = { let __args: [G; IN_533] = [__v_9, __v_10, __v_15, __v_16]; let __cu = unconstrained; if let Some(result) = record.function_queries[533].get_mut(&__args[..]) { if !__cu && *result.multiplicity == G::ZERO { aiur_fn_533(__args, record, io_buffer, false)? } else { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_533] = unsafe { *(result.output.as_ptr() as *const [G; OUT_533]) }; __ret } } else { aiur_fn_533(__args, record, io_buffer, __cu)? } }; + let __r_arr: [G; OUT_529] = { let __args: [G; IN_529] = [__v_9, __v_10, __v_15, __v_16]; let __cu = unconstrained; if let Some(result) = record.function_queries[529].get_mut(&__args[..]) { if !__cu && *result.multiplicity == G::ZERO { aiur_fn_529(__args, record, io_buffer, false)? } else { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_529] = unsafe { *(result.output.as_ptr() as *const [G; OUT_529]) }; __ret } } else { aiur_fn_529(__args, record, io_buffer, __cu)? } }; let __v_17: G = __r_arr[0]; let __v_18: G = __r_arr[1]; - let __ret: [G; OUT_547] = [__v_17, __v_18]; - if let Some(result) = record.function_queries[547].get_mut(&inp[..]) { debug_assert_eq!(result.output, &__ret[..]); if !unconstrained { *result.multiplicity += G::ONE; } } else { record.function_queries[547].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained)); }; + let __ret: [G; OUT_543] = [__v_17, __v_18]; + if let Some(result) = record.function_queries[543].get_mut(&inp[..]) { debug_assert_eq!(result.output, &__ret[..]); if !unconstrained { *result.multiplicity += G::ONE; } } else { record.function_queries[543].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained)); }; return Ok(__ret); }, _ => { - let __r_arr: [G; OUT_530] = { let __args: [G; IN_530] = []; let __cu = unconstrained; if let Some(result) = record.function_queries[530].get_mut(&__args[..]) { if !__cu && *result.multiplicity == G::ZERO { aiur_fn_530(__args, record, io_buffer, false)? } else { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_530] = unsafe { *(result.output.as_ptr() as *const [G; OUT_530]) }; __ret } } else { aiur_fn_530(__args, record, io_buffer, __cu)? } }; + let __r_arr: [G; OUT_526] = { let __args: [G; IN_526] = []; let __cu = unconstrained; if let Some(result) = record.function_queries[526].get_mut(&__args[..]) { if !__cu && *result.multiplicity == G::ZERO { aiur_fn_526(__args, record, io_buffer, false)? } else { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_526] = unsafe { *(result.output.as_ptr() as *const [G; OUT_526]) }; __ret } } else { aiur_fn_526(__args, record, io_buffer, __cu)? } }; let __v_9: G = __r_arr[0]; let __v_10: G = __r_arr[1]; - let __ret: [G; OUT_547] = [__v_9, __v_10]; - if let Some(result) = record.function_queries[547].get_mut(&inp[..]) { debug_assert_eq!(result.output, &__ret[..]); if !unconstrained { *result.multiplicity += G::ONE; } } else { record.function_queries[547].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained)); }; + let __ret: [G; OUT_543] = [__v_9, __v_10]; + if let Some(result) = record.function_queries[543].get_mut(&inp[..]) { debug_assert_eq!(result.output, &__ret[..]); if !unconstrained { *result.multiplicity += G::ONE; } } else { record.function_queries[543].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained)); }; return Ok(__ret); }, } @@ -47517,29 +47233,29 @@ fn aiur_fn_547( 7u64 => { match __v_4.as_canonical_u64() { 8u64 => { - let __r_arr: [G; OUT_530] = { let __args: [G; IN_530] = []; let __cu = unconstrained; if let Some(result) = record.function_queries[530].get_mut(&__args[..]) { if !__cu && *result.multiplicity == G::ZERO { aiur_fn_530(__args, record, io_buffer, false)? } else { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_530] = unsafe { *(result.output.as_ptr() as *const [G; OUT_530]) }; __ret } } else { aiur_fn_530(__args, record, io_buffer, __cu)? } }; + let __r_arr: [G; OUT_526] = { let __args: [G; IN_526] = []; let __cu = unconstrained; if let Some(result) = record.function_queries[526].get_mut(&__args[..]) { if !__cu && *result.multiplicity == G::ZERO { aiur_fn_526(__args, record, io_buffer, false)? } else { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_526] = unsafe { *(result.output.as_ptr() as *const [G; OUT_526]) }; __ret } } else { aiur_fn_526(__args, record, io_buffer, __cu)? } }; let __v_9: G = __r_arr[0]; let __v_10: G = __r_arr[1]; - let __ret: [G; OUT_547] = [__v_9, __v_10]; - if let Some(result) = record.function_queries[547].get_mut(&inp[..]) { debug_assert_eq!(result.output, &__ret[..]); if !unconstrained { *result.multiplicity += G::ONE; } } else { record.function_queries[547].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained)); }; + let __ret: [G; OUT_543] = [__v_9, __v_10]; + if let Some(result) = record.function_queries[543].get_mut(&inp[..]) { debug_assert_eq!(result.output, &__ret[..]); if !unconstrained { *result.multiplicity += G::ONE; } } else { record.function_queries[543].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained)); }; return Ok(__ret); }, 7u64 => { - let __r_arr: [G; OUT_541] = { let __args: [G; IN_541] = [__v_1, __v_2, __v_5, __v_6]; let __cu = unconstrained; if let Some(result) = record.function_queries[541].get_mut(&__args[..]) { if !__cu && *result.multiplicity == G::ZERO { aiur_fn_541(__args, record, io_buffer, false)? } else { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_541] = unsafe { *(result.output.as_ptr() as *const [G; OUT_541]) }; __ret } } else { aiur_fn_541(__args, record, io_buffer, __cu)? } }; + let __r_arr: [G; OUT_537] = { let __args: [G; IN_537] = [__v_1, __v_2, __v_5, __v_6]; let __cu = unconstrained; if let Some(result) = record.function_queries[537].get_mut(&__args[..]) { if !__cu && *result.multiplicity == G::ZERO { aiur_fn_537(__args, record, io_buffer, false)? } else { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_537] = unsafe { *(result.output.as_ptr() as *const [G; OUT_537]) }; __ret } } else { aiur_fn_537(__args, record, io_buffer, __cu)? } }; let __v_9: G = __r_arr[0]; - let __r_arr: [G; OUT_534] = { let __args: [G; IN_534] = [__v_9]; let __cu = unconstrained; if let Some(result) = record.function_queries[534].get_mut(&__args[..]) { if !__cu && *result.multiplicity == G::ZERO { aiur_fn_534(__args, record, io_buffer, false)? } else { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_534] = unsafe { *(result.output.as_ptr() as *const [G; OUT_534]) }; __ret } } else { aiur_fn_534(__args, record, io_buffer, __cu)? } }; + let __r_arr: [G; OUT_530] = { let __args: [G; IN_530] = [__v_9]; let __cu = unconstrained; if let Some(result) = record.function_queries[530].get_mut(&__args[..]) { if !__cu && *result.multiplicity == G::ZERO { aiur_fn_530(__args, record, io_buffer, false)? } else { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_530] = unsafe { *(result.output.as_ptr() as *const [G; OUT_530]) }; __ret } } else { aiur_fn_530(__args, record, io_buffer, __cu)? } }; let __v_10: G = __r_arr[0]; let __v_11: G = __r_arr[1]; - let __ret: [G; OUT_547] = [__v_10, __v_11]; - if let Some(result) = record.function_queries[547].get_mut(&inp[..]) { debug_assert_eq!(result.output, &__ret[..]); if !unconstrained { *result.multiplicity += G::ONE; } } else { record.function_queries[547].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained)); }; + let __ret: [G; OUT_543] = [__v_10, __v_11]; + if let Some(result) = record.function_queries[543].get_mut(&inp[..]) { debug_assert_eq!(result.output, &__ret[..]); if !unconstrained { *result.multiplicity += G::ONE; } } else { record.function_queries[543].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained)); }; return Ok(__ret); }, _ => { - let __r_arr: [G; OUT_532] = { let __args: [G; IN_532] = []; let __cu = unconstrained; if let Some(result) = record.function_queries[532].get_mut(&__args[..]) { if !__cu && *result.multiplicity == G::ZERO { aiur_fn_532(__args, record, io_buffer, false)? } else { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_532] = unsafe { *(result.output.as_ptr() as *const [G; OUT_532]) }; __ret } } else { aiur_fn_532(__args, record, io_buffer, __cu)? } }; + let __r_arr: [G; OUT_528] = { let __args: [G; IN_528] = []; let __cu = unconstrained; if let Some(result) = record.function_queries[528].get_mut(&__args[..]) { if !__cu && *result.multiplicity == G::ZERO { aiur_fn_528(__args, record, io_buffer, false)? } else { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_528] = unsafe { *(result.output.as_ptr() as *const [G; OUT_528]) }; __ret } } else { aiur_fn_528(__args, record, io_buffer, __cu)? } }; let __v_9: G = __r_arr[0]; let __v_10: G = __r_arr[1]; - let __ret: [G; OUT_547] = [__v_9, __v_10]; - if let Some(result) = record.function_queries[547].get_mut(&inp[..]) { debug_assert_eq!(result.output, &__ret[..]); if !unconstrained { *result.multiplicity += G::ONE; } } else { record.function_queries[547].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained)); }; + let __ret: [G; OUT_543] = [__v_9, __v_10]; + if let Some(result) = record.function_queries[543].get_mut(&inp[..]) { debug_assert_eq!(result.output, &__ret[..]); if !unconstrained { *result.multiplicity += G::ONE; } } else { record.function_queries[543].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained)); }; return Ok(__ret); }, } @@ -47547,33 +47263,33 @@ fn aiur_fn_547( 8u64 => { match __v_4.as_canonical_u64() { 8u64 => { - let __r_arr: [G; OUT_538] = { let __args: [G; IN_538] = [__v_1, __v_5, __v_8]; let __cu = unconstrained; if let Some(result) = record.function_queries[538].get_mut(&__args[..]) { if !__cu && *result.multiplicity == G::ZERO { aiur_fn_538(__args, record, io_buffer, false)? } else { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_538] = unsafe { *(result.output.as_ptr() as *const [G; OUT_538]) }; __ret } } else { aiur_fn_538(__args, record, io_buffer, __cu)? } }; + let __r_arr: [G; OUT_534] = { let __args: [G; IN_534] = [__v_1, __v_5, __v_8]; let __cu = unconstrained; if let Some(result) = record.function_queries[534].get_mut(&__args[..]) { if !__cu && *result.multiplicity == G::ZERO { aiur_fn_534(__args, record, io_buffer, false)? } else { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_534] = unsafe { *(result.output.as_ptr() as *const [G; OUT_534]) }; __ret } } else { aiur_fn_534(__args, record, io_buffer, __cu)? } }; let __v_9: G = __r_arr[0]; let __v_10: G = __r_arr[1]; - let __r_arr: [G; OUT_528] = { let __args: [G; IN_528] = [__v_2, __v_6]; let __cu = unconstrained; if let Some(result) = record.function_queries[528].get_mut(&__args[..]) { if !__cu && *result.multiplicity == G::ZERO { aiur_fn_528(__args, record, io_buffer, false)? } else { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_528] = unsafe { *(result.output.as_ptr() as *const [G; OUT_528]) }; __ret } } else { aiur_fn_528(__args, record, io_buffer, __cu)? } }; + let __r_arr: [G; OUT_524] = { let __args: [G; IN_524] = [__v_2, __v_6]; let __cu = unconstrained; if let Some(result) = record.function_queries[524].get_mut(&__args[..]) { if !__cu && *result.multiplicity == G::ZERO { aiur_fn_524(__args, record, io_buffer, false)? } else { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_524] = unsafe { *(result.output.as_ptr() as *const [G; OUT_524]) }; __ret } } else { aiur_fn_524(__args, record, io_buffer, __cu)? } }; let __v_11: G = __r_arr[0]; - let __r_arr: [G; OUT_534] = { let __args: [G; IN_534] = [__v_11]; let __cu = unconstrained; if let Some(result) = record.function_queries[534].get_mut(&__args[..]) { if !__cu && *result.multiplicity == G::ZERO { aiur_fn_534(__args, record, io_buffer, false)? } else { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_534] = unsafe { *(result.output.as_ptr() as *const [G; OUT_534]) }; __ret } } else { aiur_fn_534(__args, record, io_buffer, __cu)? } }; + let __r_arr: [G; OUT_530] = { let __args: [G; IN_530] = [__v_11]; let __cu = unconstrained; if let Some(result) = record.function_queries[530].get_mut(&__args[..]) { if !__cu && *result.multiplicity == G::ZERO { aiur_fn_530(__args, record, io_buffer, false)? } else { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_530] = unsafe { *(result.output.as_ptr() as *const [G; OUT_530]) }; __ret } } else { aiur_fn_530(__args, record, io_buffer, __cu)? } }; let __v_12: G = __r_arr[0]; let __v_13: G = __r_arr[1]; - let __r_arr: [G; OUT_546] = { let __args: [G; IN_546] = [__v_3, __v_7, __v_8]; let __cu = unconstrained; if let Some(result) = record.function_queries[546].get_mut(&__args[..]) { if !__cu && *result.multiplicity == G::ZERO { aiur_fn_546(__args, record, io_buffer, false)? } else { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_546] = unsafe { *(result.output.as_ptr() as *const [G; OUT_546]) }; __ret } } else { aiur_fn_546(__args, record, io_buffer, __cu)? } }; + let __r_arr: [G; OUT_542] = { let __args: [G; IN_542] = [__v_3, __v_7, __v_8]; let __cu = unconstrained; if let Some(result) = record.function_queries[542].get_mut(&__args[..]) { if !__cu && *result.multiplicity == G::ZERO { aiur_fn_542(__args, record, io_buffer, false)? } else { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_542] = unsafe { *(result.output.as_ptr() as *const [G; OUT_542]) }; __ret } } else { aiur_fn_542(__args, record, io_buffer, __cu)? } }; let __v_14: G = __r_arr[0]; let __v_15: G = __r_arr[1]; - let __r_arr: [G; OUT_533] = { let __args: [G; IN_533] = [__v_12, __v_13, __v_14, __v_15]; let __cu = unconstrained; if let Some(result) = record.function_queries[533].get_mut(&__args[..]) { if !__cu && *result.multiplicity == G::ZERO { aiur_fn_533(__args, record, io_buffer, false)? } else { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_533] = unsafe { *(result.output.as_ptr() as *const [G; OUT_533]) }; __ret } } else { aiur_fn_533(__args, record, io_buffer, __cu)? } }; + let __r_arr: [G; OUT_529] = { let __args: [G; IN_529] = [__v_12, __v_13, __v_14, __v_15]; let __cu = unconstrained; if let Some(result) = record.function_queries[529].get_mut(&__args[..]) { if !__cu && *result.multiplicity == G::ZERO { aiur_fn_529(__args, record, io_buffer, false)? } else { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_529] = unsafe { *(result.output.as_ptr() as *const [G; OUT_529]) }; __ret } } else { aiur_fn_529(__args, record, io_buffer, __cu)? } }; let __v_16: G = __r_arr[0]; let __v_17: G = __r_arr[1]; - let __r_arr: [G; OUT_533] = { let __args: [G; IN_533] = [__v_9, __v_10, __v_16, __v_17]; let __cu = unconstrained; if let Some(result) = record.function_queries[533].get_mut(&__args[..]) { if !__cu && *result.multiplicity == G::ZERO { aiur_fn_533(__args, record, io_buffer, false)? } else { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_533] = unsafe { *(result.output.as_ptr() as *const [G; OUT_533]) }; __ret } } else { aiur_fn_533(__args, record, io_buffer, __cu)? } }; + let __r_arr: [G; OUT_529] = { let __args: [G; IN_529] = [__v_9, __v_10, __v_16, __v_17]; let __cu = unconstrained; if let Some(result) = record.function_queries[529].get_mut(&__args[..]) { if !__cu && *result.multiplicity == G::ZERO { aiur_fn_529(__args, record, io_buffer, false)? } else { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_529] = unsafe { *(result.output.as_ptr() as *const [G; OUT_529]) }; __ret } } else { aiur_fn_529(__args, record, io_buffer, __cu)? } }; let __v_18: G = __r_arr[0]; let __v_19: G = __r_arr[1]; - let __ret: [G; OUT_547] = [__v_18, __v_19]; - if let Some(result) = record.function_queries[547].get_mut(&inp[..]) { debug_assert_eq!(result.output, &__ret[..]); if !unconstrained { *result.multiplicity += G::ONE; } } else { record.function_queries[547].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained)); }; + let __ret: [G; OUT_543] = [__v_18, __v_19]; + if let Some(result) = record.function_queries[543].get_mut(&inp[..]) { debug_assert_eq!(result.output, &__ret[..]); if !unconstrained { *result.multiplicity += G::ONE; } } else { record.function_queries[543].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained)); }; return Ok(__ret); }, _ => { - let __r_arr: [G; OUT_532] = { let __args: [G; IN_532] = []; let __cu = unconstrained; if let Some(result) = record.function_queries[532].get_mut(&__args[..]) { if !__cu && *result.multiplicity == G::ZERO { aiur_fn_532(__args, record, io_buffer, false)? } else { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_532] = unsafe { *(result.output.as_ptr() as *const [G; OUT_532]) }; __ret } } else { aiur_fn_532(__args, record, io_buffer, __cu)? } }; + let __r_arr: [G; OUT_528] = { let __args: [G; IN_528] = []; let __cu = unconstrained; if let Some(result) = record.function_queries[528].get_mut(&__args[..]) { if !__cu && *result.multiplicity == G::ZERO { aiur_fn_528(__args, record, io_buffer, false)? } else { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_528] = unsafe { *(result.output.as_ptr() as *const [G; OUT_528]) }; __ret } } else { aiur_fn_528(__args, record, io_buffer, __cu)? } }; let __v_9: G = __r_arr[0]; let __v_10: G = __r_arr[1]; - let __ret: [G; OUT_547] = [__v_9, __v_10]; - if let Some(result) = record.function_queries[547].get_mut(&inp[..]) { debug_assert_eq!(result.output, &__ret[..]); if !unconstrained { *result.multiplicity += G::ONE; } } else { record.function_queries[547].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained)); }; + let __ret: [G; OUT_543] = [__v_9, __v_10]; + if let Some(result) = record.function_queries[543].get_mut(&inp[..]) { debug_assert_eq!(result.output, &__ret[..]); if !unconstrained { *result.multiplicity += G::ONE; } } else { record.function_queries[543].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained)); }; return Ok(__ret); }, } @@ -47585,15 +47301,15 @@ fn aiur_fn_547( }) } -const INPUT_SIZE_548: usize = 7; -const IN_548: usize = 7; -const OUT_548: usize = 2; -fn aiur_fn_548( - inp: [G; IN_548], +const INPUT_SIZE_544: usize = 7; +const IN_544: usize = 7; +const OUT_544: usize = 2; +fn aiur_fn_544( + inp: [G; IN_544], record: &mut QueryRecord, io_buffer: &mut IOBuffer, unconstrained: bool, -) -> Result<[G; OUT_548], ExecError> { +) -> Result<[G; OUT_544], ExecError> { stacker::maybe_grow(64 * 1024, 4 * 1024 * 1024, || { let __v_0: G = inp[0]; let __v_1: G = inp[1]; @@ -47606,19 +47322,19 @@ fn aiur_fn_548( _ => { match __v_3.as_canonical_u64() { _ => { - let __r_arr: [G; OUT_528] = { let __args: [G; IN_528] = [__v_1, __v_4]; let __cu = unconstrained; if let Some(result) = record.function_queries[528].get_mut(&__args[..]) { if !__cu && *result.multiplicity == G::ZERO { aiur_fn_528(__args, record, io_buffer, false)? } else { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_528] = unsafe { *(result.output.as_ptr() as *const [G; OUT_528]) }; __ret } } else { aiur_fn_528(__args, record, io_buffer, __cu)? } }; + let __r_arr: [G; OUT_524] = { let __args: [G; IN_524] = [__v_1, __v_4]; let __cu = unconstrained; if let Some(result) = record.function_queries[524].get_mut(&__args[..]) { if !__cu && *result.multiplicity == G::ZERO { aiur_fn_524(__args, record, io_buffer, false)? } else { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_524] = unsafe { *(result.output.as_ptr() as *const [G; OUT_524]) }; __ret } } else { aiur_fn_524(__args, record, io_buffer, __cu)? } }; let __v_7: G = __r_arr[0]; - let __r_arr: [G; OUT_534] = { let __args: [G; IN_534] = [__v_7]; let __cu = unconstrained; if let Some(result) = record.function_queries[534].get_mut(&__args[..]) { if !__cu && *result.multiplicity == G::ZERO { aiur_fn_534(__args, record, io_buffer, false)? } else { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_534] = unsafe { *(result.output.as_ptr() as *const [G; OUT_534]) }; __ret } } else { aiur_fn_534(__args, record, io_buffer, __cu)? } }; + let __r_arr: [G; OUT_530] = { let __args: [G; IN_530] = [__v_7]; let __cu = unconstrained; if let Some(result) = record.function_queries[530].get_mut(&__args[..]) { if !__cu && *result.multiplicity == G::ZERO { aiur_fn_530(__args, record, io_buffer, false)? } else { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_530] = unsafe { *(result.output.as_ptr() as *const [G; OUT_530]) }; __ret } } else { aiur_fn_530(__args, record, io_buffer, __cu)? } }; let __v_8: G = __r_arr[0]; let __v_9: G = __r_arr[1]; - let __r_arr: [G; OUT_546] = { let __args: [G; IN_546] = [__v_2, __v_5, __v_6]; let __cu = unconstrained; if let Some(result) = record.function_queries[546].get_mut(&__args[..]) { if !__cu && *result.multiplicity == G::ZERO { aiur_fn_546(__args, record, io_buffer, false)? } else { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_546] = unsafe { *(result.output.as_ptr() as *const [G; OUT_546]) }; __ret } } else { aiur_fn_546(__args, record, io_buffer, __cu)? } }; + let __r_arr: [G; OUT_542] = { let __args: [G; IN_542] = [__v_2, __v_5, __v_6]; let __cu = unconstrained; if let Some(result) = record.function_queries[542].get_mut(&__args[..]) { if !__cu && *result.multiplicity == G::ZERO { aiur_fn_542(__args, record, io_buffer, false)? } else { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_542] = unsafe { *(result.output.as_ptr() as *const [G; OUT_542]) }; __ret } } else { aiur_fn_542(__args, record, io_buffer, __cu)? } }; let __v_10: G = __r_arr[0]; let __v_11: G = __r_arr[1]; - let __r_arr: [G; OUT_533] = { let __args: [G; IN_533] = [__v_8, __v_9, __v_10, __v_11]; let __cu = unconstrained; if let Some(result) = record.function_queries[533].get_mut(&__args[..]) { if !__cu && *result.multiplicity == G::ZERO { aiur_fn_533(__args, record, io_buffer, false)? } else { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_533] = unsafe { *(result.output.as_ptr() as *const [G; OUT_533]) }; __ret } } else { aiur_fn_533(__args, record, io_buffer, __cu)? } }; + let __r_arr: [G; OUT_529] = { let __args: [G; IN_529] = [__v_8, __v_9, __v_10, __v_11]; let __cu = unconstrained; if let Some(result) = record.function_queries[529].get_mut(&__args[..]) { if !__cu && *result.multiplicity == G::ZERO { aiur_fn_529(__args, record, io_buffer, false)? } else { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_529] = unsafe { *(result.output.as_ptr() as *const [G; OUT_529]) }; __ret } } else { aiur_fn_529(__args, record, io_buffer, __cu)? } }; let __v_12: G = __r_arr[0]; let __v_13: G = __r_arr[1]; - let __ret: [G; OUT_548] = [__v_12, __v_13]; - if let Some(result) = record.function_queries[548].get_mut(&inp[..]) { debug_assert_eq!(result.output, &__ret[..]); if !unconstrained { *result.multiplicity += G::ONE; } } else { record.function_queries[548].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained)); }; + let __ret: [G; OUT_544] = [__v_12, __v_13]; + if let Some(result) = record.function_queries[544].get_mut(&inp[..]) { debug_assert_eq!(result.output, &__ret[..]); if !unconstrained { *result.multiplicity += G::ONE; } } else { record.function_queries[544].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained)); }; return Ok(__ret); }, } @@ -47627,15 +47343,15 @@ fn aiur_fn_548( }) } -const INPUT_SIZE_549: usize = 3; -const IN_549: usize = 3; -const OUT_549: usize = 2; -fn aiur_fn_549( - inp: [G; IN_549], +const INPUT_SIZE_545: usize = 3; +const IN_545: usize = 3; +const OUT_545: usize = 2; +fn aiur_fn_545( + inp: [G; IN_545], record: &mut QueryRecord, io_buffer: &mut IOBuffer, unconstrained: bool, -) -> Result<[G; OUT_549], ExecError> { +) -> Result<[G; OUT_545], ExecError> { stacker::maybe_grow(64 * 1024, 4 * 1024 * 1024, || { let __v_0: G = inp[0]; let __v_1: G = inp[1]; @@ -47656,19 +47372,19 @@ fn aiur_fn_549( let __v_12: G = __loaded[4]; match __v_8.as_canonical_u64() { 1u64 => { - let __r_arr: [G; OUT_531] = { let __args: [G; IN_531] = []; let __cu = unconstrained; if let Some(result) = record.function_queries[531].get_mut(&__args[..]) { if !__cu && *result.multiplicity == G::ZERO { aiur_fn_531(__args, record, io_buffer, false)? } else { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_531] = unsafe { *(result.output.as_ptr() as *const [G; OUT_531]) }; __ret } } else { aiur_fn_531(__args, record, io_buffer, __cu)? } }; + let __r_arr: [G; OUT_527] = { let __args: [G; IN_527] = []; let __cu = unconstrained; if let Some(result) = record.function_queries[527].get_mut(&__args[..]) { if !__cu && *result.multiplicity == G::ZERO { aiur_fn_527(__args, record, io_buffer, false)? } else { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_527] = unsafe { *(result.output.as_ptr() as *const [G; OUT_527]) }; __ret } } else { aiur_fn_527(__args, record, io_buffer, __cu)? } }; let __v_13: G = __r_arr[0]; let __v_14: G = __r_arr[1]; - let __ret: [G; OUT_549] = [__v_13, __v_14]; - if let Some(result) = record.function_queries[549].get_mut(&inp[..]) { debug_assert_eq!(result.output, &__ret[..]); if !unconstrained { *result.multiplicity += G::ONE; } } else { record.function_queries[549].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained)); }; + let __ret: [G; OUT_545] = [__v_13, __v_14]; + if let Some(result) = record.function_queries[545].get_mut(&inp[..]) { debug_assert_eq!(result.output, &__ret[..]); if !unconstrained { *result.multiplicity += G::ONE; } } else { record.function_queries[545].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained)); }; return Ok(__ret); }, _ => { - let __r_arr: [G; OUT_530] = { let __args: [G; IN_530] = []; let __cu = unconstrained; if let Some(result) = record.function_queries[530].get_mut(&__args[..]) { if !__cu && *result.multiplicity == G::ZERO { aiur_fn_530(__args, record, io_buffer, false)? } else { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_530] = unsafe { *(result.output.as_ptr() as *const [G; OUT_530]) }; __ret } } else { aiur_fn_530(__args, record, io_buffer, __cu)? } }; + let __r_arr: [G; OUT_526] = { let __args: [G; IN_526] = []; let __cu = unconstrained; if let Some(result) = record.function_queries[526].get_mut(&__args[..]) { if !__cu && *result.multiplicity == G::ZERO { aiur_fn_526(__args, record, io_buffer, false)? } else { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_526] = unsafe { *(result.output.as_ptr() as *const [G; OUT_526]) }; __ret } } else { aiur_fn_526(__args, record, io_buffer, __cu)? } }; let __v_13: G = __r_arr[0]; let __v_14: G = __r_arr[1]; - let __ret: [G; OUT_549] = [__v_13, __v_14]; - if let Some(result) = record.function_queries[549].get_mut(&inp[..]) { debug_assert_eq!(result.output, &__ret[..]); if !unconstrained { *result.multiplicity += G::ONE; } } else { record.function_queries[549].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained)); }; + let __ret: [G; OUT_545] = [__v_13, __v_14]; + if let Some(result) = record.function_queries[545].get_mut(&inp[..]) { debug_assert_eq!(result.output, &__ret[..]); if !unconstrained { *result.multiplicity += G::ONE; } } else { record.function_queries[545].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained)); }; return Ok(__ret); }, } @@ -47682,25 +47398,25 @@ fn aiur_fn_549( let __v_12: G = __loaded[4]; match __v_8.as_canonical_u64() { 1u64 => { - let __r_arr: [G; OUT_532] = { let __args: [G; IN_532] = []; let __cu = unconstrained; if let Some(result) = record.function_queries[532].get_mut(&__args[..]) { if !__cu && *result.multiplicity == G::ZERO { aiur_fn_532(__args, record, io_buffer, false)? } else { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_532] = unsafe { *(result.output.as_ptr() as *const [G; OUT_532]) }; __ret } } else { aiur_fn_532(__args, record, io_buffer, __cu)? } }; + let __r_arr: [G; OUT_528] = { let __args: [G; IN_528] = []; let __cu = unconstrained; if let Some(result) = record.function_queries[528].get_mut(&__args[..]) { if !__cu && *result.multiplicity == G::ZERO { aiur_fn_528(__args, record, io_buffer, false)? } else { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_528] = unsafe { *(result.output.as_ptr() as *const [G; OUT_528]) }; __ret } } else { aiur_fn_528(__args, record, io_buffer, __cu)? } }; let __v_13: G = __r_arr[0]; let __v_14: G = __r_arr[1]; - let __ret: [G; OUT_549] = [__v_13, __v_14]; - if let Some(result) = record.function_queries[549].get_mut(&inp[..]) { debug_assert_eq!(result.output, &__ret[..]); if !unconstrained { *result.multiplicity += G::ONE; } } else { record.function_queries[549].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained)); }; + let __ret: [G; OUT_545] = [__v_13, __v_14]; + if let Some(result) = record.function_queries[545].get_mut(&inp[..]) { debug_assert_eq!(result.output, &__ret[..]); if !unconstrained { *result.multiplicity += G::ONE; } } else { record.function_queries[545].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained)); }; return Ok(__ret); }, 0u64 => { - let __r_arr: [G; OUT_548] = { let __args: [G; IN_548] = [__v_4, __v_5, __v_6, __v_9, __v_10, __v_11, __v_2]; let __cu = unconstrained; if let Some(result) = record.function_queries[548].get_mut(&__args[..]) { if !__cu && *result.multiplicity == G::ZERO { aiur_fn_548(__args, record, io_buffer, false)? } else { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_548] = unsafe { *(result.output.as_ptr() as *const [G; OUT_548]) }; __ret } } else { aiur_fn_548(__args, record, io_buffer, __cu)? } }; + let __r_arr: [G; OUT_544] = { let __args: [G; IN_544] = [__v_4, __v_5, __v_6, __v_9, __v_10, __v_11, __v_2]; let __cu = unconstrained; if let Some(result) = record.function_queries[544].get_mut(&__args[..]) { if !__cu && *result.multiplicity == G::ZERO { aiur_fn_544(__args, record, io_buffer, false)? } else { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_544] = unsafe { *(result.output.as_ptr() as *const [G; OUT_544]) }; __ret } } else { aiur_fn_544(__args, record, io_buffer, __cu)? } }; let __v_13: G = __r_arr[0]; let __v_14: G = __r_arr[1]; - let __r_arr: [G; OUT_549] = { let __args: [G; IN_549] = [__v_7, __v_12, __v_2]; let __cu = unconstrained; if let Some(result) = record.function_queries[549].get_mut(&__args[..]) { if !__cu && *result.multiplicity == G::ZERO { aiur_fn_549(__args, record, io_buffer, false)? } else { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_549] = unsafe { *(result.output.as_ptr() as *const [G; OUT_549]) }; __ret } } else { aiur_fn_549(__args, record, io_buffer, __cu)? } }; + let __r_arr: [G; OUT_545] = { let __args: [G; IN_545] = [__v_7, __v_12, __v_2]; let __cu = unconstrained; if let Some(result) = record.function_queries[545].get_mut(&__args[..]) { if !__cu && *result.multiplicity == G::ZERO { aiur_fn_545(__args, record, io_buffer, false)? } else { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_545] = unsafe { *(result.output.as_ptr() as *const [G; OUT_545]) }; __ret } } else { aiur_fn_545(__args, record, io_buffer, __cu)? } }; let __v_15: G = __r_arr[0]; let __v_16: G = __r_arr[1]; - let __r_arr: [G; OUT_533] = { let __args: [G; IN_533] = [__v_13, __v_14, __v_15, __v_16]; let __cu = unconstrained; if let Some(result) = record.function_queries[533].get_mut(&__args[..]) { if !__cu && *result.multiplicity == G::ZERO { aiur_fn_533(__args, record, io_buffer, false)? } else { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_533] = unsafe { *(result.output.as_ptr() as *const [G; OUT_533]) }; __ret } } else { aiur_fn_533(__args, record, io_buffer, __cu)? } }; + let __r_arr: [G; OUT_529] = { let __args: [G; IN_529] = [__v_13, __v_14, __v_15, __v_16]; let __cu = unconstrained; if let Some(result) = record.function_queries[529].get_mut(&__args[..]) { if !__cu && *result.multiplicity == G::ZERO { aiur_fn_529(__args, record, io_buffer, false)? } else { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_529] = unsafe { *(result.output.as_ptr() as *const [G; OUT_529]) }; __ret } } else { aiur_fn_529(__args, record, io_buffer, __cu)? } }; let __v_17: G = __r_arr[0]; let __v_18: G = __r_arr[1]; - let __ret: [G; OUT_549] = [__v_17, __v_18]; - if let Some(result) = record.function_queries[549].get_mut(&inp[..]) { debug_assert_eq!(result.output, &__ret[..]); if !unconstrained { *result.multiplicity += G::ONE; } } else { record.function_queries[549].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained)); }; + let __ret: [G; OUT_545] = [__v_17, __v_18]; + if let Some(result) = record.function_queries[545].get_mut(&inp[..]) { debug_assert_eq!(result.output, &__ret[..]); if !unconstrained { *result.multiplicity += G::ONE; } } else { record.function_queries[545].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained)); }; return Ok(__ret); }, _ => { @@ -47715,15 +47431,15 @@ fn aiur_fn_549( }) } -const INPUT_SIZE_550: usize = 12; -const IN_550: usize = 12; -const OUT_550: usize = 1; -fn aiur_fn_550( - inp: [G; IN_550], +const INPUT_SIZE_546: usize = 12; +const IN_546: usize = 12; +const OUT_546: usize = 1; +fn aiur_fn_546( + inp: [G; IN_546], record: &mut QueryRecord, io_buffer: &mut IOBuffer, unconstrained: bool, -) -> Result<[G; OUT_550], ExecError> { +) -> Result<[G; OUT_546], ExecError> { stacker::maybe_grow(64 * 1024, 4 * 1024 * 1024, || { let __v_0: G = inp[0]; let __v_1: G = inp[1]; @@ -47740,50 +47456,50 @@ fn aiur_fn_550( match __v_0.as_canonical_u64() { 1u64 => { let __v_12: G = G::from_u64(0); - let __ret: [G; OUT_550] = [__v_12]; - if let Some(result) = record.function_queries[550].get_mut(&inp[..]) { debug_assert_eq!(result.output, &__ret[..]); if !unconstrained { *result.multiplicity += G::ONE; } } else { record.function_queries[550].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained)); }; + let __ret: [G; OUT_546] = [__v_12]; + if let Some(result) = record.function_queries[546].get_mut(&inp[..]) { debug_assert_eq!(result.output, &__ret[..]); if !unconstrained { *result.multiplicity += G::ONE; } } else { record.function_queries[546].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained)); }; return Ok(__ret); }, 2u64 => { let __v_12: G = G::from_u64(0); - let __ret: [G; OUT_550] = [__v_12]; - if let Some(result) = record.function_queries[550].get_mut(&inp[..]) { debug_assert_eq!(result.output, &__ret[..]); if !unconstrained { *result.multiplicity += G::ONE; } } else { record.function_queries[550].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained)); }; + let __ret: [G; OUT_546] = [__v_12]; + if let Some(result) = record.function_queries[546].get_mut(&inp[..]) { debug_assert_eq!(result.output, &__ret[..]); if !unconstrained { *result.multiplicity += G::ONE; } } else { record.function_queries[546].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained)); }; return Ok(__ret); }, 3u64 => { let __v_12: G = G::from_u64(0); - let __ret: [G; OUT_550] = [__v_12]; - if let Some(result) = record.function_queries[550].get_mut(&inp[..]) { debug_assert_eq!(result.output, &__ret[..]); if !unconstrained { *result.multiplicity += G::ONE; } } else { record.function_queries[550].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained)); }; + let __ret: [G; OUT_546] = [__v_12]; + if let Some(result) = record.function_queries[546].get_mut(&inp[..]) { debug_assert_eq!(result.output, &__ret[..]); if !unconstrained { *result.multiplicity += G::ONE; } } else { record.function_queries[546].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained)); }; return Ok(__ret); }, 5u64 => { let __v_12: G = G::from_u64(1); - let __ret: [G; OUT_550] = [__v_12]; - if let Some(result) = record.function_queries[550].get_mut(&inp[..]) { debug_assert_eq!(result.output, &__ret[..]); if !unconstrained { *result.multiplicity += G::ONE; } } else { record.function_queries[550].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained)); }; + let __ret: [G; OUT_546] = [__v_12]; + if let Some(result) = record.function_queries[546].get_mut(&inp[..]) { debug_assert_eq!(result.output, &__ret[..]); if !unconstrained { *result.multiplicity += G::ONE; } } else { record.function_queries[546].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained)); }; return Ok(__ret); }, 7u64 => { let __v_12: G = G::from_u64(2); - let __ret: [G; OUT_550] = [__v_12]; - if let Some(result) = record.function_queries[550].get_mut(&inp[..]) { debug_assert_eq!(result.output, &__ret[..]); if !unconstrained { *result.multiplicity += G::ONE; } } else { record.function_queries[550].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained)); }; + let __ret: [G; OUT_546] = [__v_12]; + if let Some(result) = record.function_queries[546].get_mut(&inp[..]) { debug_assert_eq!(result.output, &__ret[..]); if !unconstrained { *result.multiplicity += G::ONE; } } else { record.function_queries[546].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained)); }; return Ok(__ret); }, 6u64 => { let __v_12: G = G::from_u64(3); - let __ret: [G; OUT_550] = [__v_12]; - if let Some(result) = record.function_queries[550].get_mut(&inp[..]) { debug_assert_eq!(result.output, &__ret[..]); if !unconstrained { *result.multiplicity += G::ONE; } } else { record.function_queries[550].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained)); }; + let __ret: [G; OUT_546] = [__v_12]; + if let Some(result) = record.function_queries[546].get_mut(&inp[..]) { debug_assert_eq!(result.output, &__ret[..]); if !unconstrained { *result.multiplicity += G::ONE; } } else { record.function_queries[546].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained)); }; return Ok(__ret); }, 0u64 => { let __v_12: G = G::from_u64(4); - let __ret: [G; OUT_550] = [__v_12]; - if let Some(result) = record.function_queries[550].get_mut(&inp[..]) { debug_assert_eq!(result.output, &__ret[..]); if !unconstrained { *result.multiplicity += G::ONE; } } else { record.function_queries[550].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained)); }; + let __ret: [G; OUT_546] = [__v_12]; + if let Some(result) = record.function_queries[546].get_mut(&inp[..]) { debug_assert_eq!(result.output, &__ret[..]); if !unconstrained { *result.multiplicity += G::ONE; } } else { record.function_queries[546].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained)); }; return Ok(__ret); }, 4u64 => { let __v_12: G = G::from_u64(5); - let __ret: [G; OUT_550] = [__v_12]; - if let Some(result) = record.function_queries[550].get_mut(&inp[..]) { debug_assert_eq!(result.output, &__ret[..]); if !unconstrained { *result.multiplicity += G::ONE; } } else { record.function_queries[550].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained)); }; + let __ret: [G; OUT_546] = [__v_12]; + if let Some(result) = record.function_queries[546].get_mut(&inp[..]) { debug_assert_eq!(result.output, &__ret[..]); if !unconstrained { *result.multiplicity += G::ONE; } } else { record.function_queries[546].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained)); }; return Ok(__ret); }, _ => { @@ -47793,15 +47509,15 @@ fn aiur_fn_550( }) } -const INPUT_SIZE_551: usize = 25; -const IN_551: usize = 25; -const OUT_551: usize = 2; -fn aiur_fn_551( - inp: [G; IN_551], +const INPUT_SIZE_547: usize = 25; +const IN_547: usize = 25; +const OUT_547: usize = 2; +fn aiur_fn_547( + inp: [G; IN_547], record: &mut QueryRecord, io_buffer: &mut IOBuffer, unconstrained: bool, -) -> Result<[G; OUT_551], ExecError> { +) -> Result<[G; OUT_547], ExecError> { stacker::maybe_grow(64 * 1024, 4 * 1024 * 1024, || { let __v_0: G = inp[0]; let __v_1: G = inp[1]; @@ -47828,42 +47544,42 @@ fn aiur_fn_551( let __v_22: G = inp[22]; let __v_23: G = inp[23]; let __v_24: G = inp[24]; - let __r_arr: [G; OUT_550] = { let __args: [G; IN_550] = [__v_0, __v_1, __v_2, __v_3, __v_4, __v_5, __v_6, __v_7, __v_8, __v_9, __v_10, __v_11]; let __cu = unconstrained; if let Some(result) = record.function_queries[550].get_mut(&__args[..]) { if !__cu && *result.multiplicity == G::ZERO { aiur_fn_550(__args, record, io_buffer, false)? } else { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_550] = unsafe { *(result.output.as_ptr() as *const [G; OUT_550]) }; __ret } } else { aiur_fn_550(__args, record, io_buffer, __cu)? } }; + let __r_arr: [G; OUT_546] = { let __args: [G; IN_546] = [__v_0, __v_1, __v_2, __v_3, __v_4, __v_5, __v_6, __v_7, __v_8, __v_9, __v_10, __v_11]; let __cu = unconstrained; if let Some(result) = record.function_queries[546].get_mut(&__args[..]) { if !__cu && *result.multiplicity == G::ZERO { aiur_fn_546(__args, record, io_buffer, false)? } else { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_546] = unsafe { *(result.output.as_ptr() as *const [G; OUT_546]) }; __ret } } else { aiur_fn_546(__args, record, io_buffer, __cu)? } }; let __v_25: G = __r_arr[0]; - let __r_arr: [G; OUT_550] = { let __args: [G; IN_550] = [__v_12, __v_13, __v_14, __v_15, __v_16, __v_17, __v_18, __v_19, __v_20, __v_21, __v_22, __v_23]; let __cu = unconstrained; if let Some(result) = record.function_queries[550].get_mut(&__args[..]) { if !__cu && *result.multiplicity == G::ZERO { aiur_fn_550(__args, record, io_buffer, false)? } else { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_550] = unsafe { *(result.output.as_ptr() as *const [G; OUT_550]) }; __ret } } else { aiur_fn_550(__args, record, io_buffer, __cu)? } }; + let __r_arr: [G; OUT_546] = { let __args: [G; IN_546] = [__v_12, __v_13, __v_14, __v_15, __v_16, __v_17, __v_18, __v_19, __v_20, __v_21, __v_22, __v_23]; let __cu = unconstrained; if let Some(result) = record.function_queries[546].get_mut(&__args[..]) { if !__cu && *result.multiplicity == G::ZERO { aiur_fn_546(__args, record, io_buffer, false)? } else { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_546] = unsafe { *(result.output.as_ptr() as *const [G; OUT_546]) }; __ret } } else { aiur_fn_546(__args, record, io_buffer, __cu)? } }; let __v_26: G = __r_arr[0]; - let __r_arr: [G; OUT_528] = { let __args: [G; IN_528] = [__v_25, __v_26]; let __cu = unconstrained; if let Some(result) = record.function_queries[528].get_mut(&__args[..]) { if !__cu && *result.multiplicity == G::ZERO { aiur_fn_528(__args, record, io_buffer, false)? } else { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_528] = unsafe { *(result.output.as_ptr() as *const [G; OUT_528]) }; __ret } } else { aiur_fn_528(__args, record, io_buffer, __cu)? } }; + let __r_arr: [G; OUT_524] = { let __args: [G; IN_524] = [__v_25, __v_26]; let __cu = unconstrained; if let Some(result) = record.function_queries[524].get_mut(&__args[..]) { if !__cu && *result.multiplicity == G::ZERO { aiur_fn_524(__args, record, io_buffer, false)? } else { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_524] = unsafe { *(result.output.as_ptr() as *const [G; OUT_524]) }; __ret } } else { aiur_fn_524(__args, record, io_buffer, __cu)? } }; let __v_27: G = __r_arr[0]; match __v_27.as_canonical_u64() { 1u64 => { - let __r_arr: [G; OUT_552] = { let __args: [G; IN_552] = [__v_0, __v_1, __v_2, __v_3, __v_4, __v_5, __v_6, __v_7, __v_8, __v_9, __v_10, __v_11, __v_12, __v_13, __v_14, __v_15, __v_16, __v_17, __v_18, __v_19, __v_20, __v_21, __v_22, __v_23, __v_24]; let __cu = unconstrained; if let Some(result) = record.function_queries[552].get_mut(&__args[..]) { if !__cu && *result.multiplicity == G::ZERO { aiur_fn_552(__args, record, io_buffer, false)? } else { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_552] = unsafe { *(result.output.as_ptr() as *const [G; OUT_552]) }; __ret } } else { aiur_fn_552(__args, record, io_buffer, __cu)? } }; + let __r_arr: [G; OUT_548] = { let __args: [G; IN_548] = [__v_0, __v_1, __v_2, __v_3, __v_4, __v_5, __v_6, __v_7, __v_8, __v_9, __v_10, __v_11, __v_12, __v_13, __v_14, __v_15, __v_16, __v_17, __v_18, __v_19, __v_20, __v_21, __v_22, __v_23, __v_24]; let __cu = unconstrained; if let Some(result) = record.function_queries[548].get_mut(&__args[..]) { if !__cu && *result.multiplicity == G::ZERO { aiur_fn_548(__args, record, io_buffer, false)? } else { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_548] = unsafe { *(result.output.as_ptr() as *const [G; OUT_548]) }; __ret } } else { aiur_fn_548(__args, record, io_buffer, __cu)? } }; let __v_28: G = __r_arr[0]; let __v_29: G = __r_arr[1]; - let __ret: [G; OUT_551] = [__v_28, __v_29]; - if let Some(result) = record.function_queries[551].get_mut(&inp[..]) { debug_assert_eq!(result.output, &__ret[..]); if !unconstrained { *result.multiplicity += G::ONE; } } else { record.function_queries[551].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained)); }; + let __ret: [G; OUT_547] = [__v_28, __v_29]; + if let Some(result) = record.function_queries[547].get_mut(&inp[..]) { debug_assert_eq!(result.output, &__ret[..]); if !unconstrained { *result.multiplicity += G::ONE; } } else { record.function_queries[547].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained)); }; return Ok(__ret); }, _ => { - let __r_arr: [G; OUT_534] = { let __args: [G; IN_534] = [__v_27]; let __cu = unconstrained; if let Some(result) = record.function_queries[534].get_mut(&__args[..]) { if !__cu && *result.multiplicity == G::ZERO { aiur_fn_534(__args, record, io_buffer, false)? } else { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_534] = unsafe { *(result.output.as_ptr() as *const [G; OUT_534]) }; __ret } } else { aiur_fn_534(__args, record, io_buffer, __cu)? } }; + let __r_arr: [G; OUT_530] = { let __args: [G; IN_530] = [__v_27]; let __cu = unconstrained; if let Some(result) = record.function_queries[530].get_mut(&__args[..]) { if !__cu && *result.multiplicity == G::ZERO { aiur_fn_530(__args, record, io_buffer, false)? } else { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_530] = unsafe { *(result.output.as_ptr() as *const [G; OUT_530]) }; __ret } } else { aiur_fn_530(__args, record, io_buffer, __cu)? } }; let __v_28: G = __r_arr[0]; let __v_29: G = __r_arr[1]; - let __ret: [G; OUT_551] = [__v_28, __v_29]; - if let Some(result) = record.function_queries[551].get_mut(&inp[..]) { debug_assert_eq!(result.output, &__ret[..]); if !unconstrained { *result.multiplicity += G::ONE; } } else { record.function_queries[551].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained)); }; + let __ret: [G; OUT_547] = [__v_28, __v_29]; + if let Some(result) = record.function_queries[547].get_mut(&inp[..]) { debug_assert_eq!(result.output, &__ret[..]); if !unconstrained { *result.multiplicity += G::ONE; } } else { record.function_queries[547].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained)); }; return Ok(__ret); }, } }) } -const INPUT_SIZE_552: usize = 25; -const IN_552: usize = 25; -const OUT_552: usize = 2; -fn aiur_fn_552( - inp: [G; IN_552], +const INPUT_SIZE_548: usize = 25; +const IN_548: usize = 25; +const OUT_548: usize = 2; +fn aiur_fn_548( + inp: [G; IN_548], record: &mut QueryRecord, io_buffer: &mut IOBuffer, unconstrained: bool, -) -> Result<[G; OUT_552], ExecError> { +) -> Result<[G; OUT_548], ExecError> { stacker::maybe_grow(64 * 1024, 4 * 1024 * 1024, || { let __v_0: G = inp[0]; let __v_1: G = inp[1]; @@ -47894,33 +47610,33 @@ fn aiur_fn_552( 1u64 => { match __v_12.as_canonical_u64() { 1u64 => { - let __r_arr: [G; OUT_528] = { let __args: [G; IN_528] = [__v_1, __v_13]; let __cu = unconstrained; if let Some(result) = record.function_queries[528].get_mut(&__args[..]) { if !__cu && *result.multiplicity == G::ZERO { aiur_fn_528(__args, record, io_buffer, false)? } else { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_528] = unsafe { *(result.output.as_ptr() as *const [G; OUT_528]) }; __ret } } else { aiur_fn_528(__args, record, io_buffer, __cu)? } }; + let __r_arr: [G; OUT_524] = { let __args: [G; IN_524] = [__v_1, __v_13]; let __cu = unconstrained; if let Some(result) = record.function_queries[524].get_mut(&__args[..]) { if !__cu && *result.multiplicity == G::ZERO { aiur_fn_524(__args, record, io_buffer, false)? } else { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_524] = unsafe { *(result.output.as_ptr() as *const [G; OUT_524]) }; __ret } } else { aiur_fn_524(__args, record, io_buffer, __cu)? } }; let __v_25: G = __r_arr[0]; - let __r_arr: [G; OUT_534] = { let __args: [G; IN_534] = [__v_25]; let __cu = unconstrained; if let Some(result) = record.function_queries[534].get_mut(&__args[..]) { if !__cu && *result.multiplicity == G::ZERO { aiur_fn_534(__args, record, io_buffer, false)? } else { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_534] = unsafe { *(result.output.as_ptr() as *const [G; OUT_534]) }; __ret } } else { aiur_fn_534(__args, record, io_buffer, __cu)? } }; + let __r_arr: [G; OUT_530] = { let __args: [G; IN_530] = [__v_25]; let __cu = unconstrained; if let Some(result) = record.function_queries[530].get_mut(&__args[..]) { if !__cu && *result.multiplicity == G::ZERO { aiur_fn_530(__args, record, io_buffer, false)? } else { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_530] = unsafe { *(result.output.as_ptr() as *const [G; OUT_530]) }; __ret } } else { aiur_fn_530(__args, record, io_buffer, __cu)? } }; let __v_26: G = __r_arr[0]; let __v_27: G = __r_arr[1]; - let __r_arr: [G; OUT_546] = { let __args: [G; IN_546] = [__v_2, __v_14, __v_24]; let __cu = unconstrained; if let Some(result) = record.function_queries[546].get_mut(&__args[..]) { if !__cu && *result.multiplicity == G::ZERO { aiur_fn_546(__args, record, io_buffer, false)? } else { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_546] = unsafe { *(result.output.as_ptr() as *const [G; OUT_546]) }; __ret } } else { aiur_fn_546(__args, record, io_buffer, __cu)? } }; + let __r_arr: [G; OUT_542] = { let __args: [G; IN_542] = [__v_2, __v_14, __v_24]; let __cu = unconstrained; if let Some(result) = record.function_queries[542].get_mut(&__args[..]) { if !__cu && *result.multiplicity == G::ZERO { aiur_fn_542(__args, record, io_buffer, false)? } else { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_542] = unsafe { *(result.output.as_ptr() as *const [G; OUT_542]) }; __ret } } else { aiur_fn_542(__args, record, io_buffer, __cu)? } }; let __v_28: G = __r_arr[0]; let __v_29: G = __r_arr[1]; - let __r_arr: [G; OUT_546] = { let __args: [G; IN_546] = [__v_3, __v_15, __v_24]; let __cu = unconstrained; if let Some(result) = record.function_queries[546].get_mut(&__args[..]) { if !__cu && *result.multiplicity == G::ZERO { aiur_fn_546(__args, record, io_buffer, false)? } else { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_546] = unsafe { *(result.output.as_ptr() as *const [G; OUT_546]) }; __ret } } else { aiur_fn_546(__args, record, io_buffer, __cu)? } }; + let __r_arr: [G; OUT_542] = { let __args: [G; IN_542] = [__v_3, __v_15, __v_24]; let __cu = unconstrained; if let Some(result) = record.function_queries[542].get_mut(&__args[..]) { if !__cu && *result.multiplicity == G::ZERO { aiur_fn_542(__args, record, io_buffer, false)? } else { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_542] = unsafe { *(result.output.as_ptr() as *const [G; OUT_542]) }; __ret } } else { aiur_fn_542(__args, record, io_buffer, __cu)? } }; let __v_30: G = __r_arr[0]; let __v_31: G = __r_arr[1]; - let __r_arr: [G; OUT_533] = { let __args: [G; IN_533] = [__v_28, __v_29, __v_30, __v_31]; let __cu = unconstrained; if let Some(result) = record.function_queries[533].get_mut(&__args[..]) { if !__cu && *result.multiplicity == G::ZERO { aiur_fn_533(__args, record, io_buffer, false)? } else { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_533] = unsafe { *(result.output.as_ptr() as *const [G; OUT_533]) }; __ret } } else { aiur_fn_533(__args, record, io_buffer, __cu)? } }; + let __r_arr: [G; OUT_529] = { let __args: [G; IN_529] = [__v_28, __v_29, __v_30, __v_31]; let __cu = unconstrained; if let Some(result) = record.function_queries[529].get_mut(&__args[..]) { if !__cu && *result.multiplicity == G::ZERO { aiur_fn_529(__args, record, io_buffer, false)? } else { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_529] = unsafe { *(result.output.as_ptr() as *const [G; OUT_529]) }; __ret } } else { aiur_fn_529(__args, record, io_buffer, __cu)? } }; let __v_32: G = __r_arr[0]; let __v_33: G = __r_arr[1]; - let __r_arr: [G; OUT_533] = { let __args: [G; IN_533] = [__v_26, __v_27, __v_32, __v_33]; let __cu = unconstrained; if let Some(result) = record.function_queries[533].get_mut(&__args[..]) { if !__cu && *result.multiplicity == G::ZERO { aiur_fn_533(__args, record, io_buffer, false)? } else { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_533] = unsafe { *(result.output.as_ptr() as *const [G; OUT_533]) }; __ret } } else { aiur_fn_533(__args, record, io_buffer, __cu)? } }; + let __r_arr: [G; OUT_529] = { let __args: [G; IN_529] = [__v_26, __v_27, __v_32, __v_33]; let __cu = unconstrained; if let Some(result) = record.function_queries[529].get_mut(&__args[..]) { if !__cu && *result.multiplicity == G::ZERO { aiur_fn_529(__args, record, io_buffer, false)? } else { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_529] = unsafe { *(result.output.as_ptr() as *const [G; OUT_529]) }; __ret } } else { aiur_fn_529(__args, record, io_buffer, __cu)? } }; let __v_34: G = __r_arr[0]; let __v_35: G = __r_arr[1]; - let __ret: [G; OUT_552] = [__v_34, __v_35]; - if let Some(result) = record.function_queries[552].get_mut(&inp[..]) { debug_assert_eq!(result.output, &__ret[..]); if !unconstrained { *result.multiplicity += G::ONE; } } else { record.function_queries[552].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained)); }; + let __ret: [G; OUT_548] = [__v_34, __v_35]; + if let Some(result) = record.function_queries[548].get_mut(&inp[..]) { debug_assert_eq!(result.output, &__ret[..]); if !unconstrained { *result.multiplicity += G::ONE; } } else { record.function_queries[548].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained)); }; return Ok(__ret); }, _ => { - let __r_arr: [G; OUT_531] = { let __args: [G; IN_531] = []; let __cu = unconstrained; if let Some(result) = record.function_queries[531].get_mut(&__args[..]) { if !__cu && *result.multiplicity == G::ZERO { aiur_fn_531(__args, record, io_buffer, false)? } else { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_531] = unsafe { *(result.output.as_ptr() as *const [G; OUT_531]) }; __ret } } else { aiur_fn_531(__args, record, io_buffer, __cu)? } }; + let __r_arr: [G; OUT_527] = { let __args: [G; IN_527] = []; let __cu = unconstrained; if let Some(result) = record.function_queries[527].get_mut(&__args[..]) { if !__cu && *result.multiplicity == G::ZERO { aiur_fn_527(__args, record, io_buffer, false)? } else { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_527] = unsafe { *(result.output.as_ptr() as *const [G; OUT_527]) }; __ret } } else { aiur_fn_527(__args, record, io_buffer, __cu)? } }; let __v_25: G = __r_arr[0]; let __v_26: G = __r_arr[1]; - let __ret: [G; OUT_552] = [__v_25, __v_26]; - if let Some(result) = record.function_queries[552].get_mut(&inp[..]) { debug_assert_eq!(result.output, &__ret[..]); if !unconstrained { *result.multiplicity += G::ONE; } } else { record.function_queries[552].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained)); }; + let __ret: [G; OUT_548] = [__v_25, __v_26]; + if let Some(result) = record.function_queries[548].get_mut(&inp[..]) { debug_assert_eq!(result.output, &__ret[..]); if !unconstrained { *result.multiplicity += G::ONE; } } else { record.function_queries[548].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained)); }; return Ok(__ret); }, } @@ -47928,75 +47644,75 @@ fn aiur_fn_552( 5u64 => { match __v_12.as_canonical_u64() { 5u64 => { - let __r_arr: [G; OUT_528] = { let __args: [G; IN_528] = [__v_6, __v_18]; let __cu = unconstrained; if let Some(result) = record.function_queries[528].get_mut(&__args[..]) { if !__cu && *result.multiplicity == G::ZERO { aiur_fn_528(__args, record, io_buffer, false)? } else { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_528] = unsafe { *(result.output.as_ptr() as *const [G; OUT_528]) }; __ret } } else { aiur_fn_528(__args, record, io_buffer, __cu)? } }; + let __r_arr: [G; OUT_524] = { let __args: [G; IN_524] = [__v_6, __v_18]; let __cu = unconstrained; if let Some(result) = record.function_queries[524].get_mut(&__args[..]) { if !__cu && *result.multiplicity == G::ZERO { aiur_fn_524(__args, record, io_buffer, false)? } else { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_524] = unsafe { *(result.output.as_ptr() as *const [G; OUT_524]) }; __ret } } else { aiur_fn_524(__args, record, io_buffer, __cu)? } }; let __v_25: G = __r_arr[0]; - let __r_arr: [G; OUT_534] = { let __args: [G; IN_534] = [__v_25]; let __cu = unconstrained; if let Some(result) = record.function_queries[534].get_mut(&__args[..]) { if !__cu && *result.multiplicity == G::ZERO { aiur_fn_534(__args, record, io_buffer, false)? } else { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_534] = unsafe { *(result.output.as_ptr() as *const [G; OUT_534]) }; __ret } } else { aiur_fn_534(__args, record, io_buffer, __cu)? } }; + let __r_arr: [G; OUT_530] = { let __args: [G; IN_530] = [__v_25]; let __cu = unconstrained; if let Some(result) = record.function_queries[530].get_mut(&__args[..]) { if !__cu && *result.multiplicity == G::ZERO { aiur_fn_530(__args, record, io_buffer, false)? } else { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_530] = unsafe { *(result.output.as_ptr() as *const [G; OUT_530]) }; __ret } } else { aiur_fn_530(__args, record, io_buffer, __cu)? } }; let __v_26: G = __r_arr[0]; let __v_27: G = __r_arr[1]; - let __r_arr: [G; OUT_528] = { let __args: [G; IN_528] = [__v_1, __v_13]; let __cu = unconstrained; if let Some(result) = record.function_queries[528].get_mut(&__args[..]) { if !__cu && *result.multiplicity == G::ZERO { aiur_fn_528(__args, record, io_buffer, false)? } else { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_528] = unsafe { *(result.output.as_ptr() as *const [G; OUT_528]) }; __ret } } else { aiur_fn_528(__args, record, io_buffer, __cu)? } }; + let __r_arr: [G; OUT_524] = { let __args: [G; IN_524] = [__v_1, __v_13]; let __cu = unconstrained; if let Some(result) = record.function_queries[524].get_mut(&__args[..]) { if !__cu && *result.multiplicity == G::ZERO { aiur_fn_524(__args, record, io_buffer, false)? } else { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_524] = unsafe { *(result.output.as_ptr() as *const [G; OUT_524]) }; __ret } } else { aiur_fn_524(__args, record, io_buffer, __cu)? } }; let __v_28: G = __r_arr[0]; - let __r_arr: [G; OUT_534] = { let __args: [G; IN_534] = [__v_28]; let __cu = unconstrained; if let Some(result) = record.function_queries[534].get_mut(&__args[..]) { if !__cu && *result.multiplicity == G::ZERO { aiur_fn_534(__args, record, io_buffer, false)? } else { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_534] = unsafe { *(result.output.as_ptr() as *const [G; OUT_534]) }; __ret } } else { aiur_fn_534(__args, record, io_buffer, __cu)? } }; + let __r_arr: [G; OUT_530] = { let __args: [G; IN_530] = [__v_28]; let __cu = unconstrained; if let Some(result) = record.function_queries[530].get_mut(&__args[..]) { if !__cu && *result.multiplicity == G::ZERO { aiur_fn_530(__args, record, io_buffer, false)? } else { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_530] = unsafe { *(result.output.as_ptr() as *const [G; OUT_530]) }; __ret } } else { aiur_fn_530(__args, record, io_buffer, __cu)? } }; let __v_29: G = __r_arr[0]; let __v_30: G = __r_arr[1]; - let __r_arr: [G; OUT_528] = { let __args: [G; IN_528] = [__v_3, __v_15]; let __cu = unconstrained; if let Some(result) = record.function_queries[528].get_mut(&__args[..]) { if !__cu && *result.multiplicity == G::ZERO { aiur_fn_528(__args, record, io_buffer, false)? } else { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_528] = unsafe { *(result.output.as_ptr() as *const [G; OUT_528]) }; __ret } } else { aiur_fn_528(__args, record, io_buffer, __cu)? } }; + let __r_arr: [G; OUT_524] = { let __args: [G; IN_524] = [__v_3, __v_15]; let __cu = unconstrained; if let Some(result) = record.function_queries[524].get_mut(&__args[..]) { if !__cu && *result.multiplicity == G::ZERO { aiur_fn_524(__args, record, io_buffer, false)? } else { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_524] = unsafe { *(result.output.as_ptr() as *const [G; OUT_524]) }; __ret } } else { aiur_fn_524(__args, record, io_buffer, __cu)? } }; let __v_31: G = __r_arr[0]; - let __r_arr: [G; OUT_534] = { let __args: [G; IN_534] = [__v_31]; let __cu = unconstrained; if let Some(result) = record.function_queries[534].get_mut(&__args[..]) { if !__cu && *result.multiplicity == G::ZERO { aiur_fn_534(__args, record, io_buffer, false)? } else { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_534] = unsafe { *(result.output.as_ptr() as *const [G; OUT_534]) }; __ret } } else { aiur_fn_534(__args, record, io_buffer, __cu)? } }; + let __r_arr: [G; OUT_530] = { let __args: [G; IN_530] = [__v_31]; let __cu = unconstrained; if let Some(result) = record.function_queries[530].get_mut(&__args[..]) { if !__cu && *result.multiplicity == G::ZERO { aiur_fn_530(__args, record, io_buffer, false)? } else { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_530] = unsafe { *(result.output.as_ptr() as *const [G; OUT_530]) }; __ret } } else { aiur_fn_530(__args, record, io_buffer, __cu)? } }; let __v_32: G = __r_arr[0]; let __v_33: G = __r_arr[1]; - let __r_arr: [G; OUT_528] = { let __args: [G; IN_528] = [__v_4, __v_16]; let __cu = unconstrained; if let Some(result) = record.function_queries[528].get_mut(&__args[..]) { if !__cu && *result.multiplicity == G::ZERO { aiur_fn_528(__args, record, io_buffer, false)? } else { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_528] = unsafe { *(result.output.as_ptr() as *const [G; OUT_528]) }; __ret } } else { aiur_fn_528(__args, record, io_buffer, __cu)? } }; + let __r_arr: [G; OUT_524] = { let __args: [G; IN_524] = [__v_4, __v_16]; let __cu = unconstrained; if let Some(result) = record.function_queries[524].get_mut(&__args[..]) { if !__cu && *result.multiplicity == G::ZERO { aiur_fn_524(__args, record, io_buffer, false)? } else { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_524] = unsafe { *(result.output.as_ptr() as *const [G; OUT_524]) }; __ret } } else { aiur_fn_524(__args, record, io_buffer, __cu)? } }; let __v_34: G = __r_arr[0]; - let __r_arr: [G; OUT_534] = { let __args: [G; IN_534] = [__v_34]; let __cu = unconstrained; if let Some(result) = record.function_queries[534].get_mut(&__args[..]) { if !__cu && *result.multiplicity == G::ZERO { aiur_fn_534(__args, record, io_buffer, false)? } else { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_534] = unsafe { *(result.output.as_ptr() as *const [G; OUT_534]) }; __ret } } else { aiur_fn_534(__args, record, io_buffer, __cu)? } }; + let __r_arr: [G; OUT_530] = { let __args: [G; IN_530] = [__v_34]; let __cu = unconstrained; if let Some(result) = record.function_queries[530].get_mut(&__args[..]) { if !__cu && *result.multiplicity == G::ZERO { aiur_fn_530(__args, record, io_buffer, false)? } else { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_530] = unsafe { *(result.output.as_ptr() as *const [G; OUT_530]) }; __ret } } else { aiur_fn_530(__args, record, io_buffer, __cu)? } }; let __v_35: G = __r_arr[0]; let __v_36: G = __r_arr[1]; - let __r_arr: [G; OUT_533] = { let __args: [G; IN_533] = [__v_32, __v_33, __v_35, __v_36]; let __cu = unconstrained; if let Some(result) = record.function_queries[533].get_mut(&__args[..]) { if !__cu && *result.multiplicity == G::ZERO { aiur_fn_533(__args, record, io_buffer, false)? } else { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_533] = unsafe { *(result.output.as_ptr() as *const [G; OUT_533]) }; __ret } } else { aiur_fn_533(__args, record, io_buffer, __cu)? } }; + let __r_arr: [G; OUT_529] = { let __args: [G; IN_529] = [__v_32, __v_33, __v_35, __v_36]; let __cu = unconstrained; if let Some(result) = record.function_queries[529].get_mut(&__args[..]) { if !__cu && *result.multiplicity == G::ZERO { aiur_fn_529(__args, record, io_buffer, false)? } else { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_529] = unsafe { *(result.output.as_ptr() as *const [G; OUT_529]) }; __ret } } else { aiur_fn_529(__args, record, io_buffer, __cu)? } }; let __v_37: G = __r_arr[0]; let __v_38: G = __r_arr[1]; - let __r_arr: [G; OUT_533] = { let __args: [G; IN_533] = [__v_29, __v_30, __v_37, __v_38]; let __cu = unconstrained; if let Some(result) = record.function_queries[533].get_mut(&__args[..]) { if !__cu && *result.multiplicity == G::ZERO { aiur_fn_533(__args, record, io_buffer, false)? } else { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_533] = unsafe { *(result.output.as_ptr() as *const [G; OUT_533]) }; __ret } } else { aiur_fn_533(__args, record, io_buffer, __cu)? } }; + let __r_arr: [G; OUT_529] = { let __args: [G; IN_529] = [__v_29, __v_30, __v_37, __v_38]; let __cu = unconstrained; if let Some(result) = record.function_queries[529].get_mut(&__args[..]) { if !__cu && *result.multiplicity == G::ZERO { aiur_fn_529(__args, record, io_buffer, false)? } else { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_529] = unsafe { *(result.output.as_ptr() as *const [G; OUT_529]) }; __ret } } else { aiur_fn_529(__args, record, io_buffer, __cu)? } }; let __v_39: G = __r_arr[0]; let __v_40: G = __r_arr[1]; - let __r_arr: [G; OUT_533] = { let __args: [G; IN_533] = [__v_26, __v_27, __v_39, __v_40]; let __cu = unconstrained; if let Some(result) = record.function_queries[533].get_mut(&__args[..]) { if !__cu && *result.multiplicity == G::ZERO { aiur_fn_533(__args, record, io_buffer, false)? } else { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_533] = unsafe { *(result.output.as_ptr() as *const [G; OUT_533]) }; __ret } } else { aiur_fn_533(__args, record, io_buffer, __cu)? } }; + let __r_arr: [G; OUT_529] = { let __args: [G; IN_529] = [__v_26, __v_27, __v_39, __v_40]; let __cu = unconstrained; if let Some(result) = record.function_queries[529].get_mut(&__args[..]) { if !__cu && *result.multiplicity == G::ZERO { aiur_fn_529(__args, record, io_buffer, false)? } else { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_529] = unsafe { *(result.output.as_ptr() as *const [G; OUT_529]) }; __ret } } else { aiur_fn_529(__args, record, io_buffer, __cu)? } }; let __v_41: G = __r_arr[0]; let __v_42: G = __r_arr[1]; - let __r_arr: [G; OUT_528] = { let __args: [G; IN_528] = [__v_5, __v_17]; let __cu = unconstrained; if let Some(result) = record.function_queries[528].get_mut(&__args[..]) { if !__cu && *result.multiplicity == G::ZERO { aiur_fn_528(__args, record, io_buffer, false)? } else { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_528] = unsafe { *(result.output.as_ptr() as *const [G; OUT_528]) }; __ret } } else { aiur_fn_528(__args, record, io_buffer, __cu)? } }; + let __r_arr: [G; OUT_524] = { let __args: [G; IN_524] = [__v_5, __v_17]; let __cu = unconstrained; if let Some(result) = record.function_queries[524].get_mut(&__args[..]) { if !__cu && *result.multiplicity == G::ZERO { aiur_fn_524(__args, record, io_buffer, false)? } else { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_524] = unsafe { *(result.output.as_ptr() as *const [G; OUT_524]) }; __ret } } else { aiur_fn_524(__args, record, io_buffer, __cu)? } }; let __v_43: G = __r_arr[0]; match __v_43.as_canonical_u64() { 1u64 => { - let __r_arr: [G; OUT_546] = { let __args: [G; IN_546] = [__v_2, __v_14, __v_24]; let __cu = unconstrained; if let Some(result) = record.function_queries[546].get_mut(&__args[..]) { if !__cu && *result.multiplicity == G::ZERO { aiur_fn_546(__args, record, io_buffer, false)? } else { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_546] = unsafe { *(result.output.as_ptr() as *const [G; OUT_546]) }; __ret } } else { aiur_fn_546(__args, record, io_buffer, __cu)? } }; + let __r_arr: [G; OUT_542] = { let __args: [G; IN_542] = [__v_2, __v_14, __v_24]; let __cu = unconstrained; if let Some(result) = record.function_queries[542].get_mut(&__args[..]) { if !__cu && *result.multiplicity == G::ZERO { aiur_fn_542(__args, record, io_buffer, false)? } else { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_542] = unsafe { *(result.output.as_ptr() as *const [G; OUT_542]) }; __ret } } else { aiur_fn_542(__args, record, io_buffer, __cu)? } }; let __v_44: G = __r_arr[0]; let __v_45: G = __r_arr[1]; let __v_46: G = G::from_u64(0); - let __r_arr: [G; OUT_553] = { let __args: [G; IN_553] = [__v_7, __v_8, __v_19, __v_20, __v_5, __v_24, __v_46]; let __cu = unconstrained; if let Some(result) = record.function_queries[553].get_mut(&__args[..]) { if !__cu && *result.multiplicity == G::ZERO { aiur_fn_553(__args, record, io_buffer, false)? } else { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_553] = unsafe { *(result.output.as_ptr() as *const [G; OUT_553]) }; __ret } } else { aiur_fn_553(__args, record, io_buffer, __cu)? } }; + let __r_arr: [G; OUT_549] = { let __args: [G; IN_549] = [__v_7, __v_8, __v_19, __v_20, __v_5, __v_24, __v_46]; let __cu = unconstrained; if let Some(result) = record.function_queries[549].get_mut(&__args[..]) { if !__cu && *result.multiplicity == G::ZERO { aiur_fn_549(__args, record, io_buffer, false)? } else { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_549] = unsafe { *(result.output.as_ptr() as *const [G; OUT_549]) }; __ret } } else { aiur_fn_549(__args, record, io_buffer, __cu)? } }; let __v_47: G = __r_arr[0]; let __v_48: G = __r_arr[1]; - let __r_arr: [G; OUT_533] = { let __args: [G; IN_533] = [__v_44, __v_45, __v_47, __v_48]; let __cu = unconstrained; if let Some(result) = record.function_queries[533].get_mut(&__args[..]) { if !__cu && *result.multiplicity == G::ZERO { aiur_fn_533(__args, record, io_buffer, false)? } else { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_533] = unsafe { *(result.output.as_ptr() as *const [G; OUT_533]) }; __ret } } else { aiur_fn_533(__args, record, io_buffer, __cu)? } }; + let __r_arr: [G; OUT_529] = { let __args: [G; IN_529] = [__v_44, __v_45, __v_47, __v_48]; let __cu = unconstrained; if let Some(result) = record.function_queries[529].get_mut(&__args[..]) { if !__cu && *result.multiplicity == G::ZERO { aiur_fn_529(__args, record, io_buffer, false)? } else { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_529] = unsafe { *(result.output.as_ptr() as *const [G; OUT_529]) }; __ret } } else { aiur_fn_529(__args, record, io_buffer, __cu)? } }; let __v_49: G = __r_arr[0]; let __v_50: G = __r_arr[1]; - let __r_arr: [G; OUT_533] = { let __args: [G; IN_533] = [__v_41, __v_42, __v_49, __v_50]; let __cu = unconstrained; if let Some(result) = record.function_queries[533].get_mut(&__args[..]) { if !__cu && *result.multiplicity == G::ZERO { aiur_fn_533(__args, record, io_buffer, false)? } else { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_533] = unsafe { *(result.output.as_ptr() as *const [G; OUT_533]) }; __ret } } else { aiur_fn_533(__args, record, io_buffer, __cu)? } }; + let __r_arr: [G; OUT_529] = { let __args: [G; IN_529] = [__v_41, __v_42, __v_49, __v_50]; let __cu = unconstrained; if let Some(result) = record.function_queries[529].get_mut(&__args[..]) { if !__cu && *result.multiplicity == G::ZERO { aiur_fn_529(__args, record, io_buffer, false)? } else { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_529] = unsafe { *(result.output.as_ptr() as *const [G; OUT_529]) }; __ret } } else { aiur_fn_529(__args, record, io_buffer, __cu)? } }; let __v_51: G = __r_arr[0]; let __v_52: G = __r_arr[1]; - let __ret: [G; OUT_552] = [__v_51, __v_52]; - if let Some(result) = record.function_queries[552].get_mut(&inp[..]) { debug_assert_eq!(result.output, &__ret[..]); if !unconstrained { *result.multiplicity += G::ONE; } } else { record.function_queries[552].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained)); }; + let __ret: [G; OUT_548] = [__v_51, __v_52]; + if let Some(result) = record.function_queries[548].get_mut(&inp[..]) { debug_assert_eq!(result.output, &__ret[..]); if !unconstrained { *result.multiplicity += G::ONE; } } else { record.function_queries[548].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained)); }; return Ok(__ret); }, _ => { - let __r_arr: [G; OUT_534] = { let __args: [G; IN_534] = [__v_43]; let __cu = unconstrained; if let Some(result) = record.function_queries[534].get_mut(&__args[..]) { if !__cu && *result.multiplicity == G::ZERO { aiur_fn_534(__args, record, io_buffer, false)? } else { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_534] = unsafe { *(result.output.as_ptr() as *const [G; OUT_534]) }; __ret } } else { aiur_fn_534(__args, record, io_buffer, __cu)? } }; + let __r_arr: [G; OUT_530] = { let __args: [G; IN_530] = [__v_43]; let __cu = unconstrained; if let Some(result) = record.function_queries[530].get_mut(&__args[..]) { if !__cu && *result.multiplicity == G::ZERO { aiur_fn_530(__args, record, io_buffer, false)? } else { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_530] = unsafe { *(result.output.as_ptr() as *const [G; OUT_530]) }; __ret } } else { aiur_fn_530(__args, record, io_buffer, __cu)? } }; let __v_44: G = __r_arr[0]; let __v_45: G = __r_arr[1]; - let __r_arr: [G; OUT_533] = { let __args: [G; IN_533] = [__v_41, __v_42, __v_44, __v_45]; let __cu = unconstrained; if let Some(result) = record.function_queries[533].get_mut(&__args[..]) { if !__cu && *result.multiplicity == G::ZERO { aiur_fn_533(__args, record, io_buffer, false)? } else { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_533] = unsafe { *(result.output.as_ptr() as *const [G; OUT_533]) }; __ret } } else { aiur_fn_533(__args, record, io_buffer, __cu)? } }; + let __r_arr: [G; OUT_529] = { let __args: [G; IN_529] = [__v_41, __v_42, __v_44, __v_45]; let __cu = unconstrained; if let Some(result) = record.function_queries[529].get_mut(&__args[..]) { if !__cu && *result.multiplicity == G::ZERO { aiur_fn_529(__args, record, io_buffer, false)? } else { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_529] = unsafe { *(result.output.as_ptr() as *const [G; OUT_529]) }; __ret } } else { aiur_fn_529(__args, record, io_buffer, __cu)? } }; let __v_46: G = __r_arr[0]; let __v_47: G = __r_arr[1]; - let __ret: [G; OUT_552] = [__v_46, __v_47]; - if let Some(result) = record.function_queries[552].get_mut(&inp[..]) { debug_assert_eq!(result.output, &__ret[..]); if !unconstrained { *result.multiplicity += G::ONE; } } else { record.function_queries[552].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained)); }; + let __ret: [G; OUT_548] = [__v_46, __v_47]; + if let Some(result) = record.function_queries[548].get_mut(&inp[..]) { debug_assert_eq!(result.output, &__ret[..]); if !unconstrained { *result.multiplicity += G::ONE; } } else { record.function_queries[548].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained)); }; return Ok(__ret); }, } }, _ => { - let __r_arr: [G; OUT_531] = { let __args: [G; IN_531] = []; let __cu = unconstrained; if let Some(result) = record.function_queries[531].get_mut(&__args[..]) { if !__cu && *result.multiplicity == G::ZERO { aiur_fn_531(__args, record, io_buffer, false)? } else { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_531] = unsafe { *(result.output.as_ptr() as *const [G; OUT_531]) }; __ret } } else { aiur_fn_531(__args, record, io_buffer, __cu)? } }; + let __r_arr: [G; OUT_527] = { let __args: [G; IN_527] = []; let __cu = unconstrained; if let Some(result) = record.function_queries[527].get_mut(&__args[..]) { if !__cu && *result.multiplicity == G::ZERO { aiur_fn_527(__args, record, io_buffer, false)? } else { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_527] = unsafe { *(result.output.as_ptr() as *const [G; OUT_527]) }; __ret } } else { aiur_fn_527(__args, record, io_buffer, __cu)? } }; let __v_25: G = __r_arr[0]; let __v_26: G = __r_arr[1]; - let __ret: [G; OUT_552] = [__v_25, __v_26]; - if let Some(result) = record.function_queries[552].get_mut(&inp[..]) { debug_assert_eq!(result.output, &__ret[..]); if !unconstrained { *result.multiplicity += G::ONE; } } else { record.function_queries[552].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained)); }; + let __ret: [G; OUT_548] = [__v_25, __v_26]; + if let Some(result) = record.function_queries[548].get_mut(&inp[..]) { debug_assert_eq!(result.output, &__ret[..]); if !unconstrained { *result.multiplicity += G::ONE; } } else { record.function_queries[548].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained)); }; return Ok(__ret); }, } @@ -48004,98 +47720,98 @@ fn aiur_fn_552( 7u64 => { match __v_12.as_canonical_u64() { 7u64 => { - let __r_arr: [G; OUT_528] = { let __args: [G; IN_528] = [__v_1, __v_13]; let __cu = unconstrained; if let Some(result) = record.function_queries[528].get_mut(&__args[..]) { if !__cu && *result.multiplicity == G::ZERO { aiur_fn_528(__args, record, io_buffer, false)? } else { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_528] = unsafe { *(result.output.as_ptr() as *const [G; OUT_528]) }; __ret } } else { aiur_fn_528(__args, record, io_buffer, __cu)? } }; + let __r_arr: [G; OUT_524] = { let __args: [G; IN_524] = [__v_1, __v_13]; let __cu = unconstrained; if let Some(result) = record.function_queries[524].get_mut(&__args[..]) { if !__cu && *result.multiplicity == G::ZERO { aiur_fn_524(__args, record, io_buffer, false)? } else { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_524] = unsafe { *(result.output.as_ptr() as *const [G; OUT_524]) }; __ret } } else { aiur_fn_524(__args, record, io_buffer, __cu)? } }; let __v_25: G = __r_arr[0]; - let __r_arr: [G; OUT_534] = { let __args: [G; IN_534] = [__v_25]; let __cu = unconstrained; if let Some(result) = record.function_queries[534].get_mut(&__args[..]) { if !__cu && *result.multiplicity == G::ZERO { aiur_fn_534(__args, record, io_buffer, false)? } else { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_534] = unsafe { *(result.output.as_ptr() as *const [G; OUT_534]) }; __ret } } else { aiur_fn_534(__args, record, io_buffer, __cu)? } }; + let __r_arr: [G; OUT_530] = { let __args: [G; IN_530] = [__v_25]; let __cu = unconstrained; if let Some(result) = record.function_queries[530].get_mut(&__args[..]) { if !__cu && *result.multiplicity == G::ZERO { aiur_fn_530(__args, record, io_buffer, false)? } else { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_530] = unsafe { *(result.output.as_ptr() as *const [G; OUT_530]) }; __ret } } else { aiur_fn_530(__args, record, io_buffer, __cu)? } }; let __v_26: G = __r_arr[0]; let __v_27: G = __r_arr[1]; - let __r_arr: [G; OUT_528] = { let __args: [G; IN_528] = [__v_3, __v_15]; let __cu = unconstrained; if let Some(result) = record.function_queries[528].get_mut(&__args[..]) { if !__cu && *result.multiplicity == G::ZERO { aiur_fn_528(__args, record, io_buffer, false)? } else { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_528] = unsafe { *(result.output.as_ptr() as *const [G; OUT_528]) }; __ret } } else { aiur_fn_528(__args, record, io_buffer, __cu)? } }; + let __r_arr: [G; OUT_524] = { let __args: [G; IN_524] = [__v_3, __v_15]; let __cu = unconstrained; if let Some(result) = record.function_queries[524].get_mut(&__args[..]) { if !__cu && *result.multiplicity == G::ZERO { aiur_fn_524(__args, record, io_buffer, false)? } else { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_524] = unsafe { *(result.output.as_ptr() as *const [G; OUT_524]) }; __ret } } else { aiur_fn_524(__args, record, io_buffer, __cu)? } }; let __v_28: G = __r_arr[0]; - let __r_arr: [G; OUT_534] = { let __args: [G; IN_534] = [__v_28]; let __cu = unconstrained; if let Some(result) = record.function_queries[534].get_mut(&__args[..]) { if !__cu && *result.multiplicity == G::ZERO { aiur_fn_534(__args, record, io_buffer, false)? } else { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_534] = unsafe { *(result.output.as_ptr() as *const [G; OUT_534]) }; __ret } } else { aiur_fn_534(__args, record, io_buffer, __cu)? } }; + let __r_arr: [G; OUT_530] = { let __args: [G; IN_530] = [__v_28]; let __cu = unconstrained; if let Some(result) = record.function_queries[530].get_mut(&__args[..]) { if !__cu && *result.multiplicity == G::ZERO { aiur_fn_530(__args, record, io_buffer, false)? } else { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_530] = unsafe { *(result.output.as_ptr() as *const [G; OUT_530]) }; __ret } } else { aiur_fn_530(__args, record, io_buffer, __cu)? } }; let __v_29: G = __r_arr[0]; let __v_30: G = __r_arr[1]; - let __r_arr: [G; OUT_528] = { let __args: [G; IN_528] = [__v_4, __v_16]; let __cu = unconstrained; if let Some(result) = record.function_queries[528].get_mut(&__args[..]) { if !__cu && *result.multiplicity == G::ZERO { aiur_fn_528(__args, record, io_buffer, false)? } else { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_528] = unsafe { *(result.output.as_ptr() as *const [G; OUT_528]) }; __ret } } else { aiur_fn_528(__args, record, io_buffer, __cu)? } }; + let __r_arr: [G; OUT_524] = { let __args: [G; IN_524] = [__v_4, __v_16]; let __cu = unconstrained; if let Some(result) = record.function_queries[524].get_mut(&__args[..]) { if !__cu && *result.multiplicity == G::ZERO { aiur_fn_524(__args, record, io_buffer, false)? } else { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_524] = unsafe { *(result.output.as_ptr() as *const [G; OUT_524]) }; __ret } } else { aiur_fn_524(__args, record, io_buffer, __cu)? } }; let __v_31: G = __r_arr[0]; - let __r_arr: [G; OUT_534] = { let __args: [G; IN_534] = [__v_31]; let __cu = unconstrained; if let Some(result) = record.function_queries[534].get_mut(&__args[..]) { if !__cu && *result.multiplicity == G::ZERO { aiur_fn_534(__args, record, io_buffer, false)? } else { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_534] = unsafe { *(result.output.as_ptr() as *const [G; OUT_534]) }; __ret } } else { aiur_fn_534(__args, record, io_buffer, __cu)? } }; + let __r_arr: [G; OUT_530] = { let __args: [G; IN_530] = [__v_31]; let __cu = unconstrained; if let Some(result) = record.function_queries[530].get_mut(&__args[..]) { if !__cu && *result.multiplicity == G::ZERO { aiur_fn_530(__args, record, io_buffer, false)? } else { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_530] = unsafe { *(result.output.as_ptr() as *const [G; OUT_530]) }; __ret } } else { aiur_fn_530(__args, record, io_buffer, __cu)? } }; let __v_32: G = __r_arr[0]; let __v_33: G = __r_arr[1]; - let __r_arr: [G; OUT_528] = { let __args: [G; IN_528] = [__v_5, __v_17]; let __cu = unconstrained; if let Some(result) = record.function_queries[528].get_mut(&__args[..]) { if !__cu && *result.multiplicity == G::ZERO { aiur_fn_528(__args, record, io_buffer, false)? } else { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_528] = unsafe { *(result.output.as_ptr() as *const [G; OUT_528]) }; __ret } } else { aiur_fn_528(__args, record, io_buffer, __cu)? } }; + let __r_arr: [G; OUT_524] = { let __args: [G; IN_524] = [__v_5, __v_17]; let __cu = unconstrained; if let Some(result) = record.function_queries[524].get_mut(&__args[..]) { if !__cu && *result.multiplicity == G::ZERO { aiur_fn_524(__args, record, io_buffer, false)? } else { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_524] = unsafe { *(result.output.as_ptr() as *const [G; OUT_524]) }; __ret } } else { aiur_fn_524(__args, record, io_buffer, __cu)? } }; let __v_34: G = __r_arr[0]; - let __r_arr: [G; OUT_534] = { let __args: [G; IN_534] = [__v_34]; let __cu = unconstrained; if let Some(result) = record.function_queries[534].get_mut(&__args[..]) { if !__cu && *result.multiplicity == G::ZERO { aiur_fn_534(__args, record, io_buffer, false)? } else { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_534] = unsafe { *(result.output.as_ptr() as *const [G; OUT_534]) }; __ret } } else { aiur_fn_534(__args, record, io_buffer, __cu)? } }; + let __r_arr: [G; OUT_530] = { let __args: [G; IN_530] = [__v_34]; let __cu = unconstrained; if let Some(result) = record.function_queries[530].get_mut(&__args[..]) { if !__cu && *result.multiplicity == G::ZERO { aiur_fn_530(__args, record, io_buffer, false)? } else { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_530] = unsafe { *(result.output.as_ptr() as *const [G; OUT_530]) }; __ret } } else { aiur_fn_530(__args, record, io_buffer, __cu)? } }; let __v_35: G = __r_arr[0]; let __v_36: G = __r_arr[1]; - let __r_arr: [G; OUT_528] = { let __args: [G; IN_528] = [__v_6, __v_18]; let __cu = unconstrained; if let Some(result) = record.function_queries[528].get_mut(&__args[..]) { if !__cu && *result.multiplicity == G::ZERO { aiur_fn_528(__args, record, io_buffer, false)? } else { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_528] = unsafe { *(result.output.as_ptr() as *const [G; OUT_528]) }; __ret } } else { aiur_fn_528(__args, record, io_buffer, __cu)? } }; + let __r_arr: [G; OUT_524] = { let __args: [G; IN_524] = [__v_6, __v_18]; let __cu = unconstrained; if let Some(result) = record.function_queries[524].get_mut(&__args[..]) { if !__cu && *result.multiplicity == G::ZERO { aiur_fn_524(__args, record, io_buffer, false)? } else { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_524] = unsafe { *(result.output.as_ptr() as *const [G; OUT_524]) }; __ret } } else { aiur_fn_524(__args, record, io_buffer, __cu)? } }; let __v_37: G = __r_arr[0]; - let __r_arr: [G; OUT_534] = { let __args: [G; IN_534] = [__v_37]; let __cu = unconstrained; if let Some(result) = record.function_queries[534].get_mut(&__args[..]) { if !__cu && *result.multiplicity == G::ZERO { aiur_fn_534(__args, record, io_buffer, false)? } else { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_534] = unsafe { *(result.output.as_ptr() as *const [G; OUT_534]) }; __ret } } else { aiur_fn_534(__args, record, io_buffer, __cu)? } }; + let __r_arr: [G; OUT_530] = { let __args: [G; IN_530] = [__v_37]; let __cu = unconstrained; if let Some(result) = record.function_queries[530].get_mut(&__args[..]) { if !__cu && *result.multiplicity == G::ZERO { aiur_fn_530(__args, record, io_buffer, false)? } else { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_530] = unsafe { *(result.output.as_ptr() as *const [G; OUT_530]) }; __ret } } else { aiur_fn_530(__args, record, io_buffer, __cu)? } }; let __v_38: G = __r_arr[0]; let __v_39: G = __r_arr[1]; - let __r_arr: [G; OUT_528] = { let __args: [G; IN_528] = [__v_8, __v_20]; let __cu = unconstrained; if let Some(result) = record.function_queries[528].get_mut(&__args[..]) { if !__cu && *result.multiplicity == G::ZERO { aiur_fn_528(__args, record, io_buffer, false)? } else { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_528] = unsafe { *(result.output.as_ptr() as *const [G; OUT_528]) }; __ret } } else { aiur_fn_528(__args, record, io_buffer, __cu)? } }; + let __r_arr: [G; OUT_524] = { let __args: [G; IN_524] = [__v_8, __v_20]; let __cu = unconstrained; if let Some(result) = record.function_queries[524].get_mut(&__args[..]) { if !__cu && *result.multiplicity == G::ZERO { aiur_fn_524(__args, record, io_buffer, false)? } else { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_524] = unsafe { *(result.output.as_ptr() as *const [G; OUT_524]) }; __ret } } else { aiur_fn_524(__args, record, io_buffer, __cu)? } }; let __v_40: G = __r_arr[0]; - let __r_arr: [G; OUT_534] = { let __args: [G; IN_534] = [__v_40]; let __cu = unconstrained; if let Some(result) = record.function_queries[534].get_mut(&__args[..]) { if !__cu && *result.multiplicity == G::ZERO { aiur_fn_534(__args, record, io_buffer, false)? } else { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_534] = unsafe { *(result.output.as_ptr() as *const [G; OUT_534]) }; __ret } } else { aiur_fn_534(__args, record, io_buffer, __cu)? } }; + let __r_arr: [G; OUT_530] = { let __args: [G; IN_530] = [__v_40]; let __cu = unconstrained; if let Some(result) = record.function_queries[530].get_mut(&__args[..]) { if !__cu && *result.multiplicity == G::ZERO { aiur_fn_530(__args, record, io_buffer, false)? } else { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_530] = unsafe { *(result.output.as_ptr() as *const [G; OUT_530]) }; __ret } } else { aiur_fn_530(__args, record, io_buffer, __cu)? } }; let __v_41: G = __r_arr[0]; let __v_42: G = __r_arr[1]; - let __r_arr: [G; OUT_546] = { let __args: [G; IN_546] = [__v_2, __v_14, __v_24]; let __cu = unconstrained; if let Some(result) = record.function_queries[546].get_mut(&__args[..]) { if !__cu && *result.multiplicity == G::ZERO { aiur_fn_546(__args, record, io_buffer, false)? } else { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_546] = unsafe { *(result.output.as_ptr() as *const [G; OUT_546]) }; __ret } } else { aiur_fn_546(__args, record, io_buffer, __cu)? } }; + let __r_arr: [G; OUT_542] = { let __args: [G; IN_542] = [__v_2, __v_14, __v_24]; let __cu = unconstrained; if let Some(result) = record.function_queries[542].get_mut(&__args[..]) { if !__cu && *result.multiplicity == G::ZERO { aiur_fn_542(__args, record, io_buffer, false)? } else { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_542] = unsafe { *(result.output.as_ptr() as *const [G; OUT_542]) }; __ret } } else { aiur_fn_542(__args, record, io_buffer, __cu)? } }; let __v_43: G = __r_arr[0]; let __v_44: G = __r_arr[1]; - let __r_arr: [G; OUT_549] = { let __args: [G; IN_549] = [__v_7, __v_19, __v_24]; let __cu = unconstrained; if let Some(result) = record.function_queries[549].get_mut(&__args[..]) { if !__cu && *result.multiplicity == G::ZERO { aiur_fn_549(__args, record, io_buffer, false)? } else { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_549] = unsafe { *(result.output.as_ptr() as *const [G; OUT_549]) }; __ret } } else { aiur_fn_549(__args, record, io_buffer, __cu)? } }; + let __r_arr: [G; OUT_545] = { let __args: [G; IN_545] = [__v_7, __v_19, __v_24]; let __cu = unconstrained; if let Some(result) = record.function_queries[545].get_mut(&__args[..]) { if !__cu && *result.multiplicity == G::ZERO { aiur_fn_545(__args, record, io_buffer, false)? } else { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_545] = unsafe { *(result.output.as_ptr() as *const [G; OUT_545]) }; __ret } } else { aiur_fn_545(__args, record, io_buffer, __cu)? } }; let __v_45: G = __r_arr[0]; let __v_46: G = __r_arr[1]; - let __r_arr: [G; OUT_533] = { let __args: [G; IN_533] = [__v_43, __v_44, __v_45, __v_46]; let __cu = unconstrained; if let Some(result) = record.function_queries[533].get_mut(&__args[..]) { if !__cu && *result.multiplicity == G::ZERO { aiur_fn_533(__args, record, io_buffer, false)? } else { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_533] = unsafe { *(result.output.as_ptr() as *const [G; OUT_533]) }; __ret } } else { aiur_fn_533(__args, record, io_buffer, __cu)? } }; + let __r_arr: [G; OUT_529] = { let __args: [G; IN_529] = [__v_43, __v_44, __v_45, __v_46]; let __cu = unconstrained; if let Some(result) = record.function_queries[529].get_mut(&__args[..]) { if !__cu && *result.multiplicity == G::ZERO { aiur_fn_529(__args, record, io_buffer, false)? } else { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_529] = unsafe { *(result.output.as_ptr() as *const [G; OUT_529]) }; __ret } } else { aiur_fn_529(__args, record, io_buffer, __cu)? } }; let __v_47: G = __r_arr[0]; let __v_48: G = __r_arr[1]; - let __r_arr: [G; OUT_533] = { let __args: [G; IN_533] = [__v_41, __v_42, __v_47, __v_48]; let __cu = unconstrained; if let Some(result) = record.function_queries[533].get_mut(&__args[..]) { if !__cu && *result.multiplicity == G::ZERO { aiur_fn_533(__args, record, io_buffer, false)? } else { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_533] = unsafe { *(result.output.as_ptr() as *const [G; OUT_533]) }; __ret } } else { aiur_fn_533(__args, record, io_buffer, __cu)? } }; + let __r_arr: [G; OUT_529] = { let __args: [G; IN_529] = [__v_41, __v_42, __v_47, __v_48]; let __cu = unconstrained; if let Some(result) = record.function_queries[529].get_mut(&__args[..]) { if !__cu && *result.multiplicity == G::ZERO { aiur_fn_529(__args, record, io_buffer, false)? } else { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_529] = unsafe { *(result.output.as_ptr() as *const [G; OUT_529]) }; __ret } } else { aiur_fn_529(__args, record, io_buffer, __cu)? } }; let __v_49: G = __r_arr[0]; let __v_50: G = __r_arr[1]; - let __r_arr: [G; OUT_533] = { let __args: [G; IN_533] = [__v_38, __v_39, __v_49, __v_50]; let __cu = unconstrained; if let Some(result) = record.function_queries[533].get_mut(&__args[..]) { if !__cu && *result.multiplicity == G::ZERO { aiur_fn_533(__args, record, io_buffer, false)? } else { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_533] = unsafe { *(result.output.as_ptr() as *const [G; OUT_533]) }; __ret } } else { aiur_fn_533(__args, record, io_buffer, __cu)? } }; + let __r_arr: [G; OUT_529] = { let __args: [G; IN_529] = [__v_38, __v_39, __v_49, __v_50]; let __cu = unconstrained; if let Some(result) = record.function_queries[529].get_mut(&__args[..]) { if !__cu && *result.multiplicity == G::ZERO { aiur_fn_529(__args, record, io_buffer, false)? } else { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_529] = unsafe { *(result.output.as_ptr() as *const [G; OUT_529]) }; __ret } } else { aiur_fn_529(__args, record, io_buffer, __cu)? } }; let __v_51: G = __r_arr[0]; let __v_52: G = __r_arr[1]; - let __r_arr: [G; OUT_533] = { let __args: [G; IN_533] = [__v_35, __v_36, __v_51, __v_52]; let __cu = unconstrained; if let Some(result) = record.function_queries[533].get_mut(&__args[..]) { if !__cu && *result.multiplicity == G::ZERO { aiur_fn_533(__args, record, io_buffer, false)? } else { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_533] = unsafe { *(result.output.as_ptr() as *const [G; OUT_533]) }; __ret } } else { aiur_fn_533(__args, record, io_buffer, __cu)? } }; + let __r_arr: [G; OUT_529] = { let __args: [G; IN_529] = [__v_35, __v_36, __v_51, __v_52]; let __cu = unconstrained; if let Some(result) = record.function_queries[529].get_mut(&__args[..]) { if !__cu && *result.multiplicity == G::ZERO { aiur_fn_529(__args, record, io_buffer, false)? } else { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_529] = unsafe { *(result.output.as_ptr() as *const [G; OUT_529]) }; __ret } } else { aiur_fn_529(__args, record, io_buffer, __cu)? } }; let __v_53: G = __r_arr[0]; let __v_54: G = __r_arr[1]; - let __r_arr: [G; OUT_533] = { let __args: [G; IN_533] = [__v_32, __v_33, __v_53, __v_54]; let __cu = unconstrained; if let Some(result) = record.function_queries[533].get_mut(&__args[..]) { if !__cu && *result.multiplicity == G::ZERO { aiur_fn_533(__args, record, io_buffer, false)? } else { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_533] = unsafe { *(result.output.as_ptr() as *const [G; OUT_533]) }; __ret } } else { aiur_fn_533(__args, record, io_buffer, __cu)? } }; + let __r_arr: [G; OUT_529] = { let __args: [G; IN_529] = [__v_32, __v_33, __v_53, __v_54]; let __cu = unconstrained; if let Some(result) = record.function_queries[529].get_mut(&__args[..]) { if !__cu && *result.multiplicity == G::ZERO { aiur_fn_529(__args, record, io_buffer, false)? } else { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_529] = unsafe { *(result.output.as_ptr() as *const [G; OUT_529]) }; __ret } } else { aiur_fn_529(__args, record, io_buffer, __cu)? } }; let __v_55: G = __r_arr[0]; let __v_56: G = __r_arr[1]; - let __r_arr: [G; OUT_533] = { let __args: [G; IN_533] = [__v_29, __v_30, __v_55, __v_56]; let __cu = unconstrained; if let Some(result) = record.function_queries[533].get_mut(&__args[..]) { if !__cu && *result.multiplicity == G::ZERO { aiur_fn_533(__args, record, io_buffer, false)? } else { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_533] = unsafe { *(result.output.as_ptr() as *const [G; OUT_533]) }; __ret } } else { aiur_fn_533(__args, record, io_buffer, __cu)? } }; + let __r_arr: [G; OUT_529] = { let __args: [G; IN_529] = [__v_29, __v_30, __v_55, __v_56]; let __cu = unconstrained; if let Some(result) = record.function_queries[529].get_mut(&__args[..]) { if !__cu && *result.multiplicity == G::ZERO { aiur_fn_529(__args, record, io_buffer, false)? } else { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_529] = unsafe { *(result.output.as_ptr() as *const [G; OUT_529]) }; __ret } } else { aiur_fn_529(__args, record, io_buffer, __cu)? } }; let __v_57: G = __r_arr[0]; let __v_58: G = __r_arr[1]; - let __r_arr: [G; OUT_533] = { let __args: [G; IN_533] = [__v_26, __v_27, __v_57, __v_58]; let __cu = unconstrained; if let Some(result) = record.function_queries[533].get_mut(&__args[..]) { if !__cu && *result.multiplicity == G::ZERO { aiur_fn_533(__args, record, io_buffer, false)? } else { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_533] = unsafe { *(result.output.as_ptr() as *const [G; OUT_533]) }; __ret } } else { aiur_fn_533(__args, record, io_buffer, __cu)? } }; + let __r_arr: [G; OUT_529] = { let __args: [G; IN_529] = [__v_26, __v_27, __v_57, __v_58]; let __cu = unconstrained; if let Some(result) = record.function_queries[529].get_mut(&__args[..]) { if !__cu && *result.multiplicity == G::ZERO { aiur_fn_529(__args, record, io_buffer, false)? } else { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_529] = unsafe { *(result.output.as_ptr() as *const [G; OUT_529]) }; __ret } } else { aiur_fn_529(__args, record, io_buffer, __cu)? } }; let __v_59: G = __r_arr[0]; let __v_60: G = __r_arr[1]; - let __ret: [G; OUT_552] = [__v_59, __v_60]; - if let Some(result) = record.function_queries[552].get_mut(&inp[..]) { debug_assert_eq!(result.output, &__ret[..]); if !unconstrained { *result.multiplicity += G::ONE; } } else { record.function_queries[552].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained)); }; + let __ret: [G; OUT_548] = [__v_59, __v_60]; + if let Some(result) = record.function_queries[548].get_mut(&inp[..]) { debug_assert_eq!(result.output, &__ret[..]); if !unconstrained { *result.multiplicity += G::ONE; } } else { record.function_queries[548].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained)); }; return Ok(__ret); }, _ => { - let __r_arr: [G; OUT_531] = { let __args: [G; IN_531] = []; let __cu = unconstrained; if let Some(result) = record.function_queries[531].get_mut(&__args[..]) { if !__cu && *result.multiplicity == G::ZERO { aiur_fn_531(__args, record, io_buffer, false)? } else { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_531] = unsafe { *(result.output.as_ptr() as *const [G; OUT_531]) }; __ret } } else { aiur_fn_531(__args, record, io_buffer, __cu)? } }; + let __r_arr: [G; OUT_527] = { let __args: [G; IN_527] = []; let __cu = unconstrained; if let Some(result) = record.function_queries[527].get_mut(&__args[..]) { if !__cu && *result.multiplicity == G::ZERO { aiur_fn_527(__args, record, io_buffer, false)? } else { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_527] = unsafe { *(result.output.as_ptr() as *const [G; OUT_527]) }; __ret } } else { aiur_fn_527(__args, record, io_buffer, __cu)? } }; let __v_25: G = __r_arr[0]; let __v_26: G = __r_arr[1]; - let __ret: [G; OUT_552] = [__v_25, __v_26]; - if let Some(result) = record.function_queries[552].get_mut(&inp[..]) { debug_assert_eq!(result.output, &__ret[..]); if !unconstrained { *result.multiplicity += G::ONE; } } else { record.function_queries[552].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained)); }; + let __ret: [G; OUT_548] = [__v_25, __v_26]; + if let Some(result) = record.function_queries[548].get_mut(&inp[..]) { debug_assert_eq!(result.output, &__ret[..]); if !unconstrained { *result.multiplicity += G::ONE; } } else { record.function_queries[548].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained)); }; return Ok(__ret); }, } }, _ => { - let __r_arr: [G; OUT_531] = { let __args: [G; IN_531] = []; let __cu = unconstrained; if let Some(result) = record.function_queries[531].get_mut(&__args[..]) { if !__cu && *result.multiplicity == G::ZERO { aiur_fn_531(__args, record, io_buffer, false)? } else { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_531] = unsafe { *(result.output.as_ptr() as *const [G; OUT_531]) }; __ret } } else { aiur_fn_531(__args, record, io_buffer, __cu)? } }; + let __r_arr: [G; OUT_527] = { let __args: [G; IN_527] = []; let __cu = unconstrained; if let Some(result) = record.function_queries[527].get_mut(&__args[..]) { if !__cu && *result.multiplicity == G::ZERO { aiur_fn_527(__args, record, io_buffer, false)? } else { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_527] = unsafe { *(result.output.as_ptr() as *const [G; OUT_527]) }; __ret } } else { aiur_fn_527(__args, record, io_buffer, __cu)? } }; let __v_25: G = __r_arr[0]; let __v_26: G = __r_arr[1]; - let __ret: [G; OUT_552] = [__v_25, __v_26]; - if let Some(result) = record.function_queries[552].get_mut(&inp[..]) { debug_assert_eq!(result.output, &__ret[..]); if !unconstrained { *result.multiplicity += G::ONE; } } else { record.function_queries[552].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained)); }; + let __ret: [G; OUT_548] = [__v_25, __v_26]; + if let Some(result) = record.function_queries[548].get_mut(&inp[..]) { debug_assert_eq!(result.output, &__ret[..]); if !unconstrained { *result.multiplicity += G::ONE; } } else { record.function_queries[548].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained)); }; return Ok(__ret); }, } }) } -const INPUT_SIZE_553: usize = 7; -const IN_553: usize = 7; -const OUT_553: usize = 2; -fn aiur_fn_553( - inp: [G; IN_553], +const INPUT_SIZE_549: usize = 7; +const IN_549: usize = 7; +const OUT_549: usize = 2; +fn aiur_fn_549( + inp: [G; IN_549], record: &mut QueryRecord, io_buffer: &mut IOBuffer, unconstrained: bool, -) -> Result<[G; OUT_553], ExecError> { +) -> Result<[G; OUT_549], ExecError> { stacker::maybe_grow(64 * 1024, 4 * 1024 * 1024, || { let __v_0: G = inp[0]; let __v_1: G = inp[1]; @@ -48107,15 +47823,15 @@ fn aiur_fn_553( let __v_7: G = (__v_4 - __v_6); match __v_7.as_canonical_u64() { 0u64 => { - let __r_arr: [G; OUT_531] = { let __args: [G; IN_531] = []; let __cu = unconstrained; if let Some(result) = record.function_queries[531].get_mut(&__args[..]) { if !__cu && *result.multiplicity == G::ZERO { aiur_fn_531(__args, record, io_buffer, false)? } else { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_531] = unsafe { *(result.output.as_ptr() as *const [G; OUT_531]) }; __ret } } else { aiur_fn_531(__args, record, io_buffer, __cu)? } }; + let __r_arr: [G; OUT_527] = { let __args: [G; IN_527] = []; let __cu = unconstrained; if let Some(result) = record.function_queries[527].get_mut(&__args[..]) { if !__cu && *result.multiplicity == G::ZERO { aiur_fn_527(__args, record, io_buffer, false)? } else { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_527] = unsafe { *(result.output.as_ptr() as *const [G; OUT_527]) }; __ret } } else { aiur_fn_527(__args, record, io_buffer, __cu)? } }; let __v_8: G = __r_arr[0]; let __v_9: G = __r_arr[1]; - let __ret: [G; OUT_553] = [__v_8, __v_9]; - if let Some(result) = record.function_queries[553].get_mut(&inp[..]) { debug_assert_eq!(result.output, &__ret[..]); if !unconstrained { *result.multiplicity += G::ONE; } } else { record.function_queries[553].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained)); }; + let __ret: [G; OUT_549] = [__v_8, __v_9]; + if let Some(result) = record.function_queries[549].get_mut(&inp[..]) { debug_assert_eq!(result.output, &__ret[..]); if !unconstrained { *result.multiplicity += G::ONE; } } else { record.function_queries[549].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained)); }; return Ok(__ret); }, _ => { - let __r_arr: [G; OUT_290] = { let __args: [G; IN_290] = [__v_0, __v_1, __v_6]; let __cu = unconstrained; if let Some(result) = record.function_queries[290].get_mut(&__args[..]) { if !__cu && *result.multiplicity == G::ZERO { aiur_fn_290(__args, record, io_buffer, false)? } else { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_290] = unsafe { *(result.output.as_ptr() as *const [G; OUT_290]) }; __ret } } else { aiur_fn_290(__args, record, io_buffer, __cu)? } }; + let __r_arr: [G; OUT_286] = { let __args: [G; IN_286] = [__v_0, __v_1, __v_6]; let __cu = unconstrained; if let Some(result) = record.function_queries[286].get_mut(&__args[..]) { if !__cu && *result.multiplicity == G::ZERO { aiur_fn_286(__args, record, io_buffer, false)? } else { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_286] = unsafe { *(result.output.as_ptr() as *const [G; OUT_286]) }; __ret } } else { aiur_fn_286(__args, record, io_buffer, __cu)? } }; let __v_8: G = __r_arr[0]; let __loaded: [G; 12] = { let __mq = record.memory_queries.get_mut(&12).ok_or(ExecError::InvalidMemorySize(12))?; let __ptr_u64 = __v_8.as_canonical_u64(); let __ptr_usize = usize::try_from(__ptr_u64).ok().ok_or(ExecError::PointerTooLarge(__ptr_u64))?; let (__args, __mult) = __mq.get_index_mut(__ptr_usize).ok_or(ExecError::UnboundPointer { ptr: __ptr_u64, size: 12 })?; if !unconstrained { *__mult += G::ONE; } let __arr: [G; 12] = __args[..12].try_into().unwrap(); __arr }; let __v_9: G = __loaded[0]; @@ -48130,7 +47846,7 @@ fn aiur_fn_553( let __v_18: G = __loaded[9]; let __v_19: G = __loaded[10]; let __v_20: G = __loaded[11]; - let __r_arr: [G; OUT_290] = { let __args: [G; IN_290] = [__v_2, __v_3, __v_6]; let __cu = unconstrained; if let Some(result) = record.function_queries[290].get_mut(&__args[..]) { if !__cu && *result.multiplicity == G::ZERO { aiur_fn_290(__args, record, io_buffer, false)? } else { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_290] = unsafe { *(result.output.as_ptr() as *const [G; OUT_290]) }; __ret } } else { aiur_fn_290(__args, record, io_buffer, __cu)? } }; + let __r_arr: [G; OUT_286] = { let __args: [G; IN_286] = [__v_2, __v_3, __v_6]; let __cu = unconstrained; if let Some(result) = record.function_queries[286].get_mut(&__args[..]) { if !__cu && *result.multiplicity == G::ZERO { aiur_fn_286(__args, record, io_buffer, false)? } else { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_286] = unsafe { *(result.output.as_ptr() as *const [G; OUT_286]) }; __ret } } else { aiur_fn_286(__args, record, io_buffer, __cu)? } }; let __v_21: G = __r_arr[0]; let __loaded: [G; 12] = { let __mq = record.memory_queries.get_mut(&12).ok_or(ExecError::InvalidMemorySize(12))?; let __ptr_u64 = __v_21.as_canonical_u64(); let __ptr_usize = usize::try_from(__ptr_u64).ok().ok_or(ExecError::PointerTooLarge(__ptr_u64))?; let (__args, __mult) = __mq.get_index_mut(__ptr_usize).ok_or(ExecError::UnboundPointer { ptr: __ptr_u64, size: 12 })?; if !unconstrained { *__mult += G::ONE; } let __arr: [G; 12] = __args[..12].try_into().unwrap(); __arr }; let __v_22: G = __loaded[0]; @@ -48145,34 +47861,34 @@ fn aiur_fn_553( let __v_31: G = __loaded[9]; let __v_32: G = __loaded[10]; let __v_33: G = __loaded[11]; - let __r_arr: [G; OUT_554] = { let __args: [G; IN_554] = [__v_9, __v_10, __v_11, __v_12, __v_13, __v_14, __v_15, __v_16, __v_17, __v_18, __v_19, __v_20, __v_22, __v_23, __v_24, __v_25, __v_26, __v_27, __v_28, __v_29, __v_30, __v_31, __v_32, __v_33, __v_5]; let __cu = unconstrained; if let Some(result) = record.function_queries[554].get_mut(&__args[..]) { if !__cu && *result.multiplicity == G::ZERO { aiur_fn_554(__args, record, io_buffer, false)? } else { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_554] = unsafe { *(result.output.as_ptr() as *const [G; OUT_554]) }; __ret } } else { aiur_fn_554(__args, record, io_buffer, __cu)? } }; + let __r_arr: [G; OUT_550] = { let __args: [G; IN_550] = [__v_9, __v_10, __v_11, __v_12, __v_13, __v_14, __v_15, __v_16, __v_17, __v_18, __v_19, __v_20, __v_22, __v_23, __v_24, __v_25, __v_26, __v_27, __v_28, __v_29, __v_30, __v_31, __v_32, __v_33, __v_5]; let __cu = unconstrained; if let Some(result) = record.function_queries[550].get_mut(&__args[..]) { if !__cu && *result.multiplicity == G::ZERO { aiur_fn_550(__args, record, io_buffer, false)? } else { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_550] = unsafe { *(result.output.as_ptr() as *const [G; OUT_550]) }; __ret } } else { aiur_fn_550(__args, record, io_buffer, __cu)? } }; let __v_34: G = __r_arr[0]; let __v_35: G = __r_arr[1]; let __v_36: G = G::from_u64(1); let __v_37: G = (__v_6 + __v_36); - let __r_arr: [G; OUT_553] = { let __args: [G; IN_553] = [__v_0, __v_1, __v_2, __v_3, __v_4, __v_5, __v_37]; let __cu = unconstrained; if let Some(result) = record.function_queries[553].get_mut(&__args[..]) { if !__cu && *result.multiplicity == G::ZERO { aiur_fn_553(__args, record, io_buffer, false)? } else { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_553] = unsafe { *(result.output.as_ptr() as *const [G; OUT_553]) }; __ret } } else { aiur_fn_553(__args, record, io_buffer, __cu)? } }; + let __r_arr: [G; OUT_549] = { let __args: [G; IN_549] = [__v_0, __v_1, __v_2, __v_3, __v_4, __v_5, __v_37]; let __cu = unconstrained; if let Some(result) = record.function_queries[549].get_mut(&__args[..]) { if !__cu && *result.multiplicity == G::ZERO { aiur_fn_549(__args, record, io_buffer, false)? } else { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_549] = unsafe { *(result.output.as_ptr() as *const [G; OUT_549]) }; __ret } } else { aiur_fn_549(__args, record, io_buffer, __cu)? } }; let __v_38: G = __r_arr[0]; let __v_39: G = __r_arr[1]; - let __r_arr: [G; OUT_533] = { let __args: [G; IN_533] = [__v_34, __v_35, __v_38, __v_39]; let __cu = unconstrained; if let Some(result) = record.function_queries[533].get_mut(&__args[..]) { if !__cu && *result.multiplicity == G::ZERO { aiur_fn_533(__args, record, io_buffer, false)? } else { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_533] = unsafe { *(result.output.as_ptr() as *const [G; OUT_533]) }; __ret } } else { aiur_fn_533(__args, record, io_buffer, __cu)? } }; + let __r_arr: [G; OUT_529] = { let __args: [G; IN_529] = [__v_34, __v_35, __v_38, __v_39]; let __cu = unconstrained; if let Some(result) = record.function_queries[529].get_mut(&__args[..]) { if !__cu && *result.multiplicity == G::ZERO { aiur_fn_529(__args, record, io_buffer, false)? } else { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_529] = unsafe { *(result.output.as_ptr() as *const [G; OUT_529]) }; __ret } } else { aiur_fn_529(__args, record, io_buffer, __cu)? } }; let __v_40: G = __r_arr[0]; let __v_41: G = __r_arr[1]; - let __ret: [G; OUT_553] = [__v_40, __v_41]; - if let Some(result) = record.function_queries[553].get_mut(&inp[..]) { debug_assert_eq!(result.output, &__ret[..]); if !unconstrained { *result.multiplicity += G::ONE; } } else { record.function_queries[553].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained)); }; + let __ret: [G; OUT_549] = [__v_40, __v_41]; + if let Some(result) = record.function_queries[549].get_mut(&inp[..]) { debug_assert_eq!(result.output, &__ret[..]); if !unconstrained { *result.multiplicity += G::ONE; } } else { record.function_queries[549].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained)); }; return Ok(__ret); }, } }) } -const INPUT_SIZE_554: usize = 25; -const IN_554: usize = 25; -const OUT_554: usize = 2; -fn aiur_fn_554( - inp: [G; IN_554], +const INPUT_SIZE_550: usize = 25; +const IN_550: usize = 25; +const OUT_550: usize = 2; +fn aiur_fn_550( + inp: [G; IN_550], record: &mut QueryRecord, io_buffer: &mut IOBuffer, unconstrained: bool, -) -> Result<[G; OUT_554], ExecError> { +) -> Result<[G; OUT_550], ExecError> { stacker::maybe_grow(64 * 1024, 4 * 1024 * 1024, || { let __v_0: G = inp[0]; let __v_1: G = inp[1]; @@ -48203,94 +47919,94 @@ fn aiur_fn_554( 6u64 => { match __v_12.as_canonical_u64() { 6u64 => { - let __r_arr: [G; OUT_528] = { let __args: [G; IN_528] = [__v_1, __v_13]; let __cu = unconstrained; if let Some(result) = record.function_queries[528].get_mut(&__args[..]) { if !__cu && *result.multiplicity == G::ZERO { aiur_fn_528(__args, record, io_buffer, false)? } else { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_528] = unsafe { *(result.output.as_ptr() as *const [G; OUT_528]) }; __ret } } else { aiur_fn_528(__args, record, io_buffer, __cu)? } }; + let __r_arr: [G; OUT_524] = { let __args: [G; IN_524] = [__v_1, __v_13]; let __cu = unconstrained; if let Some(result) = record.function_queries[524].get_mut(&__args[..]) { if !__cu && *result.multiplicity == G::ZERO { aiur_fn_524(__args, record, io_buffer, false)? } else { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_524] = unsafe { *(result.output.as_ptr() as *const [G; OUT_524]) }; __ret } } else { aiur_fn_524(__args, record, io_buffer, __cu)? } }; let __v_25: G = __r_arr[0]; - let __r_arr: [G; OUT_534] = { let __args: [G; IN_534] = [__v_25]; let __cu = unconstrained; if let Some(result) = record.function_queries[534].get_mut(&__args[..]) { if !__cu && *result.multiplicity == G::ZERO { aiur_fn_534(__args, record, io_buffer, false)? } else { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_534] = unsafe { *(result.output.as_ptr() as *const [G; OUT_534]) }; __ret } } else { aiur_fn_534(__args, record, io_buffer, __cu)? } }; + let __r_arr: [G; OUT_530] = { let __args: [G; IN_530] = [__v_25]; let __cu = unconstrained; if let Some(result) = record.function_queries[530].get_mut(&__args[..]) { if !__cu && *result.multiplicity == G::ZERO { aiur_fn_530(__args, record, io_buffer, false)? } else { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_530] = unsafe { *(result.output.as_ptr() as *const [G; OUT_530]) }; __ret } } else { aiur_fn_530(__args, record, io_buffer, __cu)? } }; let __v_26: G = __r_arr[0]; let __v_27: G = __r_arr[1]; - let __r_arr: [G; OUT_528] = { let __args: [G; IN_528] = [__v_5, __v_17]; let __cu = unconstrained; if let Some(result) = record.function_queries[528].get_mut(&__args[..]) { if !__cu && *result.multiplicity == G::ZERO { aiur_fn_528(__args, record, io_buffer, false)? } else { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_528] = unsafe { *(result.output.as_ptr() as *const [G; OUT_528]) }; __ret } } else { aiur_fn_528(__args, record, io_buffer, __cu)? } }; + let __r_arr: [G; OUT_524] = { let __args: [G; IN_524] = [__v_5, __v_17]; let __cu = unconstrained; if let Some(result) = record.function_queries[524].get_mut(&__args[..]) { if !__cu && *result.multiplicity == G::ZERO { aiur_fn_524(__args, record, io_buffer, false)? } else { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_524] = unsafe { *(result.output.as_ptr() as *const [G; OUT_524]) }; __ret } } else { aiur_fn_524(__args, record, io_buffer, __cu)? } }; let __v_28: G = __r_arr[0]; - let __r_arr: [G; OUT_534] = { let __args: [G; IN_534] = [__v_28]; let __cu = unconstrained; if let Some(result) = record.function_queries[534].get_mut(&__args[..]) { if !__cu && *result.multiplicity == G::ZERO { aiur_fn_534(__args, record, io_buffer, false)? } else { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_534] = unsafe { *(result.output.as_ptr() as *const [G; OUT_534]) }; __ret } } else { aiur_fn_534(__args, record, io_buffer, __cu)? } }; + let __r_arr: [G; OUT_530] = { let __args: [G; IN_530] = [__v_28]; let __cu = unconstrained; if let Some(result) = record.function_queries[530].get_mut(&__args[..]) { if !__cu && *result.multiplicity == G::ZERO { aiur_fn_530(__args, record, io_buffer, false)? } else { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_530] = unsafe { *(result.output.as_ptr() as *const [G; OUT_530]) }; __ret } } else { aiur_fn_530(__args, record, io_buffer, __cu)? } }; let __v_29: G = __r_arr[0]; let __v_30: G = __r_arr[1]; - let __r_arr: [G; OUT_528] = { let __args: [G; IN_528] = [__v_6, __v_18]; let __cu = unconstrained; if let Some(result) = record.function_queries[528].get_mut(&__args[..]) { if !__cu && *result.multiplicity == G::ZERO { aiur_fn_528(__args, record, io_buffer, false)? } else { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_528] = unsafe { *(result.output.as_ptr() as *const [G; OUT_528]) }; __ret } } else { aiur_fn_528(__args, record, io_buffer, __cu)? } }; + let __r_arr: [G; OUT_524] = { let __args: [G; IN_524] = [__v_6, __v_18]; let __cu = unconstrained; if let Some(result) = record.function_queries[524].get_mut(&__args[..]) { if !__cu && *result.multiplicity == G::ZERO { aiur_fn_524(__args, record, io_buffer, false)? } else { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_524] = unsafe { *(result.output.as_ptr() as *const [G; OUT_524]) }; __ret } } else { aiur_fn_524(__args, record, io_buffer, __cu)? } }; let __v_31: G = __r_arr[0]; - let __r_arr: [G; OUT_534] = { let __args: [G; IN_534] = [__v_31]; let __cu = unconstrained; if let Some(result) = record.function_queries[534].get_mut(&__args[..]) { if !__cu && *result.multiplicity == G::ZERO { aiur_fn_534(__args, record, io_buffer, false)? } else { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_534] = unsafe { *(result.output.as_ptr() as *const [G; OUT_534]) }; __ret } } else { aiur_fn_534(__args, record, io_buffer, __cu)? } }; + let __r_arr: [G; OUT_530] = { let __args: [G; IN_530] = [__v_31]; let __cu = unconstrained; if let Some(result) = record.function_queries[530].get_mut(&__args[..]) { if !__cu && *result.multiplicity == G::ZERO { aiur_fn_530(__args, record, io_buffer, false)? } else { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_530] = unsafe { *(result.output.as_ptr() as *const [G; OUT_530]) }; __ret } } else { aiur_fn_530(__args, record, io_buffer, __cu)? } }; let __v_32: G = __r_arr[0]; let __v_33: G = __r_arr[1]; - let __r_arr: [G; OUT_528] = { let __args: [G; IN_528] = [__v_7, __v_19]; let __cu = unconstrained; if let Some(result) = record.function_queries[528].get_mut(&__args[..]) { if !__cu && *result.multiplicity == G::ZERO { aiur_fn_528(__args, record, io_buffer, false)? } else { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_528] = unsafe { *(result.output.as_ptr() as *const [G; OUT_528]) }; __ret } } else { aiur_fn_528(__args, record, io_buffer, __cu)? } }; + let __r_arr: [G; OUT_524] = { let __args: [G; IN_524] = [__v_7, __v_19]; let __cu = unconstrained; if let Some(result) = record.function_queries[524].get_mut(&__args[..]) { if !__cu && *result.multiplicity == G::ZERO { aiur_fn_524(__args, record, io_buffer, false)? } else { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_524] = unsafe { *(result.output.as_ptr() as *const [G; OUT_524]) }; __ret } } else { aiur_fn_524(__args, record, io_buffer, __cu)? } }; let __v_34: G = __r_arr[0]; - let __r_arr: [G; OUT_534] = { let __args: [G; IN_534] = [__v_34]; let __cu = unconstrained; if let Some(result) = record.function_queries[534].get_mut(&__args[..]) { if !__cu && *result.multiplicity == G::ZERO { aiur_fn_534(__args, record, io_buffer, false)? } else { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_534] = unsafe { *(result.output.as_ptr() as *const [G; OUT_534]) }; __ret } } else { aiur_fn_534(__args, record, io_buffer, __cu)? } }; + let __r_arr: [G; OUT_530] = { let __args: [G; IN_530] = [__v_34]; let __cu = unconstrained; if let Some(result) = record.function_queries[530].get_mut(&__args[..]) { if !__cu && *result.multiplicity == G::ZERO { aiur_fn_530(__args, record, io_buffer, false)? } else { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_530] = unsafe { *(result.output.as_ptr() as *const [G; OUT_530]) }; __ret } } else { aiur_fn_530(__args, record, io_buffer, __cu)? } }; let __v_35: G = __r_arr[0]; let __v_36: G = __r_arr[1]; - let __r_arr: [G; OUT_546] = { let __args: [G; IN_546] = [__v_2, __v_14, __v_24]; let __cu = unconstrained; if let Some(result) = record.function_queries[546].get_mut(&__args[..]) { if !__cu && *result.multiplicity == G::ZERO { aiur_fn_546(__args, record, io_buffer, false)? } else { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_546] = unsafe { *(result.output.as_ptr() as *const [G; OUT_546]) }; __ret } } else { aiur_fn_546(__args, record, io_buffer, __cu)? } }; + let __r_arr: [G; OUT_542] = { let __args: [G; IN_542] = [__v_2, __v_14, __v_24]; let __cu = unconstrained; if let Some(result) = record.function_queries[542].get_mut(&__args[..]) { if !__cu && *result.multiplicity == G::ZERO { aiur_fn_542(__args, record, io_buffer, false)? } else { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_542] = unsafe { *(result.output.as_ptr() as *const [G; OUT_542]) }; __ret } } else { aiur_fn_542(__args, record, io_buffer, __cu)? } }; let __v_37: G = __r_arr[0]; let __v_38: G = __r_arr[1]; - let __r_arr: [G; OUT_533] = { let __args: [G; IN_533] = [__v_35, __v_36, __v_37, __v_38]; let __cu = unconstrained; if let Some(result) = record.function_queries[533].get_mut(&__args[..]) { if !__cu && *result.multiplicity == G::ZERO { aiur_fn_533(__args, record, io_buffer, false)? } else { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_533] = unsafe { *(result.output.as_ptr() as *const [G; OUT_533]) }; __ret } } else { aiur_fn_533(__args, record, io_buffer, __cu)? } }; + let __r_arr: [G; OUT_529] = { let __args: [G; IN_529] = [__v_35, __v_36, __v_37, __v_38]; let __cu = unconstrained; if let Some(result) = record.function_queries[529].get_mut(&__args[..]) { if !__cu && *result.multiplicity == G::ZERO { aiur_fn_529(__args, record, io_buffer, false)? } else { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_529] = unsafe { *(result.output.as_ptr() as *const [G; OUT_529]) }; __ret } } else { aiur_fn_529(__args, record, io_buffer, __cu)? } }; let __v_39: G = __r_arr[0]; let __v_40: G = __r_arr[1]; - let __r_arr: [G; OUT_533] = { let __args: [G; IN_533] = [__v_32, __v_33, __v_39, __v_40]; let __cu = unconstrained; if let Some(result) = record.function_queries[533].get_mut(&__args[..]) { if !__cu && *result.multiplicity == G::ZERO { aiur_fn_533(__args, record, io_buffer, false)? } else { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_533] = unsafe { *(result.output.as_ptr() as *const [G; OUT_533]) }; __ret } } else { aiur_fn_533(__args, record, io_buffer, __cu)? } }; + let __r_arr: [G; OUT_529] = { let __args: [G; IN_529] = [__v_32, __v_33, __v_39, __v_40]; let __cu = unconstrained; if let Some(result) = record.function_queries[529].get_mut(&__args[..]) { if !__cu && *result.multiplicity == G::ZERO { aiur_fn_529(__args, record, io_buffer, false)? } else { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_529] = unsafe { *(result.output.as_ptr() as *const [G; OUT_529]) }; __ret } } else { aiur_fn_529(__args, record, io_buffer, __cu)? } }; let __v_41: G = __r_arr[0]; let __v_42: G = __r_arr[1]; - let __r_arr: [G; OUT_533] = { let __args: [G; IN_533] = [__v_29, __v_30, __v_41, __v_42]; let __cu = unconstrained; if let Some(result) = record.function_queries[533].get_mut(&__args[..]) { if !__cu && *result.multiplicity == G::ZERO { aiur_fn_533(__args, record, io_buffer, false)? } else { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_533] = unsafe { *(result.output.as_ptr() as *const [G; OUT_533]) }; __ret } } else { aiur_fn_533(__args, record, io_buffer, __cu)? } }; + let __r_arr: [G; OUT_529] = { let __args: [G; IN_529] = [__v_29, __v_30, __v_41, __v_42]; let __cu = unconstrained; if let Some(result) = record.function_queries[529].get_mut(&__args[..]) { if !__cu && *result.multiplicity == G::ZERO { aiur_fn_529(__args, record, io_buffer, false)? } else { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_529] = unsafe { *(result.output.as_ptr() as *const [G; OUT_529]) }; __ret } } else { aiur_fn_529(__args, record, io_buffer, __cu)? } }; let __v_43: G = __r_arr[0]; let __v_44: G = __r_arr[1]; - let __r_arr: [G; OUT_533] = { let __args: [G; IN_533] = [__v_26, __v_27, __v_43, __v_44]; let __cu = unconstrained; if let Some(result) = record.function_queries[533].get_mut(&__args[..]) { if !__cu && *result.multiplicity == G::ZERO { aiur_fn_533(__args, record, io_buffer, false)? } else { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_533] = unsafe { *(result.output.as_ptr() as *const [G; OUT_533]) }; __ret } } else { aiur_fn_533(__args, record, io_buffer, __cu)? } }; + let __r_arr: [G; OUT_529] = { let __args: [G; IN_529] = [__v_26, __v_27, __v_43, __v_44]; let __cu = unconstrained; if let Some(result) = record.function_queries[529].get_mut(&__args[..]) { if !__cu && *result.multiplicity == G::ZERO { aiur_fn_529(__args, record, io_buffer, false)? } else { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_529] = unsafe { *(result.output.as_ptr() as *const [G; OUT_529]) }; __ret } } else { aiur_fn_529(__args, record, io_buffer, __cu)? } }; let __v_45: G = __r_arr[0]; let __v_46: G = __r_arr[1]; - let __ret: [G; OUT_554] = [__v_45, __v_46]; - if let Some(result) = record.function_queries[554].get_mut(&inp[..]) { debug_assert_eq!(result.output, &__ret[..]); if !unconstrained { *result.multiplicity += G::ONE; } } else { record.function_queries[554].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained)); }; + let __ret: [G; OUT_550] = [__v_45, __v_46]; + if let Some(result) = record.function_queries[550].get_mut(&inp[..]) { debug_assert_eq!(result.output, &__ret[..]); if !unconstrained { *result.multiplicity += G::ONE; } } else { record.function_queries[550].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained)); }; return Ok(__ret); }, _ => { - let __r_arr: [G; OUT_550] = { let __args: [G; IN_550] = [__v_0, __v_1, __v_2, __v_3, __v_4, __v_5, __v_6, __v_7, __v_8, __v_9, __v_10, __v_11]; let __cu = unconstrained; if let Some(result) = record.function_queries[550].get_mut(&__args[..]) { if !__cu && *result.multiplicity == G::ZERO { aiur_fn_550(__args, record, io_buffer, false)? } else { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_550] = unsafe { *(result.output.as_ptr() as *const [G; OUT_550]) }; __ret } } else { aiur_fn_550(__args, record, io_buffer, __cu)? } }; + let __r_arr: [G; OUT_546] = { let __args: [G; IN_546] = [__v_0, __v_1, __v_2, __v_3, __v_4, __v_5, __v_6, __v_7, __v_8, __v_9, __v_10, __v_11]; let __cu = unconstrained; if let Some(result) = record.function_queries[546].get_mut(&__args[..]) { if !__cu && *result.multiplicity == G::ZERO { aiur_fn_546(__args, record, io_buffer, false)? } else { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_546] = unsafe { *(result.output.as_ptr() as *const [G; OUT_546]) }; __ret } } else { aiur_fn_546(__args, record, io_buffer, __cu)? } }; let __v_25: G = __r_arr[0]; - let __r_arr: [G; OUT_550] = { let __args: [G; IN_550] = [__v_12, __v_13, __v_14, __v_15, __v_16, __v_17, __v_18, __v_19, __v_20, __v_21, __v_22, __v_23]; let __cu = unconstrained; if let Some(result) = record.function_queries[550].get_mut(&__args[..]) { if !__cu && *result.multiplicity == G::ZERO { aiur_fn_550(__args, record, io_buffer, false)? } else { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_550] = unsafe { *(result.output.as_ptr() as *const [G; OUT_550]) }; __ret } } else { aiur_fn_550(__args, record, io_buffer, __cu)? } }; + let __r_arr: [G; OUT_546] = { let __args: [G; IN_546] = [__v_12, __v_13, __v_14, __v_15, __v_16, __v_17, __v_18, __v_19, __v_20, __v_21, __v_22, __v_23]; let __cu = unconstrained; if let Some(result) = record.function_queries[546].get_mut(&__args[..]) { if !__cu && *result.multiplicity == G::ZERO { aiur_fn_546(__args, record, io_buffer, false)? } else { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_546] = unsafe { *(result.output.as_ptr() as *const [G; OUT_546]) }; __ret } } else { aiur_fn_546(__args, record, io_buffer, __cu)? } }; let __v_26: G = __r_arr[0]; - let __r_arr: [G; OUT_528] = { let __args: [G; IN_528] = [__v_25, __v_26]; let __cu = unconstrained; if let Some(result) = record.function_queries[528].get_mut(&__args[..]) { if !__cu && *result.multiplicity == G::ZERO { aiur_fn_528(__args, record, io_buffer, false)? } else { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_528] = unsafe { *(result.output.as_ptr() as *const [G; OUT_528]) }; __ret } } else { aiur_fn_528(__args, record, io_buffer, __cu)? } }; + let __r_arr: [G; OUT_524] = { let __args: [G; IN_524] = [__v_25, __v_26]; let __cu = unconstrained; if let Some(result) = record.function_queries[524].get_mut(&__args[..]) { if !__cu && *result.multiplicity == G::ZERO { aiur_fn_524(__args, record, io_buffer, false)? } else { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_524] = unsafe { *(result.output.as_ptr() as *const [G; OUT_524]) }; __ret } } else { aiur_fn_524(__args, record, io_buffer, __cu)? } }; let __v_27: G = __r_arr[0]; - let __r_arr: [G; OUT_534] = { let __args: [G; IN_534] = [__v_27]; let __cu = unconstrained; if let Some(result) = record.function_queries[534].get_mut(&__args[..]) { if !__cu && *result.multiplicity == G::ZERO { aiur_fn_534(__args, record, io_buffer, false)? } else { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_534] = unsafe { *(result.output.as_ptr() as *const [G; OUT_534]) }; __ret } } else { aiur_fn_534(__args, record, io_buffer, __cu)? } }; + let __r_arr: [G; OUT_530] = { let __args: [G; IN_530] = [__v_27]; let __cu = unconstrained; if let Some(result) = record.function_queries[530].get_mut(&__args[..]) { if !__cu && *result.multiplicity == G::ZERO { aiur_fn_530(__args, record, io_buffer, false)? } else { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_530] = unsafe { *(result.output.as_ptr() as *const [G; OUT_530]) }; __ret } } else { aiur_fn_530(__args, record, io_buffer, __cu)? } }; let __v_28: G = __r_arr[0]; let __v_29: G = __r_arr[1]; - let __ret: [G; OUT_554] = [__v_28, __v_29]; - if let Some(result) = record.function_queries[554].get_mut(&inp[..]) { debug_assert_eq!(result.output, &__ret[..]); if !unconstrained { *result.multiplicity += G::ONE; } } else { record.function_queries[554].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained)); }; + let __ret: [G; OUT_550] = [__v_28, __v_29]; + if let Some(result) = record.function_queries[550].get_mut(&inp[..]) { debug_assert_eq!(result.output, &__ret[..]); if !unconstrained { *result.multiplicity += G::ONE; } } else { record.function_queries[550].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained)); }; return Ok(__ret); }, } }, _ => { - let __r_arr: [G; OUT_550] = { let __args: [G; IN_550] = [__v_0, __v_1, __v_2, __v_3, __v_4, __v_5, __v_6, __v_7, __v_8, __v_9, __v_10, __v_11]; let __cu = unconstrained; if let Some(result) = record.function_queries[550].get_mut(&__args[..]) { if !__cu && *result.multiplicity == G::ZERO { aiur_fn_550(__args, record, io_buffer, false)? } else { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_550] = unsafe { *(result.output.as_ptr() as *const [G; OUT_550]) }; __ret } } else { aiur_fn_550(__args, record, io_buffer, __cu)? } }; + let __r_arr: [G; OUT_546] = { let __args: [G; IN_546] = [__v_0, __v_1, __v_2, __v_3, __v_4, __v_5, __v_6, __v_7, __v_8, __v_9, __v_10, __v_11]; let __cu = unconstrained; if let Some(result) = record.function_queries[546].get_mut(&__args[..]) { if !__cu && *result.multiplicity == G::ZERO { aiur_fn_546(__args, record, io_buffer, false)? } else { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_546] = unsafe { *(result.output.as_ptr() as *const [G; OUT_546]) }; __ret } } else { aiur_fn_546(__args, record, io_buffer, __cu)? } }; let __v_25: G = __r_arr[0]; - let __r_arr: [G; OUT_550] = { let __args: [G; IN_550] = [__v_12, __v_13, __v_14, __v_15, __v_16, __v_17, __v_18, __v_19, __v_20, __v_21, __v_22, __v_23]; let __cu = unconstrained; if let Some(result) = record.function_queries[550].get_mut(&__args[..]) { if !__cu && *result.multiplicity == G::ZERO { aiur_fn_550(__args, record, io_buffer, false)? } else { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_550] = unsafe { *(result.output.as_ptr() as *const [G; OUT_550]) }; __ret } } else { aiur_fn_550(__args, record, io_buffer, __cu)? } }; + let __r_arr: [G; OUT_546] = { let __args: [G; IN_546] = [__v_12, __v_13, __v_14, __v_15, __v_16, __v_17, __v_18, __v_19, __v_20, __v_21, __v_22, __v_23]; let __cu = unconstrained; if let Some(result) = record.function_queries[546].get_mut(&__args[..]) { if !__cu && *result.multiplicity == G::ZERO { aiur_fn_546(__args, record, io_buffer, false)? } else { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_546] = unsafe { *(result.output.as_ptr() as *const [G; OUT_546]) }; __ret } } else { aiur_fn_546(__args, record, io_buffer, __cu)? } }; let __v_26: G = __r_arr[0]; - let __r_arr: [G; OUT_528] = { let __args: [G; IN_528] = [__v_25, __v_26]; let __cu = unconstrained; if let Some(result) = record.function_queries[528].get_mut(&__args[..]) { if !__cu && *result.multiplicity == G::ZERO { aiur_fn_528(__args, record, io_buffer, false)? } else { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_528] = unsafe { *(result.output.as_ptr() as *const [G; OUT_528]) }; __ret } } else { aiur_fn_528(__args, record, io_buffer, __cu)? } }; + let __r_arr: [G; OUT_524] = { let __args: [G; IN_524] = [__v_25, __v_26]; let __cu = unconstrained; if let Some(result) = record.function_queries[524].get_mut(&__args[..]) { if !__cu && *result.multiplicity == G::ZERO { aiur_fn_524(__args, record, io_buffer, false)? } else { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_524] = unsafe { *(result.output.as_ptr() as *const [G; OUT_524]) }; __ret } } else { aiur_fn_524(__args, record, io_buffer, __cu)? } }; let __v_27: G = __r_arr[0]; - let __r_arr: [G; OUT_534] = { let __args: [G; IN_534] = [__v_27]; let __cu = unconstrained; if let Some(result) = record.function_queries[534].get_mut(&__args[..]) { if !__cu && *result.multiplicity == G::ZERO { aiur_fn_534(__args, record, io_buffer, false)? } else { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_534] = unsafe { *(result.output.as_ptr() as *const [G; OUT_534]) }; __ret } } else { aiur_fn_534(__args, record, io_buffer, __cu)? } }; + let __r_arr: [G; OUT_530] = { let __args: [G; IN_530] = [__v_27]; let __cu = unconstrained; if let Some(result) = record.function_queries[530].get_mut(&__args[..]) { if !__cu && *result.multiplicity == G::ZERO { aiur_fn_530(__args, record, io_buffer, false)? } else { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_530] = unsafe { *(result.output.as_ptr() as *const [G; OUT_530]) }; __ret } } else { aiur_fn_530(__args, record, io_buffer, __cu)? } }; let __v_28: G = __r_arr[0]; let __v_29: G = __r_arr[1]; - let __ret: [G; OUT_554] = [__v_28, __v_29]; - if let Some(result) = record.function_queries[554].get_mut(&inp[..]) { debug_assert_eq!(result.output, &__ret[..]); if !unconstrained { *result.multiplicity += G::ONE; } } else { record.function_queries[554].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained)); }; + let __ret: [G; OUT_550] = [__v_28, __v_29]; + if let Some(result) = record.function_queries[550].get_mut(&inp[..]) { debug_assert_eq!(result.output, &__ret[..]); if !unconstrained { *result.multiplicity += G::ONE; } } else { record.function_queries[550].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained)); }; return Ok(__ret); }, } }) } -const INPUT_SIZE_555: usize = 3; -const IN_555: usize = 3; -const OUT_555: usize = 1; -fn aiur_fn_555( - inp: [G; IN_555], +const INPUT_SIZE_551: usize = 3; +const IN_551: usize = 3; +const OUT_551: usize = 1; +fn aiur_fn_551( + inp: [G; IN_551], record: &mut QueryRecord, io_buffer: &mut IOBuffer, unconstrained: bool, -) -> Result<[G; OUT_555], ExecError> { +) -> Result<[G; OUT_551], ExecError> { stacker::maybe_grow(64 * 1024, 4 * 1024 * 1024, || { let __v_0: G = inp[0]; let __v_1: G = inp[1]; let __v_2: G = inp[2]; let __v_3: G = G::from_u64(4); - let __r_arr: [G; OUT_293] = { let __args: [G; IN_293] = [__v_1]; let __cu = unconstrained; if let Some(result) = record.function_queries[293].get_mut(&__args[..]) { if !__cu && *result.multiplicity == G::ZERO { aiur_fn_293(__args, record, io_buffer, false)? } else { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_293] = unsafe { *(result.output.as_ptr() as *const [G; OUT_293]) }; __ret } } else { aiur_fn_293(__args, record, io_buffer, __cu)? } }; + let __r_arr: [G; OUT_289] = { let __args: [G; IN_289] = [__v_1]; let __cu = unconstrained; if let Some(result) = record.function_queries[289].get_mut(&__args[..]) { if !__cu && *result.multiplicity == G::ZERO { aiur_fn_289(__args, record, io_buffer, false)? } else { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_289] = unsafe { *(result.output.as_ptr() as *const [G; OUT_289]) }; __ret } } else { aiur_fn_289(__args, record, io_buffer, __cu)? } }; let __v_4: G = __r_arr[0]; let __v_5: G = __r_arr[1]; let __v_6: G = __r_arr[2]; @@ -48299,7 +48015,7 @@ fn aiur_fn_555( let __v_9: G = __r_arr[5]; let __v_10: G = __r_arr[6]; let __v_11: G = __r_arr[7]; - let __r_arr: [G; OUT_293] = { let __args: [G; IN_293] = [__v_2]; let __cu = unconstrained; if let Some(result) = record.function_queries[293].get_mut(&__args[..]) { if !__cu && *result.multiplicity == G::ZERO { aiur_fn_293(__args, record, io_buffer, false)? } else { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_293] = unsafe { *(result.output.as_ptr() as *const [G; OUT_293]) }; __ret } } else { aiur_fn_293(__args, record, io_buffer, __cu)? } }; + let __r_arr: [G; OUT_289] = { let __args: [G; IN_289] = [__v_2]; let __cu = unconstrained; if let Some(result) = record.function_queries[289].get_mut(&__args[..]) { if !__cu && *result.multiplicity == G::ZERO { aiur_fn_289(__args, record, io_buffer, false)? } else { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_289] = unsafe { *(result.output.as_ptr() as *const [G; OUT_289]) }; __ret } } else { aiur_fn_289(__args, record, io_buffer, __cu)? } }; let __v_12: G = __r_arr[0]; let __v_13: G = __r_arr[1]; let __v_14: G = __r_arr[2]; @@ -48325,27 +48041,27 @@ fn aiur_fn_555( let __v_33: G = __r_arr[0]; let __r_arr: [G; OUT_21] = { let __args: [G; IN_21] = [__v_33]; let __cu = unconstrained; if let Some(result) = record.function_queries[21].get_mut(&__args[..]) { if !__cu && *result.multiplicity == G::ZERO { aiur_fn_21(__args, record, io_buffer, false)? } else { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_21] = unsafe { *(result.output.as_ptr() as *const [G; OUT_21]) }; __ret } } else { aiur_fn_21(__args, record, io_buffer, __cu)? } }; let __v_34: G = __r_arr[0]; - let __ret: [G; OUT_555] = [__v_34]; - if let Some(result) = record.function_queries[555].get_mut(&inp[..]) { debug_assert_eq!(result.output, &__ret[..]); if !unconstrained { *result.multiplicity += G::ONE; } } else { record.function_queries[555].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained)); }; + let __ret: [G; OUT_551] = [__v_34]; + if let Some(result) = record.function_queries[551].get_mut(&inp[..]) { debug_assert_eq!(result.output, &__ret[..]); if !unconstrained { *result.multiplicity += G::ONE; } } else { record.function_queries[551].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained)); }; return Ok(__ret); }) } -const INPUT_SIZE_556: usize = 2; -const IN_556: usize = 2; -const OUT_556: usize = 12; -fn aiur_fn_556( - inp: [G; IN_556], +const INPUT_SIZE_552: usize = 2; +const IN_552: usize = 2; +const OUT_552: usize = 12; +fn aiur_fn_552( + inp: [G; IN_552], record: &mut QueryRecord, io_buffer: &mut IOBuffer, unconstrained: bool, -) -> Result<[G; OUT_556], ExecError> { +) -> Result<[G; OUT_552], ExecError> { stacker::maybe_grow(64 * 1024, 4 * 1024 * 1024, || { let __v_0: G = inp[0]; let __v_1: G = inp[1]; - let __r_arr: [G; OUT_766] = { let __args: [G; IN_766] = [__v_0, __v_1]; let __cu = unconstrained; if let Some(result) = record.function_queries[766].get_mut(&__args[..]) { if !__cu && *result.multiplicity == G::ZERO { aiur_fn_766(__args, record, io_buffer, false)? } else { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_766] = unsafe { *(result.output.as_ptr() as *const [G; OUT_766]) }; __ret } } else { aiur_fn_766(__args, record, io_buffer, __cu)? } }; + let __r_arr: [G; OUT_762] = { let __args: [G; IN_762] = [__v_0, __v_1]; let __cu = unconstrained; if let Some(result) = record.function_queries[762].get_mut(&__args[..]) { if !__cu && *result.multiplicity == G::ZERO { aiur_fn_762(__args, record, io_buffer, false)? } else { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_762] = unsafe { *(result.output.as_ptr() as *const [G; OUT_762]) }; __ret } } else { aiur_fn_762(__args, record, io_buffer, __cu)? } }; let __v_2: G = __r_arr[0]; - let __r_arr: [G; OUT_287] = { let __args: [G; IN_287] = [__v_2]; let __cu = unconstrained; if let Some(result) = record.function_queries[287].get_mut(&__args[..]) { if !__cu && *result.multiplicity == G::ZERO { aiur_fn_287(__args, record, io_buffer, false)? } else { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_287] = unsafe { *(result.output.as_ptr() as *const [G; OUT_287]) }; __ret } } else { aiur_fn_287(__args, record, io_buffer, __cu)? } }; + let __r_arr: [G; OUT_283] = { let __args: [G; IN_283] = [__v_2]; let __cu = unconstrained; if let Some(result) = record.function_queries[283].get_mut(&__args[..]) { if !__cu && *result.multiplicity == G::ZERO { aiur_fn_283(__args, record, io_buffer, false)? } else { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_283] = unsafe { *(result.output.as_ptr() as *const [G; OUT_283]) }; __ret } } else { aiur_fn_283(__args, record, io_buffer, __cu)? } }; let __v_3: G = __r_arr[0]; let __loaded: [G; 12] = { let __mq = record.memory_queries.get_mut(&12).ok_or(ExecError::InvalidMemorySize(12))?; let __ptr_u64 = __v_3.as_canonical_u64(); let __ptr_usize = usize::try_from(__ptr_u64).ok().ok_or(ExecError::PointerTooLarge(__ptr_u64))?; let (__args, __mult) = __mq.get_index_mut(__ptr_usize).ok_or(ExecError::UnboundPointer { ptr: __ptr_u64, size: 12 })?; if !unconstrained { *__mult += G::ONE; } let __arr: [G; 12] = __args[..12].try_into().unwrap(); __arr }; let __v_4: G = __loaded[0]; @@ -48360,25 +48076,25 @@ fn aiur_fn_556( let __v_13: G = __loaded[9]; let __v_14: G = __loaded[10]; let __v_15: G = __loaded[11]; - let __ret: [G; OUT_556] = [__v_4, __v_5, __v_6, __v_7, __v_8, __v_9, __v_10, __v_11, __v_12, __v_13, __v_14, __v_15]; - if let Some(result) = record.function_queries[556].get_mut(&inp[..]) { debug_assert_eq!(result.output, &__ret[..]); if !unconstrained { *result.multiplicity += G::ONE; } } else { record.function_queries[556].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained)); }; + let __ret: [G; OUT_552] = [__v_4, __v_5, __v_6, __v_7, __v_8, __v_9, __v_10, __v_11, __v_12, __v_13, __v_14, __v_15]; + if let Some(result) = record.function_queries[552].get_mut(&inp[..]) { debug_assert_eq!(result.output, &__ret[..]); if !unconstrained { *result.multiplicity += G::ONE; } } else { record.function_queries[552].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained)); }; return Ok(__ret); }) } -const INPUT_SIZE_557: usize = 2; -const IN_557: usize = 2; -const OUT_557: usize = 1; -fn aiur_fn_557( - inp: [G; IN_557], +const INPUT_SIZE_553: usize = 2; +const IN_553: usize = 2; +const OUT_553: usize = 1; +fn aiur_fn_553( + inp: [G; IN_553], record: &mut QueryRecord, io_buffer: &mut IOBuffer, unconstrained: bool, -) -> Result<[G; OUT_557], ExecError> { +) -> Result<[G; OUT_553], ExecError> { stacker::maybe_grow(64 * 1024, 4 * 1024 * 1024, || { let __v_0: G = inp[0]; let __v_1: G = inp[1]; - let __r_arr: [G; OUT_556] = { let __args: [G; IN_556] = [__v_0, __v_1]; let __cu = unconstrained; if let Some(result) = record.function_queries[556].get_mut(&__args[..]) { if !__cu && *result.multiplicity == G::ZERO { aiur_fn_556(__args, record, io_buffer, false)? } else { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_556] = unsafe { *(result.output.as_ptr() as *const [G; OUT_556]) }; __ret } } else { aiur_fn_556(__args, record, io_buffer, __cu)? } }; + let __r_arr: [G; OUT_552] = { let __args: [G; IN_552] = [__v_0, __v_1]; let __cu = unconstrained; if let Some(result) = record.function_queries[552].get_mut(&__args[..]) { if !__cu && *result.multiplicity == G::ZERO { aiur_fn_552(__args, record, io_buffer, false)? } else { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_552] = unsafe { *(result.output.as_ptr() as *const [G; OUT_552]) }; __ret } } else { aiur_fn_552(__args, record, io_buffer, __cu)? } }; let __v_2: G = __r_arr[0]; let __v_3: G = __r_arr[1]; let __v_4: G = __r_arr[2]; @@ -48393,53 +48109,53 @@ fn aiur_fn_557( let __v_13: G = __r_arr[11]; match __v_2.as_canonical_u64() { 5u64 => { - let __ret: [G; OUT_557] = [__v_7]; - if let Some(result) = record.function_queries[557].get_mut(&inp[..]) { debug_assert_eq!(result.output, &__ret[..]); if !unconstrained { *result.multiplicity += G::ONE; } } else { record.function_queries[557].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained)); }; + let __ret: [G; OUT_553] = [__v_7]; + if let Some(result) = record.function_queries[553].get_mut(&inp[..]) { debug_assert_eq!(result.output, &__ret[..]); if !unconstrained { *result.multiplicity += G::ONE; } } else { record.function_queries[553].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained)); }; return Ok(__ret); }, _ => { let __v_14: G = G::from_u64(0); - let __ret: [G; OUT_557] = [__v_14]; - if let Some(result) = record.function_queries[557].get_mut(&inp[..]) { debug_assert_eq!(result.output, &__ret[..]); if !unconstrained { *result.multiplicity += G::ONE; } } else { record.function_queries[557].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained)); }; + let __ret: [G; OUT_553] = [__v_14]; + if let Some(result) = record.function_queries[553].get_mut(&inp[..]) { debug_assert_eq!(result.output, &__ret[..]); if !unconstrained { *result.multiplicity += G::ONE; } } else { record.function_queries[553].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained)); }; return Ok(__ret); }, } }) } -const INPUT_SIZE_558: usize = 3; -const IN_558: usize = 3; -const OUT_558: usize = 1; -fn aiur_fn_558( - inp: [G; IN_558], +const INPUT_SIZE_554: usize = 3; +const IN_554: usize = 3; +const OUT_554: usize = 1; +fn aiur_fn_554( + inp: [G; IN_554], record: &mut QueryRecord, io_buffer: &mut IOBuffer, unconstrained: bool, -) -> Result<[G; OUT_558], ExecError> { +) -> Result<[G; OUT_554], ExecError> { stacker::maybe_grow(64 * 1024, 4 * 1024 * 1024, || { let __v_0: G = inp[0]; let __v_1: G = inp[1]; let __v_2: G = inp[2]; let __v_3: G = G::from_u64(0); - let __r_arr: [G; OUT_764] = { let __args: [G; IN_764] = [__v_0]; let __cu = unconstrained; if let Some(result) = record.function_queries[764].get_mut(&__args[..]) { if !__cu && *result.multiplicity == G::ZERO { aiur_fn_764(__args, record, io_buffer, false)? } else { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_764] = unsafe { *(result.output.as_ptr() as *const [G; OUT_764]) }; __ret } } else { aiur_fn_764(__args, record, io_buffer, __cu)? } }; + let __r_arr: [G; OUT_760] = { let __args: [G; IN_760] = [__v_0]; let __cu = unconstrained; if let Some(result) = record.function_queries[760].get_mut(&__args[..]) { if !__cu && *result.multiplicity == G::ZERO { aiur_fn_760(__args, record, io_buffer, false)? } else { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_760] = unsafe { *(result.output.as_ptr() as *const [G; OUT_760]) }; __ret } } else { aiur_fn_760(__args, record, io_buffer, __cu)? } }; let __v_4: G = __r_arr[0]; - let __r_arr: [G; OUT_559] = { let __args: [G; IN_559] = [__v_0, __v_1, __v_2, __v_3, __v_4]; let __cu = unconstrained; if let Some(result) = record.function_queries[559].get_mut(&__args[..]) { if !__cu && *result.multiplicity == G::ZERO { aiur_fn_559(__args, record, io_buffer, false)? } else { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_559] = unsafe { *(result.output.as_ptr() as *const [G; OUT_559]) }; __ret } } else { aiur_fn_559(__args, record, io_buffer, __cu)? } }; + let __r_arr: [G; OUT_555] = { let __args: [G; IN_555] = [__v_0, __v_1, __v_2, __v_3, __v_4]; let __cu = unconstrained; if let Some(result) = record.function_queries[555].get_mut(&__args[..]) { if !__cu && *result.multiplicity == G::ZERO { aiur_fn_555(__args, record, io_buffer, false)? } else { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_555] = unsafe { *(result.output.as_ptr() as *const [G; OUT_555]) }; __ret } } else { aiur_fn_555(__args, record, io_buffer, __cu)? } }; let __v_5: G = __r_arr[0]; - let __ret: [G; OUT_558] = [__v_5]; - if let Some(result) = record.function_queries[558].get_mut(&inp[..]) { debug_assert_eq!(result.output, &__ret[..]); if !unconstrained { *result.multiplicity += G::ONE; } } else { record.function_queries[558].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained)); }; + let __ret: [G; OUT_554] = [__v_5]; + if let Some(result) = record.function_queries[554].get_mut(&inp[..]) { debug_assert_eq!(result.output, &__ret[..]); if !unconstrained { *result.multiplicity += G::ONE; } } else { record.function_queries[554].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained)); }; return Ok(__ret); }) } -const INPUT_SIZE_559: usize = 5; -const IN_559: usize = 5; -const OUT_559: usize = 1; -fn aiur_fn_559( - inp: [G; IN_559], +const INPUT_SIZE_555: usize = 5; +const IN_555: usize = 5; +const OUT_555: usize = 1; +fn aiur_fn_555( + inp: [G; IN_555], record: &mut QueryRecord, io_buffer: &mut IOBuffer, unconstrained: bool, -) -> Result<[G; OUT_559], ExecError> { +) -> Result<[G; OUT_555], ExecError> { stacker::maybe_grow(64 * 1024, 4 * 1024 * 1024, || { let __v_0: G = inp[0]; let __v_1: G = inp[1]; @@ -48455,23 +48171,23 @@ fn aiur_fn_559( let __v_8: G = G::from_u64(1); let __v_9: G = G::from_u64(1); let __v_10: G = { let __values: [G; 4] = [__v_8, __v_9, __v_9, __v_9]; let __mq = record.memory_queries.get_mut(&4).ok_or(ExecError::InvalidMemorySize(4))?; if let Some(result) = __mq.get_mut(&__values[..]) { if !unconstrained { *result.multiplicity += G::ONE; } result.output[0] } else { let __ptr = G::from_usize(__mq.len()); __mq.insert(&__values[..], &[__ptr], G::from_bool(!unconstrained)); __ptr } }; - let __ret: [G; OUT_559] = [__v_10]; - if let Some(result) = record.function_queries[559].get_mut(&inp[..]) { debug_assert_eq!(result.output, &__ret[..]); if !unconstrained { *result.multiplicity += G::ONE; } } else { record.function_queries[559].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained)); }; + let __ret: [G; OUT_555] = [__v_10]; + if let Some(result) = record.function_queries[555].get_mut(&inp[..]) { debug_assert_eq!(result.output, &__ret[..]); if !unconstrained { *result.multiplicity += G::ONE; } } else { record.function_queries[555].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained)); }; return Ok(__ret); }, 0u64 => { - let __r_arr: [G; OUT_560] = { let __args: [G; IN_560] = [__v_6, __v_1, __v_2, __v_3, __v_4]; let __cu = unconstrained; if let Some(result) = record.function_queries[560].get_mut(&__args[..]) { if !__cu && *result.multiplicity == G::ZERO { aiur_fn_560(__args, record, io_buffer, false)? } else { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_560] = unsafe { *(result.output.as_ptr() as *const [G; OUT_560]) }; __ret } } else { aiur_fn_560(__args, record, io_buffer, __cu)? } }; + let __r_arr: [G; OUT_556] = { let __args: [G; IN_556] = [__v_6, __v_1, __v_2, __v_3, __v_4]; let __cu = unconstrained; if let Some(result) = record.function_queries[556].get_mut(&__args[..]) { if !__cu && *result.multiplicity == G::ZERO { aiur_fn_556(__args, record, io_buffer, false)? } else { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_556] = unsafe { *(result.output.as_ptr() as *const [G; OUT_556]) }; __ret } } else { aiur_fn_556(__args, record, io_buffer, __cu)? } }; let __v_8: G = __r_arr[0]; let __v_9: G = __r_arr[1]; let __v_10: G = G::from_u64(1); let __v_11: G = (__v_3 + __v_10); let __v_12: G = (__v_4 + __v_9); - let __r_arr: [G; OUT_559] = { let __args: [G; IN_559] = [__v_7, __v_1, __v_2, __v_11, __v_12]; let __cu = unconstrained; if let Some(result) = record.function_queries[559].get_mut(&__args[..]) { if !__cu && *result.multiplicity == G::ZERO { aiur_fn_559(__args, record, io_buffer, false)? } else { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_559] = unsafe { *(result.output.as_ptr() as *const [G; OUT_559]) }; __ret } } else { aiur_fn_559(__args, record, io_buffer, __cu)? } }; + let __r_arr: [G; OUT_555] = { let __args: [G; IN_555] = [__v_7, __v_1, __v_2, __v_11, __v_12]; let __cu = unconstrained; if let Some(result) = record.function_queries[555].get_mut(&__args[..]) { if !__cu && *result.multiplicity == G::ZERO { aiur_fn_555(__args, record, io_buffer, false)? } else { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_555] = unsafe { *(result.output.as_ptr() as *const [G; OUT_555]) }; __ret } } else { aiur_fn_555(__args, record, io_buffer, __cu)? } }; let __v_13: G = __r_arr[0]; - let __r_arr: [G; OUT_759] = { let __args: [G; IN_759] = [__v_8, __v_13]; let __cu = unconstrained; if let Some(result) = record.function_queries[759].get_mut(&__args[..]) { if !__cu && *result.multiplicity == G::ZERO { aiur_fn_759(__args, record, io_buffer, false)? } else { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_759] = unsafe { *(result.output.as_ptr() as *const [G; OUT_759]) }; __ret } } else { aiur_fn_759(__args, record, io_buffer, __cu)? } }; + let __r_arr: [G; OUT_755] = { let __args: [G; IN_755] = [__v_8, __v_13]; let __cu = unconstrained; if let Some(result) = record.function_queries[755].get_mut(&__args[..]) { if !__cu && *result.multiplicity == G::ZERO { aiur_fn_755(__args, record, io_buffer, false)? } else { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_755] = unsafe { *(result.output.as_ptr() as *const [G; OUT_755]) }; __ret } } else { aiur_fn_755(__args, record, io_buffer, __cu)? } }; let __v_14: G = __r_arr[0]; - let __ret: [G; OUT_559] = [__v_14]; - if let Some(result) = record.function_queries[559].get_mut(&inp[..]) { debug_assert_eq!(result.output, &__ret[..]); if !unconstrained { *result.multiplicity += G::ONE; } } else { record.function_queries[559].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained)); }; + let __ret: [G; OUT_555] = [__v_14]; + if let Some(result) = record.function_queries[555].get_mut(&inp[..]) { debug_assert_eq!(result.output, &__ret[..]); if !unconstrained { *result.multiplicity += G::ONE; } } else { record.function_queries[555].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained)); }; return Ok(__ret); }, _ => { @@ -48481,15 +48197,15 @@ fn aiur_fn_559( }) } -const INPUT_SIZE_560: usize = 5; -const IN_560: usize = 5; -const OUT_560: usize = 2; -fn aiur_fn_560( - inp: [G; IN_560], +const INPUT_SIZE_556: usize = 5; +const IN_556: usize = 5; +const OUT_556: usize = 2; +fn aiur_fn_556( + inp: [G; IN_556], record: &mut QueryRecord, io_buffer: &mut IOBuffer, unconstrained: bool, -) -> Result<[G; OUT_560], ExecError> { +) -> Result<[G; OUT_556], ExecError> { stacker::maybe_grow(64 * 1024, 4 * 1024 * 1024, || { let __v_0: G = inp[0]; let __v_1: G = inp[1]; @@ -48506,35 +48222,35 @@ fn aiur_fn_560( let __v_9: G = G::from_u64(1); let __v_10: G = { let __values: [G; 4] = [__v_8, __v_9, __v_9, __v_9]; let __mq = record.memory_queries.get_mut(&4).ok_or(ExecError::InvalidMemorySize(4))?; if let Some(result) = __mq.get_mut(&__values[..]) { if !unconstrained { *result.multiplicity += G::ONE; } result.output[0] } else { let __ptr = G::from_usize(__mq.len()); __mq.insert(&__values[..], &[__ptr], G::from_bool(!unconstrained)); __ptr } }; let __v_11: G = G::from_u64(0); - let __ret: [G; OUT_560] = [__v_10, __v_11]; - if let Some(result) = record.function_queries[560].get_mut(&inp[..]) { debug_assert_eq!(result.output, &__ret[..]); if !unconstrained { *result.multiplicity += G::ONE; } } else { record.function_queries[560].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained)); }; + let __ret: [G; OUT_556] = [__v_10, __v_11]; + if let Some(result) = record.function_queries[556].get_mut(&inp[..]) { debug_assert_eq!(result.output, &__ret[..]); if !unconstrained { *result.multiplicity += G::ONE; } } else { record.function_queries[556].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained)); }; return Ok(__ret); }, 0u64 => { - let __r_arr: [G; OUT_560] = { let __args: [G; IN_560] = [__v_7, __v_1, __v_2, __v_3, __v_4]; let __cu = unconstrained; if let Some(result) = record.function_queries[560].get_mut(&__args[..]) { if !__cu && *result.multiplicity == G::ZERO { aiur_fn_560(__args, record, io_buffer, false)? } else { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_560] = unsafe { *(result.output.as_ptr() as *const [G; OUT_560]) }; __ret } } else { aiur_fn_560(__args, record, io_buffer, __cu)? } }; + let __r_arr: [G; OUT_556] = { let __args: [G; IN_556] = [__v_7, __v_1, __v_2, __v_3, __v_4]; let __cu = unconstrained; if let Some(result) = record.function_queries[556].get_mut(&__args[..]) { if !__cu && *result.multiplicity == G::ZERO { aiur_fn_556(__args, record, io_buffer, false)? } else { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_556] = unsafe { *(result.output.as_ptr() as *const [G; OUT_556]) }; __ret } } else { aiur_fn_556(__args, record, io_buffer, __cu)? } }; let __v_8: G = __r_arr[0]; let __v_9: G = __r_arr[1]; - let __r_arr: [G; OUT_557] = { let __args: [G; IN_557] = [__v_1, __v_6]; let __cu = unconstrained; if let Some(result) = record.function_queries[557].get_mut(&__args[..]) { if !__cu && *result.multiplicity == G::ZERO { aiur_fn_557(__args, record, io_buffer, false)? } else { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_557] = unsafe { *(result.output.as_ptr() as *const [G; OUT_557]) }; __ret } } else { aiur_fn_557(__args, record, io_buffer, __cu)? } }; + let __r_arr: [G; OUT_553] = { let __args: [G; IN_553] = [__v_1, __v_6]; let __cu = unconstrained; if let Some(result) = record.function_queries[553].get_mut(&__args[..]) { if !__cu && *result.multiplicity == G::ZERO { aiur_fn_553(__args, record, io_buffer, false)? } else { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_553] = unsafe { *(result.output.as_ptr() as *const [G; OUT_553]) }; __ret } } else { aiur_fn_553(__args, record, io_buffer, __cu)? } }; let __v_10: G = __r_arr[0]; let __v_11: G = G::from_u64(0); - let __r_arr: [G; OUT_561] = { let __args: [G; IN_561] = [__v_2, __v_6, __v_10, __v_4, __v_11]; let __cu = unconstrained; if let Some(result) = record.function_queries[561].get_mut(&__args[..]) { if !__cu && *result.multiplicity == G::ZERO { aiur_fn_561(__args, record, io_buffer, false)? } else { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_561] = unsafe { *(result.output.as_ptr() as *const [G; OUT_561]) }; __ret } } else { aiur_fn_561(__args, record, io_buffer, __cu)? } }; + let __r_arr: [G; OUT_557] = { let __args: [G; IN_557] = [__v_2, __v_6, __v_10, __v_4, __v_11]; let __cu = unconstrained; if let Some(result) = record.function_queries[557].get_mut(&__args[..]) { if !__cu && *result.multiplicity == G::ZERO { aiur_fn_557(__args, record, io_buffer, false)? } else { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_557] = unsafe { *(result.output.as_ptr() as *const [G; OUT_557]) }; __ret } } else { aiur_fn_557(__args, record, io_buffer, __cu)? } }; let __v_12: G = __r_arr[0]; let __v_13: G = G::from_u64(0); - let __r_arr: [G; OUT_766] = { let __args: [G; IN_766] = [__v_1, __v_6]; let __cu = unconstrained; if let Some(result) = record.function_queries[766].get_mut(&__args[..]) { if !__cu && *result.multiplicity == G::ZERO { aiur_fn_766(__args, record, io_buffer, false)? } else { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_766] = unsafe { *(result.output.as_ptr() as *const [G; OUT_766]) }; __ret } } else { aiur_fn_766(__args, record, io_buffer, __cu)? } }; + let __r_arr: [G; OUT_762] = { let __args: [G; IN_762] = [__v_1, __v_6]; let __cu = unconstrained; if let Some(result) = record.function_queries[762].get_mut(&__args[..]) { if !__cu && *result.multiplicity == G::ZERO { aiur_fn_762(__args, record, io_buffer, false)? } else { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_762] = unsafe { *(result.output.as_ptr() as *const [G; OUT_762]) }; __ret } } else { aiur_fn_762(__args, record, io_buffer, __cu)? } }; let __v_14: G = __r_arr[0]; - let __r_arr: [G; OUT_759] = { let __args: [G; IN_759] = [__v_12, __v_8]; let __cu = unconstrained; if let Some(result) = record.function_queries[759].get_mut(&__args[..]) { if !__cu && *result.multiplicity == G::ZERO { aiur_fn_759(__args, record, io_buffer, false)? } else { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_759] = unsafe { *(result.output.as_ptr() as *const [G; OUT_759]) }; __ret } } else { aiur_fn_759(__args, record, io_buffer, __cu)? } }; + let __r_arr: [G; OUT_755] = { let __args: [G; IN_755] = [__v_12, __v_8]; let __cu = unconstrained; if let Some(result) = record.function_queries[755].get_mut(&__args[..]) { if !__cu && *result.multiplicity == G::ZERO { aiur_fn_755(__args, record, io_buffer, false)? } else { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_755] = unsafe { *(result.output.as_ptr() as *const [G; OUT_755]) }; __ret } } else { aiur_fn_755(__args, record, io_buffer, __cu)? } }; let __v_15: G = __r_arr[0]; let __v_16: G = { let __values: [G; 4] = [__v_13, __v_14, __v_3, __v_15]; let __mq = record.memory_queries.get_mut(&4).ok_or(ExecError::InvalidMemorySize(4))?; if let Some(result) = __mq.get_mut(&__values[..]) { if !unconstrained { *result.multiplicity += G::ONE; } result.output[0] } else { let __ptr = G::from_usize(__mq.len()); __mq.insert(&__values[..], &[__ptr], G::from_bool(!unconstrained)); __ptr } }; let __v_17: G = { let __a_val = __v_9.as_canonical_u64(); let __b_val = __v_10.as_canonical_u64(); let __a_u32 = u32::try_from(__a_val).ok().ok_or(ExecError::U32OutOfRange(__a_val))?; let __b_u32 = u32::try_from(__b_val).ok().ok_or(ExecError::U32OutOfRange(__b_val))?; let __result = G::from_bool(__a_u32 < __b_u32); if !unconstrained { let __x_bytes = __a_u32.to_le_bytes(); let __z_bytes = __b_u32.to_le_bytes(); let __c_u32 = __b_u32.wrapping_sub(__a_u32).wrapping_sub(1); let __y_bytes = __c_u32.to_le_bytes(); record.bytes2_queries.bump_range_check(&G::from_u8(__x_bytes[0]), &G::from_u8(__x_bytes[1])); record.bytes2_queries.bump_range_check(&G::from_u8(__x_bytes[2]), &G::from_u8(__x_bytes[3])); record.bytes2_queries.bump_range_check(&G::from_u8(__y_bytes[0]), &G::from_u8(__y_bytes[1])); record.bytes2_queries.bump_range_check(&G::from_u8(__y_bytes[2]), &G::from_u8(__y_bytes[3])); record.bytes2_queries.bump_range_check(&G::from_u8(__z_bytes[0]), &G::from_u8(__z_bytes[1])); record.bytes2_queries.bump_range_check(&G::from_u8(__z_bytes[2]), &G::from_u8(__z_bytes[3])); } __result }; match __v_17.as_canonical_u64() { 1u64 => { - let __ret: [G; OUT_560] = [__v_16, __v_10]; - if let Some(result) = record.function_queries[560].get_mut(&inp[..]) { debug_assert_eq!(result.output, &__ret[..]); if !unconstrained { *result.multiplicity += G::ONE; } } else { record.function_queries[560].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained)); }; + let __ret: [G; OUT_556] = [__v_16, __v_10]; + if let Some(result) = record.function_queries[556].get_mut(&inp[..]) { debug_assert_eq!(result.output, &__ret[..]); if !unconstrained { *result.multiplicity += G::ONE; } } else { record.function_queries[556].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained)); }; return Ok(__ret); }, _ => { - let __ret: [G; OUT_560] = [__v_16, __v_9]; - if let Some(result) = record.function_queries[560].get_mut(&inp[..]) { debug_assert_eq!(result.output, &__ret[..]); if !unconstrained { *result.multiplicity += G::ONE; } } else { record.function_queries[560].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained)); }; + let __ret: [G; OUT_556] = [__v_16, __v_9]; + if let Some(result) = record.function_queries[556].get_mut(&inp[..]) { debug_assert_eq!(result.output, &__ret[..]); if !unconstrained { *result.multiplicity += G::ONE; } } else { record.function_queries[556].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained)); }; return Ok(__ret); }, } @@ -48546,15 +48262,15 @@ fn aiur_fn_560( }) } -const INPUT_SIZE_561: usize = 5; -const IN_561: usize = 5; -const OUT_561: usize = 1; -fn aiur_fn_561( - inp: [G; IN_561], +const INPUT_SIZE_557: usize = 5; +const IN_557: usize = 5; +const OUT_557: usize = 1; +fn aiur_fn_557( + inp: [G; IN_557], record: &mut QueryRecord, io_buffer: &mut IOBuffer, unconstrained: bool, -) -> Result<[G; OUT_561], ExecError> { +) -> Result<[G; OUT_557], ExecError> { stacker::maybe_grow(64 * 1024, 4 * 1024 * 1024, || { let __v_0: G = inp[0]; let __v_1: G = inp[1]; @@ -48567,37 +48283,37 @@ fn aiur_fn_561( let __v_6: G = G::from_u64(1); let __v_7: G = G::from_u64(1); let __v_8: G = { let __values: [G; 4] = [__v_6, __v_7, __v_7, __v_7]; let __mq = record.memory_queries.get_mut(&4).ok_or(ExecError::InvalidMemorySize(4))?; if let Some(result) = __mq.get_mut(&__values[..]) { if !unconstrained { *result.multiplicity += G::ONE; } result.output[0] } else { let __ptr = G::from_usize(__mq.len()); __mq.insert(&__values[..], &[__ptr], G::from_bool(!unconstrained)); __ptr } }; - let __ret: [G; OUT_561] = [__v_8]; - if let Some(result) = record.function_queries[561].get_mut(&inp[..]) { debug_assert_eq!(result.output, &__ret[..]); if !unconstrained { *result.multiplicity += G::ONE; } } else { record.function_queries[561].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained)); }; + let __ret: [G; OUT_557] = [__v_8]; + if let Some(result) = record.function_queries[557].get_mut(&inp[..]) { debug_assert_eq!(result.output, &__ret[..]); if !unconstrained { *result.multiplicity += G::ONE; } } else { record.function_queries[557].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained)); }; return Ok(__ret); }, _ => { let __v_6: G = G::from_u64(0); - let __r_arr: [G; OUT_555] = { let __args: [G; IN_555] = [__v_0, __v_1, __v_4]; let __cu = unconstrained; if let Some(result) = record.function_queries[555].get_mut(&__args[..]) { if !__cu && *result.multiplicity == G::ZERO { aiur_fn_555(__args, record, io_buffer, false)? } else { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_555] = unsafe { *(result.output.as_ptr() as *const [G; OUT_555]) }; __ret } } else { aiur_fn_555(__args, record, io_buffer, __cu)? } }; + let __r_arr: [G; OUT_551] = { let __args: [G; IN_551] = [__v_0, __v_1, __v_4]; let __cu = unconstrained; if let Some(result) = record.function_queries[551].get_mut(&__args[..]) { if !__cu && *result.multiplicity == G::ZERO { aiur_fn_551(__args, record, io_buffer, false)? } else { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_551] = unsafe { *(result.output.as_ptr() as *const [G; OUT_551]) }; __ret } } else { aiur_fn_551(__args, record, io_buffer, __cu)? } }; let __v_7: G = __r_arr[0]; let __v_8: G = (__v_3 + __v_4); let __v_9: G = G::from_u64(1); let __v_10: G = (__v_4 + __v_9); - let __r_arr: [G; OUT_561] = { let __args: [G; IN_561] = [__v_0, __v_1, __v_2, __v_3, __v_10]; let __cu = unconstrained; if let Some(result) = record.function_queries[561].get_mut(&__args[..]) { if !__cu && *result.multiplicity == G::ZERO { aiur_fn_561(__args, record, io_buffer, false)? } else { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_561] = unsafe { *(result.output.as_ptr() as *const [G; OUT_561]) }; __ret } } else { aiur_fn_561(__args, record, io_buffer, __cu)? } }; + let __r_arr: [G; OUT_557] = { let __args: [G; IN_557] = [__v_0, __v_1, __v_2, __v_3, __v_10]; let __cu = unconstrained; if let Some(result) = record.function_queries[557].get_mut(&__args[..]) { if !__cu && *result.multiplicity == G::ZERO { aiur_fn_557(__args, record, io_buffer, false)? } else { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_557] = unsafe { *(result.output.as_ptr() as *const [G; OUT_557]) }; __ret } } else { aiur_fn_557(__args, record, io_buffer, __cu)? } }; let __v_11: G = __r_arr[0]; let __v_12: G = { let __values: [G; 4] = [__v_6, __v_7, __v_8, __v_11]; let __mq = record.memory_queries.get_mut(&4).ok_or(ExecError::InvalidMemorySize(4))?; if let Some(result) = __mq.get_mut(&__values[..]) { if !unconstrained { *result.multiplicity += G::ONE; } result.output[0] } else { let __ptr = G::from_usize(__mq.len()); __mq.insert(&__values[..], &[__ptr], G::from_bool(!unconstrained)); __ptr } }; - let __ret: [G; OUT_561] = [__v_12]; - if let Some(result) = record.function_queries[561].get_mut(&inp[..]) { debug_assert_eq!(result.output, &__ret[..]); if !unconstrained { *result.multiplicity += G::ONE; } } else { record.function_queries[561].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained)); }; + let __ret: [G; OUT_557] = [__v_12]; + if let Some(result) = record.function_queries[557].get_mut(&inp[..]) { debug_assert_eq!(result.output, &__ret[..]); if !unconstrained { *result.multiplicity += G::ONE; } } else { record.function_queries[557].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained)); }; return Ok(__ret); }, } }) } -const INPUT_SIZE_562: usize = 3; -const IN_562: usize = 3; -const OUT_562: usize = 1; -fn aiur_fn_562( - inp: [G; IN_562], +const INPUT_SIZE_558: usize = 3; +const IN_558: usize = 3; +const OUT_558: usize = 1; +fn aiur_fn_558( + inp: [G; IN_558], record: &mut QueryRecord, io_buffer: &mut IOBuffer, unconstrained: bool, -) -> Result<[G; OUT_562], ExecError> { +) -> Result<[G; OUT_558], ExecError> { stacker::maybe_grow(64 * 1024, 4 * 1024 * 1024, || { let __v_0: G = inp[0]; let __v_1: G = inp[1]; @@ -48608,26 +48324,26 @@ fn aiur_fn_562( let __v_6: G = { let __values: [G; 3] = [__v_4, __v_5, __v_5]; let __mq = record.memory_queries.get_mut(&3).ok_or(ExecError::InvalidMemorySize(3))?; if let Some(result) = __mq.get_mut(&__values[..]) { if !unconstrained { *result.multiplicity += G::ONE; } result.output[0] } else { let __ptr = G::from_usize(__mq.len()); __mq.insert(&__values[..], &[__ptr], G::from_bool(!unconstrained)); __ptr } }; let __v_7: G = { let __values: [G; 3] = [__v_3, __v_0, __v_6]; let __mq = record.memory_queries.get_mut(&3).ok_or(ExecError::InvalidMemorySize(3))?; if let Some(result) = __mq.get_mut(&__values[..]) { if !unconstrained { *result.multiplicity += G::ONE; } result.output[0] } else { let __ptr = G::from_usize(__mq.len()); __mq.insert(&__values[..], &[__ptr], G::from_bool(!unconstrained)); __ptr } }; let __v_8: G = G::from_u64(1); - let __r_arr: [G; OUT_764] = { let __args: [G; IN_764] = [__v_0]; let __cu = unconstrained; if let Some(result) = record.function_queries[764].get_mut(&__args[..]) { if !__cu && *result.multiplicity == G::ZERO { aiur_fn_764(__args, record, io_buffer, false)? } else { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_764] = unsafe { *(result.output.as_ptr() as *const [G; OUT_764]) }; __ret } } else { aiur_fn_764(__args, record, io_buffer, __cu)? } }; + let __r_arr: [G; OUT_760] = { let __args: [G; IN_760] = [__v_0]; let __cu = unconstrained; if let Some(result) = record.function_queries[760].get_mut(&__args[..]) { if !__cu && *result.multiplicity == G::ZERO { aiur_fn_760(__args, record, io_buffer, false)? } else { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_760] = unsafe { *(result.output.as_ptr() as *const [G; OUT_760]) }; __ret } } else { aiur_fn_760(__args, record, io_buffer, __cu)? } }; let __v_9: G = __r_arr[0]; let __v_10: G = (__v_8 + __v_9); - let __r_arr: [G; OUT_563] = { let __args: [G; IN_563] = [__v_7, __v_1, __v_2, __v_10]; let __cu = unconstrained; if let Some(result) = record.function_queries[563].get_mut(&__args[..]) { if !__cu && *result.multiplicity == G::ZERO { aiur_fn_563(__args, record, io_buffer, false)? } else { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_563] = unsafe { *(result.output.as_ptr() as *const [G; OUT_563]) }; __ret } } else { aiur_fn_563(__args, record, io_buffer, __cu)? } }; + let __r_arr: [G; OUT_559] = { let __args: [G; IN_559] = [__v_7, __v_1, __v_2, __v_10]; let __cu = unconstrained; if let Some(result) = record.function_queries[559].get_mut(&__args[..]) { if !__cu && *result.multiplicity == G::ZERO { aiur_fn_559(__args, record, io_buffer, false)? } else { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_559] = unsafe { *(result.output.as_ptr() as *const [G; OUT_559]) }; __ret } } else { aiur_fn_559(__args, record, io_buffer, __cu)? } }; let __v_11: G = __r_arr[0]; - let __ret: [G; OUT_562] = [__v_11]; - if let Some(result) = record.function_queries[562].get_mut(&inp[..]) { debug_assert_eq!(result.output, &__ret[..]); if !unconstrained { *result.multiplicity += G::ONE; } } else { record.function_queries[562].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained)); }; + let __ret: [G; OUT_558] = [__v_11]; + if let Some(result) = record.function_queries[558].get_mut(&inp[..]) { debug_assert_eq!(result.output, &__ret[..]); if !unconstrained { *result.multiplicity += G::ONE; } } else { record.function_queries[558].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained)); }; return Ok(__ret); }) } -const INPUT_SIZE_563: usize = 4; -const IN_563: usize = 4; -const OUT_563: usize = 1; -fn aiur_fn_563( - inp: [G; IN_563], +const INPUT_SIZE_559: usize = 4; +const IN_559: usize = 4; +const OUT_559: usize = 1; +fn aiur_fn_559( + inp: [G; IN_559], record: &mut QueryRecord, io_buffer: &mut IOBuffer, unconstrained: bool, -) -> Result<[G; OUT_563], ExecError> { +) -> Result<[G; OUT_559], ExecError> { stacker::maybe_grow(64 * 1024, 4 * 1024 * 1024, || { let __v_0: G = inp[0]; let __v_1: G = inp[1]; @@ -48635,33 +48351,33 @@ fn aiur_fn_563( let __v_3: G = inp[3]; match __v_3.as_canonical_u64() { 0u64 => { - let __ret: [G; OUT_563] = [__v_0]; - if let Some(result) = record.function_queries[563].get_mut(&inp[..]) { debug_assert_eq!(result.output, &__ret[..]); if !unconstrained { *result.multiplicity += G::ONE; } } else { record.function_queries[563].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained)); }; + let __ret: [G; OUT_559] = [__v_0]; + if let Some(result) = record.function_queries[559].get_mut(&inp[..]) { debug_assert_eq!(result.output, &__ret[..]); if !unconstrained { *result.multiplicity += G::ONE; } } else { record.function_queries[559].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained)); }; return Ok(__ret); }, _ => { let __v_4: G = G::from_u64(0); - let __r_arr: [G; OUT_764] = { let __args: [G; IN_764] = [__v_0]; let __cu = unconstrained; if let Some(result) = record.function_queries[764].get_mut(&__args[..]) { if !__cu && *result.multiplicity == G::ZERO { aiur_fn_764(__args, record, io_buffer, false)? } else { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_764] = unsafe { *(result.output.as_ptr() as *const [G; OUT_764]) }; __ret } } else { aiur_fn_764(__args, record, io_buffer, __cu)? } }; + let __r_arr: [G; OUT_760] = { let __args: [G; IN_760] = [__v_0]; let __cu = unconstrained; if let Some(result) = record.function_queries[760].get_mut(&__args[..]) { if !__cu && *result.multiplicity == G::ZERO { aiur_fn_760(__args, record, io_buffer, false)? } else { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_760] = unsafe { *(result.output.as_ptr() as *const [G; OUT_760]) }; __ret } } else { aiur_fn_760(__args, record, io_buffer, __cu)? } }; let __v_5: G = __r_arr[0]; - let __r_arr: [G; OUT_559] = { let __args: [G; IN_559] = [__v_0, __v_1, __v_2, __v_4, __v_5]; let __cu = unconstrained; if let Some(result) = record.function_queries[559].get_mut(&__args[..]) { if !__cu && *result.multiplicity == G::ZERO { aiur_fn_559(__args, record, io_buffer, false)? } else { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_559] = unsafe { *(result.output.as_ptr() as *const [G; OUT_559]) }; __ret } } else { aiur_fn_559(__args, record, io_buffer, __cu)? } }; + let __r_arr: [G; OUT_555] = { let __args: [G; IN_555] = [__v_0, __v_1, __v_2, __v_4, __v_5]; let __cu = unconstrained; if let Some(result) = record.function_queries[555].get_mut(&__args[..]) { if !__cu && *result.multiplicity == G::ZERO { aiur_fn_555(__args, record, io_buffer, false)? } else { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_555] = unsafe { *(result.output.as_ptr() as *const [G; OUT_555]) }; __ret } } else { aiur_fn_555(__args, record, io_buffer, __cu)? } }; let __v_6: G = __r_arr[0]; - let __r_arr: [G; OUT_564] = { let __args: [G; IN_564] = [__v_0, __v_6, __v_1]; let __cu = unconstrained; if let Some(result) = record.function_queries[564].get_mut(&__args[..]) { if !__cu && *result.multiplicity == G::ZERO { aiur_fn_564(__args, record, io_buffer, false)? } else { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_564] = unsafe { *(result.output.as_ptr() as *const [G; OUT_564]) }; __ret } } else { aiur_fn_564(__args, record, io_buffer, __cu)? } }; + let __r_arr: [G; OUT_560] = { let __args: [G; IN_560] = [__v_0, __v_6, __v_1]; let __cu = unconstrained; if let Some(result) = record.function_queries[560].get_mut(&__args[..]) { if !__cu && *result.multiplicity == G::ZERO { aiur_fn_560(__args, record, io_buffer, false)? } else { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_560] = unsafe { *(result.output.as_ptr() as *const [G; OUT_560]) }; __ret } } else { aiur_fn_560(__args, record, io_buffer, __cu)? } }; let __v_7: G = __r_arr[0]; - let __r_arr: [G; OUT_570] = { let __args: [G; IN_570] = [__v_0, __v_7]; let __cu = unconstrained; if let Some(result) = record.function_queries[570].get_mut(&__args[..]) { if !__cu && *result.multiplicity == G::ZERO { aiur_fn_570(__args, record, io_buffer, false)? } else { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_570] = unsafe { *(result.output.as_ptr() as *const [G; OUT_570]) }; __ret } } else { aiur_fn_570(__args, record, io_buffer, __cu)? } }; + let __r_arr: [G; OUT_566] = { let __args: [G; IN_566] = [__v_0, __v_7]; let __cu = unconstrained; if let Some(result) = record.function_queries[566].get_mut(&__args[..]) { if !__cu && *result.multiplicity == G::ZERO { aiur_fn_566(__args, record, io_buffer, false)? } else { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_566] = unsafe { *(result.output.as_ptr() as *const [G; OUT_566]) }; __ret } } else { aiur_fn_566(__args, record, io_buffer, __cu)? } }; let __v_8: G = __r_arr[0]; match __v_8.as_canonical_u64() { 1u64 => { - let __ret: [G; OUT_563] = [__v_0]; - if let Some(result) = record.function_queries[563].get_mut(&inp[..]) { debug_assert_eq!(result.output, &__ret[..]); if !unconstrained { *result.multiplicity += G::ONE; } } else { record.function_queries[563].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained)); }; + let __ret: [G; OUT_559] = [__v_0]; + if let Some(result) = record.function_queries[559].get_mut(&inp[..]) { debug_assert_eq!(result.output, &__ret[..]); if !unconstrained { *result.multiplicity += G::ONE; } } else { record.function_queries[559].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained)); }; return Ok(__ret); }, _ => { let __v_9: G = G::from_u64(1); let __v_10: G = (__v_3 - __v_9); - let __r_arr: [G; OUT_563] = { let __args: [G; IN_563] = [__v_7, __v_1, __v_2, __v_10]; let __cu = unconstrained; if let Some(result) = record.function_queries[563].get_mut(&__args[..]) { if !__cu && *result.multiplicity == G::ZERO { aiur_fn_563(__args, record, io_buffer, false)? } else { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_563] = unsafe { *(result.output.as_ptr() as *const [G; OUT_563]) }; __ret } } else { aiur_fn_563(__args, record, io_buffer, __cu)? } }; + let __r_arr: [G; OUT_559] = { let __args: [G; IN_559] = [__v_7, __v_1, __v_2, __v_10]; let __cu = unconstrained; if let Some(result) = record.function_queries[559].get_mut(&__args[..]) { if !__cu && *result.multiplicity == G::ZERO { aiur_fn_559(__args, record, io_buffer, false)? } else { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_559] = unsafe { *(result.output.as_ptr() as *const [G; OUT_559]) }; __ret } } else { aiur_fn_559(__args, record, io_buffer, __cu)? } }; let __v_11: G = __r_arr[0]; - let __ret: [G; OUT_563] = [__v_11]; - if let Some(result) = record.function_queries[563].get_mut(&inp[..]) { debug_assert_eq!(result.output, &__ret[..]); if !unconstrained { *result.multiplicity += G::ONE; } } else { record.function_queries[563].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained)); }; + let __ret: [G; OUT_559] = [__v_11]; + if let Some(result) = record.function_queries[559].get_mut(&inp[..]) { debug_assert_eq!(result.output, &__ret[..]); if !unconstrained { *result.multiplicity += G::ONE; } } else { record.function_queries[559].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained)); }; return Ok(__ret); }, } @@ -48670,15 +48386,15 @@ fn aiur_fn_563( }) } -const INPUT_SIZE_564: usize = 3; -const IN_564: usize = 3; -const OUT_564: usize = 1; -fn aiur_fn_564( - inp: [G; IN_564], +const INPUT_SIZE_560: usize = 3; +const IN_560: usize = 3; +const OUT_560: usize = 1; +fn aiur_fn_560( + inp: [G; IN_560], record: &mut QueryRecord, io_buffer: &mut IOBuffer, unconstrained: bool, -) -> Result<[G; OUT_564], ExecError> { +) -> Result<[G; OUT_560], ExecError> { stacker::maybe_grow(64 * 1024, 4 * 1024 * 1024, || { let __v_0: G = inp[0]; let __v_1: G = inp[1]; @@ -48692,19 +48408,19 @@ fn aiur_fn_564( let __v_6: G = G::from_u64(1); let __v_7: G = G::from_u64(1); let __v_8: G = { let __values: [G; 3] = [__v_6, __v_7, __v_7]; let __mq = record.memory_queries.get_mut(&3).ok_or(ExecError::InvalidMemorySize(3))?; if let Some(result) = __mq.get_mut(&__values[..]) { if !unconstrained { *result.multiplicity += G::ONE; } result.output[0] } else { let __ptr = G::from_usize(__mq.len()); __mq.insert(&__values[..], &[__ptr], G::from_bool(!unconstrained)); __ptr } }; - let __ret: [G; OUT_564] = [__v_8]; - if let Some(result) = record.function_queries[564].get_mut(&inp[..]) { debug_assert_eq!(result.output, &__ret[..]); if !unconstrained { *result.multiplicity += G::ONE; } } else { record.function_queries[564].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained)); }; + let __ret: [G; OUT_560] = [__v_8]; + if let Some(result) = record.function_queries[560].get_mut(&inp[..]) { debug_assert_eq!(result.output, &__ret[..]); if !unconstrained { *result.multiplicity += G::ONE; } } else { record.function_queries[560].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained)); }; return Ok(__ret); }, 0u64 => { - let __r_arr: [G; OUT_565] = { let __args: [G; IN_565] = [__v_4, __v_1, __v_2]; let __cu = unconstrained; if let Some(result) = record.function_queries[565].get_mut(&__args[..]) { if !__cu && *result.multiplicity == G::ZERO { aiur_fn_565(__args, record, io_buffer, false)? } else { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_565] = unsafe { *(result.output.as_ptr() as *const [G; OUT_565]) }; __ret } } else { aiur_fn_565(__args, record, io_buffer, __cu)? } }; + let __r_arr: [G; OUT_561] = { let __args: [G; IN_561] = [__v_4, __v_1, __v_2]; let __cu = unconstrained; if let Some(result) = record.function_queries[561].get_mut(&__args[..]) { if !__cu && *result.multiplicity == G::ZERO { aiur_fn_561(__args, record, io_buffer, false)? } else { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_561] = unsafe { *(result.output.as_ptr() as *const [G; OUT_561]) }; __ret } } else { aiur_fn_561(__args, record, io_buffer, __cu)? } }; let __v_6: G = __r_arr[0]; - let __r_arr: [G; OUT_564] = { let __args: [G; IN_564] = [__v_5, __v_1, __v_2]; let __cu = unconstrained; if let Some(result) = record.function_queries[564].get_mut(&__args[..]) { if !__cu && *result.multiplicity == G::ZERO { aiur_fn_564(__args, record, io_buffer, false)? } else { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_564] = unsafe { *(result.output.as_ptr() as *const [G; OUT_564]) }; __ret } } else { aiur_fn_564(__args, record, io_buffer, __cu)? } }; + let __r_arr: [G; OUT_560] = { let __args: [G; IN_560] = [__v_5, __v_1, __v_2]; let __cu = unconstrained; if let Some(result) = record.function_queries[560].get_mut(&__args[..]) { if !__cu && *result.multiplicity == G::ZERO { aiur_fn_560(__args, record, io_buffer, false)? } else { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_560] = unsafe { *(result.output.as_ptr() as *const [G; OUT_560]) }; __ret } } else { aiur_fn_560(__args, record, io_buffer, __cu)? } }; let __v_7: G = __r_arr[0]; - let __r_arr: [G; OUT_763] = { let __args: [G; IN_763] = [__v_6, __v_7]; let __cu = unconstrained; if let Some(result) = record.function_queries[763].get_mut(&__args[..]) { if !__cu && *result.multiplicity == G::ZERO { aiur_fn_763(__args, record, io_buffer, false)? } else { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_763] = unsafe { *(result.output.as_ptr() as *const [G; OUT_763]) }; __ret } } else { aiur_fn_763(__args, record, io_buffer, __cu)? } }; + let __r_arr: [G; OUT_759] = { let __args: [G; IN_759] = [__v_6, __v_7]; let __cu = unconstrained; if let Some(result) = record.function_queries[759].get_mut(&__args[..]) { if !__cu && *result.multiplicity == G::ZERO { aiur_fn_759(__args, record, io_buffer, false)? } else { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_759] = unsafe { *(result.output.as_ptr() as *const [G; OUT_759]) }; __ret } } else { aiur_fn_759(__args, record, io_buffer, __cu)? } }; let __v_8: G = __r_arr[0]; - let __ret: [G; OUT_564] = [__v_8]; - if let Some(result) = record.function_queries[564].get_mut(&inp[..]) { debug_assert_eq!(result.output, &__ret[..]); if !unconstrained { *result.multiplicity += G::ONE; } } else { record.function_queries[564].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained)); }; + let __ret: [G; OUT_560] = [__v_8]; + if let Some(result) = record.function_queries[560].get_mut(&inp[..]) { debug_assert_eq!(result.output, &__ret[..]); if !unconstrained { *result.multiplicity += G::ONE; } } else { record.function_queries[560].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained)); }; return Ok(__ret); }, _ => { @@ -48714,28 +48430,28 @@ fn aiur_fn_564( }) } -const INPUT_SIZE_565: usize = 3; -const IN_565: usize = 3; -const OUT_565: usize = 1; -fn aiur_fn_565( - inp: [G; IN_565], +const INPUT_SIZE_561: usize = 3; +const IN_561: usize = 3; +const OUT_561: usize = 1; +fn aiur_fn_561( + inp: [G; IN_561], record: &mut QueryRecord, io_buffer: &mut IOBuffer, unconstrained: bool, -) -> Result<[G; OUT_565], ExecError> { +) -> Result<[G; OUT_561], ExecError> { stacker::maybe_grow(64 * 1024, 4 * 1024 * 1024, || { let __v_0: G = inp[0]; let __v_1: G = inp[1]; let __v_2: G = inp[2]; - let __r_arr: [G; OUT_764] = { let __args: [G; IN_764] = [__v_0]; let __cu = unconstrained; if let Some(result) = record.function_queries[764].get_mut(&__args[..]) { if !__cu && *result.multiplicity == G::ZERO { aiur_fn_764(__args, record, io_buffer, false)? } else { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_764] = unsafe { *(result.output.as_ptr() as *const [G; OUT_764]) }; __ret } } else { aiur_fn_764(__args, record, io_buffer, __cu)? } }; + let __r_arr: [G; OUT_760] = { let __args: [G; IN_760] = [__v_0]; let __cu = unconstrained; if let Some(result) = record.function_queries[760].get_mut(&__args[..]) { if !__cu && *result.multiplicity == G::ZERO { aiur_fn_760(__args, record, io_buffer, false)? } else { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_760] = unsafe { *(result.output.as_ptr() as *const [G; OUT_760]) }; __ret } } else { aiur_fn_760(__args, record, io_buffer, __cu)? } }; let __v_3: G = __r_arr[0]; match __v_3.as_canonical_u64() { 0u64 => { let __v_4: G = G::from_u64(1); let __v_5: G = G::from_u64(1); let __v_6: G = { let __values: [G; 3] = [__v_4, __v_5, __v_5]; let __mq = record.memory_queries.get_mut(&3).ok_or(ExecError::InvalidMemorySize(3))?; if let Some(result) = __mq.get_mut(&__values[..]) { if !unconstrained { *result.multiplicity += G::ONE; } result.output[0] } else { let __ptr = G::from_usize(__mq.len()); __mq.insert(&__values[..], &[__ptr], G::from_bool(!unconstrained)); __ptr } }; - let __ret: [G; OUT_565] = [__v_6]; - if let Some(result) = record.function_queries[565].get_mut(&inp[..]) { debug_assert_eq!(result.output, &__ret[..]); if !unconstrained { *result.multiplicity += G::ONE; } } else { record.function_queries[565].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained)); }; + let __ret: [G; OUT_561] = [__v_6]; + if let Some(result) = record.function_queries[561].get_mut(&inp[..]) { debug_assert_eq!(result.output, &__ret[..]); if !unconstrained { *result.multiplicity += G::ONE; } } else { record.function_queries[561].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained)); }; return Ok(__ret); }, 1u64 => { @@ -48744,32 +48460,32 @@ fn aiur_fn_565( let __v_6: G = G::from_u64(1); let __v_7: G = { let __values: [G; 3] = [__v_5, __v_6, __v_6]; let __mq = record.memory_queries.get_mut(&3).ok_or(ExecError::InvalidMemorySize(3))?; if let Some(result) = __mq.get_mut(&__values[..]) { if !unconstrained { *result.multiplicity += G::ONE; } result.output[0] } else { let __ptr = G::from_usize(__mq.len()); __mq.insert(&__values[..], &[__ptr], G::from_bool(!unconstrained)); __ptr } }; let __v_8: G = { let __values: [G; 3] = [__v_4, __v_0, __v_7]; let __mq = record.memory_queries.get_mut(&3).ok_or(ExecError::InvalidMemorySize(3))?; if let Some(result) = __mq.get_mut(&__values[..]) { if !unconstrained { *result.multiplicity += G::ONE; } result.output[0] } else { let __ptr = G::from_usize(__mq.len()); __mq.insert(&__values[..], &[__ptr], G::from_bool(!unconstrained)); __ptr } }; - let __ret: [G; OUT_565] = [__v_8]; - if let Some(result) = record.function_queries[565].get_mut(&inp[..]) { debug_assert_eq!(result.output, &__ret[..]); if !unconstrained { *result.multiplicity += G::ONE; } } else { record.function_queries[565].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained)); }; + let __ret: [G; OUT_561] = [__v_8]; + if let Some(result) = record.function_queries[561].get_mut(&inp[..]) { debug_assert_eq!(result.output, &__ret[..]); if !unconstrained { *result.multiplicity += G::ONE; } } else { record.function_queries[561].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained)); }; return Ok(__ret); }, _ => { - let __r_arr: [G; OUT_566] = { let __args: [G; IN_566] = [__v_0, __v_1, __v_2]; let __cu = unconstrained; if let Some(result) = record.function_queries[566].get_mut(&__args[..]) { if !__cu && *result.multiplicity == G::ZERO { aiur_fn_566(__args, record, io_buffer, false)? } else { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_566] = unsafe { *(result.output.as_ptr() as *const [G; OUT_566]) }; __ret } } else { aiur_fn_566(__args, record, io_buffer, __cu)? } }; + let __r_arr: [G; OUT_562] = { let __args: [G; IN_562] = [__v_0, __v_1, __v_2]; let __cu = unconstrained; if let Some(result) = record.function_queries[562].get_mut(&__args[..]) { if !__cu && *result.multiplicity == G::ZERO { aiur_fn_562(__args, record, io_buffer, false)? } else { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_562] = unsafe { *(result.output.as_ptr() as *const [G; OUT_562]) }; __ret } } else { aiur_fn_562(__args, record, io_buffer, __cu)? } }; let __v_4: G = __r_arr[0]; - let __r_arr: [G; OUT_568] = { let __args: [G; IN_568] = [__v_4, __v_1, __v_2]; let __cu = unconstrained; if let Some(result) = record.function_queries[568].get_mut(&__args[..]) { if !__cu && *result.multiplicity == G::ZERO { aiur_fn_568(__args, record, io_buffer, false)? } else { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_568] = unsafe { *(result.output.as_ptr() as *const [G; OUT_568]) }; __ret } } else { aiur_fn_568(__args, record, io_buffer, __cu)? } }; + let __r_arr: [G; OUT_564] = { let __args: [G; IN_564] = [__v_4, __v_1, __v_2]; let __cu = unconstrained; if let Some(result) = record.function_queries[564].get_mut(&__args[..]) { if !__cu && *result.multiplicity == G::ZERO { aiur_fn_564(__args, record, io_buffer, false)? } else { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_564] = unsafe { *(result.output.as_ptr() as *const [G; OUT_564]) }; __ret } } else { aiur_fn_564(__args, record, io_buffer, __cu)? } }; let __v_5: G = __r_arr[0]; - let __ret: [G; OUT_565] = [__v_5]; - if let Some(result) = record.function_queries[565].get_mut(&inp[..]) { debug_assert_eq!(result.output, &__ret[..]); if !unconstrained { *result.multiplicity += G::ONE; } } else { record.function_queries[565].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained)); }; + let __ret: [G; OUT_561] = [__v_5]; + if let Some(result) = record.function_queries[561].get_mut(&inp[..]) { debug_assert_eq!(result.output, &__ret[..]); if !unconstrained { *result.multiplicity += G::ONE; } } else { record.function_queries[561].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained)); }; return Ok(__ret); }, } }) } -const INPUT_SIZE_566: usize = 3; -const IN_566: usize = 3; -const OUT_566: usize = 1; -fn aiur_fn_566( - inp: [G; IN_566], +const INPUT_SIZE_562: usize = 3; +const IN_562: usize = 3; +const OUT_562: usize = 1; +fn aiur_fn_562( + inp: [G; IN_562], record: &mut QueryRecord, io_buffer: &mut IOBuffer, unconstrained: bool, -) -> Result<[G; OUT_566], ExecError> { +) -> Result<[G; OUT_562], ExecError> { stacker::maybe_grow(64 * 1024, 4 * 1024 * 1024, || { let __v_0: G = inp[0]; let __v_1: G = inp[1]; @@ -48783,17 +48499,17 @@ fn aiur_fn_566( let __v_6: G = G::from_u64(1); let __v_7: G = G::from_u64(1); let __v_8: G = { let __values: [G; 3] = [__v_6, __v_7, __v_7]; let __mq = record.memory_queries.get_mut(&3).ok_or(ExecError::InvalidMemorySize(3))?; if let Some(result) = __mq.get_mut(&__values[..]) { if !unconstrained { *result.multiplicity += G::ONE; } result.output[0] } else { let __ptr = G::from_usize(__mq.len()); __mq.insert(&__values[..], &[__ptr], G::from_bool(!unconstrained)); __ptr } }; - let __ret: [G; OUT_566] = [__v_8]; - if let Some(result) = record.function_queries[566].get_mut(&inp[..]) { debug_assert_eq!(result.output, &__ret[..]); if !unconstrained { *result.multiplicity += G::ONE; } } else { record.function_queries[566].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained)); }; + let __ret: [G; OUT_562] = [__v_8]; + if let Some(result) = record.function_queries[562].get_mut(&inp[..]) { debug_assert_eq!(result.output, &__ret[..]); if !unconstrained { *result.multiplicity += G::ONE; } } else { record.function_queries[562].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained)); }; return Ok(__ret); }, 0u64 => { - let __r_arr: [G; OUT_566] = { let __args: [G; IN_566] = [__v_5, __v_1, __v_2]; let __cu = unconstrained; if let Some(result) = record.function_queries[566].get_mut(&__args[..]) { if !__cu && *result.multiplicity == G::ZERO { aiur_fn_566(__args, record, io_buffer, false)? } else { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_566] = unsafe { *(result.output.as_ptr() as *const [G; OUT_566]) }; __ret } } else { aiur_fn_566(__args, record, io_buffer, __cu)? } }; + let __r_arr: [G; OUT_562] = { let __args: [G; IN_562] = [__v_5, __v_1, __v_2]; let __cu = unconstrained; if let Some(result) = record.function_queries[562].get_mut(&__args[..]) { if !__cu && *result.multiplicity == G::ZERO { aiur_fn_562(__args, record, io_buffer, false)? } else { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_562] = unsafe { *(result.output.as_ptr() as *const [G; OUT_562]) }; __ret } } else { aiur_fn_562(__args, record, io_buffer, __cu)? } }; let __v_6: G = __r_arr[0]; - let __r_arr: [G; OUT_567] = { let __args: [G; IN_567] = [__v_4, __v_6, __v_1, __v_2]; let __cu = unconstrained; if let Some(result) = record.function_queries[567].get_mut(&__args[..]) { if !__cu && *result.multiplicity == G::ZERO { aiur_fn_567(__args, record, io_buffer, false)? } else { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_567] = unsafe { *(result.output.as_ptr() as *const [G; OUT_567]) }; __ret } } else { aiur_fn_567(__args, record, io_buffer, __cu)? } }; + let __r_arr: [G; OUT_563] = { let __args: [G; IN_563] = [__v_4, __v_6, __v_1, __v_2]; let __cu = unconstrained; if let Some(result) = record.function_queries[563].get_mut(&__args[..]) { if !__cu && *result.multiplicity == G::ZERO { aiur_fn_563(__args, record, io_buffer, false)? } else { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_563] = unsafe { *(result.output.as_ptr() as *const [G; OUT_563]) }; __ret } } else { aiur_fn_563(__args, record, io_buffer, __cu)? } }; let __v_7: G = __r_arr[0]; - let __ret: [G; OUT_566] = [__v_7]; - if let Some(result) = record.function_queries[566].get_mut(&inp[..]) { debug_assert_eq!(result.output, &__ret[..]); if !unconstrained { *result.multiplicity += G::ONE; } } else { record.function_queries[566].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained)); }; + let __ret: [G; OUT_562] = [__v_7]; + if let Some(result) = record.function_queries[562].get_mut(&inp[..]) { debug_assert_eq!(result.output, &__ret[..]); if !unconstrained { *result.multiplicity += G::ONE; } } else { record.function_queries[562].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained)); }; return Ok(__ret); }, _ => { @@ -48803,15 +48519,15 @@ fn aiur_fn_566( }) } -const INPUT_SIZE_567: usize = 4; -const IN_567: usize = 4; -const OUT_567: usize = 1; -fn aiur_fn_567( - inp: [G; IN_567], +const INPUT_SIZE_563: usize = 4; +const IN_563: usize = 4; +const OUT_563: usize = 1; +fn aiur_fn_563( + inp: [G; IN_563], record: &mut QueryRecord, io_buffer: &mut IOBuffer, unconstrained: bool, -) -> Result<[G; OUT_567], ExecError> { +) -> Result<[G; OUT_563], ExecError> { stacker::maybe_grow(64 * 1024, 4 * 1024 * 1024, || { let __v_0: G = inp[0]; let __v_1: G = inp[1]; @@ -48828,12 +48544,12 @@ fn aiur_fn_567( let __v_9: G = G::from_u64(1); let __v_10: G = { let __values: [G; 3] = [__v_8, __v_9, __v_9]; let __mq = record.memory_queries.get_mut(&3).ok_or(ExecError::InvalidMemorySize(3))?; if let Some(result) = __mq.get_mut(&__values[..]) { if !unconstrained { *result.multiplicity += G::ONE; } result.output[0] } else { let __ptr = G::from_usize(__mq.len()); __mq.insert(&__values[..], &[__ptr], G::from_bool(!unconstrained)); __ptr } }; let __v_11: G = { let __values: [G; 3] = [__v_7, __v_0, __v_10]; let __mq = record.memory_queries.get_mut(&3).ok_or(ExecError::InvalidMemorySize(3))?; if let Some(result) = __mq.get_mut(&__values[..]) { if !unconstrained { *result.multiplicity += G::ONE; } result.output[0] } else { let __ptr = G::from_usize(__mq.len()); __mq.insert(&__values[..], &[__ptr], G::from_bool(!unconstrained)); __ptr } }; - let __ret: [G; OUT_567] = [__v_11]; - if let Some(result) = record.function_queries[567].get_mut(&inp[..]) { debug_assert_eq!(result.output, &__ret[..]); if !unconstrained { *result.multiplicity += G::ONE; } } else { record.function_queries[567].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained)); }; + let __ret: [G; OUT_563] = [__v_11]; + if let Some(result) = record.function_queries[563].get_mut(&inp[..]) { debug_assert_eq!(result.output, &__ret[..]); if !unconstrained { *result.multiplicity += G::ONE; } } else { record.function_queries[563].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained)); }; return Ok(__ret); }, 0u64 => { - let __r_arr: [G; OUT_556] = { let __args: [G; IN_556] = [__v_3, __v_0]; let __cu = unconstrained; if let Some(result) = record.function_queries[556].get_mut(&__args[..]) { if !__cu && *result.multiplicity == G::ZERO { aiur_fn_556(__args, record, io_buffer, false)? } else { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_556] = unsafe { *(result.output.as_ptr() as *const [G; OUT_556]) }; __ret } } else { aiur_fn_556(__args, record, io_buffer, __cu)? } }; + let __r_arr: [G; OUT_552] = { let __args: [G; IN_552] = [__v_3, __v_0]; let __cu = unconstrained; if let Some(result) = record.function_queries[552].get_mut(&__args[..]) { if !__cu && *result.multiplicity == G::ZERO { aiur_fn_552(__args, record, io_buffer, false)? } else { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_552] = unsafe { *(result.output.as_ptr() as *const [G; OUT_552]) }; __ret } } else { aiur_fn_552(__args, record, io_buffer, __cu)? } }; let __v_7: G = __r_arr[0]; let __v_8: G = __r_arr[1]; let __v_9: G = __r_arr[2]; @@ -48846,7 +48562,7 @@ fn aiur_fn_567( let __v_16: G = __r_arr[9]; let __v_17: G = __r_arr[10]; let __v_18: G = __r_arr[11]; - let __r_arr: [G; OUT_556] = { let __args: [G; IN_556] = [__v_3, __v_5]; let __cu = unconstrained; if let Some(result) = record.function_queries[556].get_mut(&__args[..]) { if !__cu && *result.multiplicity == G::ZERO { aiur_fn_556(__args, record, io_buffer, false)? } else { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_556] = unsafe { *(result.output.as_ptr() as *const [G; OUT_556]) }; __ret } } else { aiur_fn_556(__args, record, io_buffer, __cu)? } }; + let __r_arr: [G; OUT_552] = { let __args: [G; IN_552] = [__v_3, __v_5]; let __cu = unconstrained; if let Some(result) = record.function_queries[552].get_mut(&__args[..]) { if !__cu && *result.multiplicity == G::ZERO { aiur_fn_552(__args, record, io_buffer, false)? } else { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_552] = unsafe { *(result.output.as_ptr() as *const [G; OUT_552]) }; __ret } } else { aiur_fn_552(__args, record, io_buffer, __cu)? } }; let __v_19: G = __r_arr[0]; let __v_20: G = __r_arr[1]; let __v_21: G = __r_arr[2]; @@ -48859,24 +48575,24 @@ fn aiur_fn_567( let __v_28: G = __r_arr[9]; let __v_29: G = __r_arr[10]; let __v_30: G = __r_arr[11]; - let __r_arr: [G; OUT_551] = { let __args: [G; IN_551] = [__v_7, __v_8, __v_9, __v_10, __v_11, __v_12, __v_13, __v_14, __v_15, __v_16, __v_17, __v_18, __v_19, __v_20, __v_21, __v_22, __v_23, __v_24, __v_25, __v_26, __v_27, __v_28, __v_29, __v_30, __v_2]; let __cu = unconstrained; if let Some(result) = record.function_queries[551].get_mut(&__args[..]) { if !__cu && *result.multiplicity == G::ZERO { aiur_fn_551(__args, record, io_buffer, false)? } else { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_551] = unsafe { *(result.output.as_ptr() as *const [G; OUT_551]) }; __ret } } else { aiur_fn_551(__args, record, io_buffer, __cu)? } }; + let __r_arr: [G; OUT_547] = { let __args: [G; IN_547] = [__v_7, __v_8, __v_9, __v_10, __v_11, __v_12, __v_13, __v_14, __v_15, __v_16, __v_17, __v_18, __v_19, __v_20, __v_21, __v_22, __v_23, __v_24, __v_25, __v_26, __v_27, __v_28, __v_29, __v_30, __v_2]; let __cu = unconstrained; if let Some(result) = record.function_queries[547].get_mut(&__args[..]) { if !__cu && *result.multiplicity == G::ZERO { aiur_fn_547(__args, record, io_buffer, false)? } else { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_547] = unsafe { *(result.output.as_ptr() as *const [G; OUT_547]) }; __ret } } else { aiur_fn_547(__args, record, io_buffer, __cu)? } }; let __v_31: G = __r_arr[0]; let __v_32: G = __r_arr[1]; match __v_31.as_canonical_u64() { 0u64 => { let __v_33: G = G::from_u64(0); let __v_34: G = { let __values: [G; 3] = [__v_33, __v_0, __v_1]; let __mq = record.memory_queries.get_mut(&3).ok_or(ExecError::InvalidMemorySize(3))?; if let Some(result) = __mq.get_mut(&__values[..]) { if !unconstrained { *result.multiplicity += G::ONE; } result.output[0] } else { let __ptr = G::from_usize(__mq.len()); __mq.insert(&__values[..], &[__ptr], G::from_bool(!unconstrained)); __ptr } }; - let __ret: [G; OUT_567] = [__v_34]; - if let Some(result) = record.function_queries[567].get_mut(&inp[..]) { debug_assert_eq!(result.output, &__ret[..]); if !unconstrained { *result.multiplicity += G::ONE; } } else { record.function_queries[567].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained)); }; + let __ret: [G; OUT_563] = [__v_34]; + if let Some(result) = record.function_queries[563].get_mut(&inp[..]) { debug_assert_eq!(result.output, &__ret[..]); if !unconstrained { *result.multiplicity += G::ONE; } } else { record.function_queries[563].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained)); }; return Ok(__ret); }, _ => { let __v_33: G = G::from_u64(0); - let __r_arr: [G; OUT_567] = { let __args: [G; IN_567] = [__v_0, __v_6, __v_2, __v_3]; let __cu = unconstrained; if let Some(result) = record.function_queries[567].get_mut(&__args[..]) { if !__cu && *result.multiplicity == G::ZERO { aiur_fn_567(__args, record, io_buffer, false)? } else { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_567] = unsafe { *(result.output.as_ptr() as *const [G; OUT_567]) }; __ret } } else { aiur_fn_567(__args, record, io_buffer, __cu)? } }; + let __r_arr: [G; OUT_563] = { let __args: [G; IN_563] = [__v_0, __v_6, __v_2, __v_3]; let __cu = unconstrained; if let Some(result) = record.function_queries[563].get_mut(&__args[..]) { if !__cu && *result.multiplicity == G::ZERO { aiur_fn_563(__args, record, io_buffer, false)? } else { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_563] = unsafe { *(result.output.as_ptr() as *const [G; OUT_563]) }; __ret } } else { aiur_fn_563(__args, record, io_buffer, __cu)? } }; let __v_34: G = __r_arr[0]; let __v_35: G = { let __values: [G; 3] = [__v_33, __v_5, __v_34]; let __mq = record.memory_queries.get_mut(&3).ok_or(ExecError::InvalidMemorySize(3))?; if let Some(result) = __mq.get_mut(&__values[..]) { if !unconstrained { *result.multiplicity += G::ONE; } result.output[0] } else { let __ptr = G::from_usize(__mq.len()); __mq.insert(&__values[..], &[__ptr], G::from_bool(!unconstrained)); __ptr } }; - let __ret: [G; OUT_567] = [__v_35]; - if let Some(result) = record.function_queries[567].get_mut(&inp[..]) { debug_assert_eq!(result.output, &__ret[..]); if !unconstrained { *result.multiplicity += G::ONE; } } else { record.function_queries[567].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained)); }; + let __ret: [G; OUT_563] = [__v_35]; + if let Some(result) = record.function_queries[563].get_mut(&inp[..]) { debug_assert_eq!(result.output, &__ret[..]); if !unconstrained { *result.multiplicity += G::ONE; } } else { record.function_queries[563].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained)); }; return Ok(__ret); }, } @@ -48888,15 +48604,15 @@ fn aiur_fn_567( }) } -const INPUT_SIZE_568: usize = 3; -const IN_568: usize = 3; -const OUT_568: usize = 1; -fn aiur_fn_568( - inp: [G; IN_568], +const INPUT_SIZE_564: usize = 3; +const IN_564: usize = 3; +const OUT_564: usize = 1; +fn aiur_fn_564( + inp: [G; IN_564], record: &mut QueryRecord, io_buffer: &mut IOBuffer, unconstrained: bool, -) -> Result<[G; OUT_568], ExecError> { +) -> Result<[G; OUT_564], ExecError> { stacker::maybe_grow(64 * 1024, 4 * 1024 * 1024, || { let __v_0: G = inp[0]; let __v_1: G = inp[1]; @@ -48910,8 +48626,8 @@ fn aiur_fn_568( let __v_6: G = G::from_u64(1); let __v_7: G = G::from_u64(1); let __v_8: G = { let __values: [G; 3] = [__v_6, __v_7, __v_7]; let __mq = record.memory_queries.get_mut(&3).ok_or(ExecError::InvalidMemorySize(3))?; if let Some(result) = __mq.get_mut(&__values[..]) { if !unconstrained { *result.multiplicity += G::ONE; } result.output[0] } else { let __ptr = G::from_usize(__mq.len()); __mq.insert(&__values[..], &[__ptr], G::from_bool(!unconstrained)); __ptr } }; - let __ret: [G; OUT_568] = [__v_8]; - if let Some(result) = record.function_queries[568].get_mut(&inp[..]) { debug_assert_eq!(result.output, &__ret[..]); if !unconstrained { *result.multiplicity += G::ONE; } } else { record.function_queries[568].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained)); }; + let __ret: [G; OUT_564] = [__v_8]; + if let Some(result) = record.function_queries[564].get_mut(&inp[..]) { debug_assert_eq!(result.output, &__ret[..]); if !unconstrained { *result.multiplicity += G::ONE; } } else { record.function_queries[564].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained)); }; return Ok(__ret); }, 0u64 => { @@ -48920,10 +48636,10 @@ fn aiur_fn_568( let __v_8: G = G::from_u64(1); let __v_9: G = { let __values: [G; 3] = [__v_7, __v_8, __v_8]; let __mq = record.memory_queries.get_mut(&3).ok_or(ExecError::InvalidMemorySize(3))?; if let Some(result) = __mq.get_mut(&__values[..]) { if !unconstrained { *result.multiplicity += G::ONE; } result.output[0] } else { let __ptr = G::from_usize(__mq.len()); __mq.insert(&__values[..], &[__ptr], G::from_bool(!unconstrained)); __ptr } }; let __v_10: G = { let __values: [G; 3] = [__v_6, __v_4, __v_9]; let __mq = record.memory_queries.get_mut(&3).ok_or(ExecError::InvalidMemorySize(3))?; if let Some(result) = __mq.get_mut(&__values[..]) { if !unconstrained { *result.multiplicity += G::ONE; } result.output[0] } else { let __ptr = G::from_usize(__mq.len()); __mq.insert(&__values[..], &[__ptr], G::from_bool(!unconstrained)); __ptr } }; - let __r_arr: [G; OUT_569] = { let __args: [G; IN_569] = [__v_5, __v_1, __v_2, __v_4, __v_10]; let __cu = unconstrained; if let Some(result) = record.function_queries[569].get_mut(&__args[..]) { if !__cu && *result.multiplicity == G::ZERO { aiur_fn_569(__args, record, io_buffer, false)? } else { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_569] = unsafe { *(result.output.as_ptr() as *const [G; OUT_569]) }; __ret } } else { aiur_fn_569(__args, record, io_buffer, __cu)? } }; + let __r_arr: [G; OUT_565] = { let __args: [G; IN_565] = [__v_5, __v_1, __v_2, __v_4, __v_10]; let __cu = unconstrained; if let Some(result) = record.function_queries[565].get_mut(&__args[..]) { if !__cu && *result.multiplicity == G::ZERO { aiur_fn_565(__args, record, io_buffer, false)? } else { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_565] = unsafe { *(result.output.as_ptr() as *const [G; OUT_565]) }; __ret } } else { aiur_fn_565(__args, record, io_buffer, __cu)? } }; let __v_11: G = __r_arr[0]; - let __ret: [G; OUT_568] = [__v_11]; - if let Some(result) = record.function_queries[568].get_mut(&inp[..]) { debug_assert_eq!(result.output, &__ret[..]); if !unconstrained { *result.multiplicity += G::ONE; } } else { record.function_queries[568].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained)); }; + let __ret: [G; OUT_564] = [__v_11]; + if let Some(result) = record.function_queries[564].get_mut(&inp[..]) { debug_assert_eq!(result.output, &__ret[..]); if !unconstrained { *result.multiplicity += G::ONE; } } else { record.function_queries[564].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained)); }; return Ok(__ret); }, _ => { @@ -48933,15 +48649,15 @@ fn aiur_fn_568( }) } -const INPUT_SIZE_569: usize = 5; -const IN_569: usize = 5; -const OUT_569: usize = 1; -fn aiur_fn_569( - inp: [G; IN_569], +const INPUT_SIZE_565: usize = 5; +const IN_565: usize = 5; +const OUT_565: usize = 1; +fn aiur_fn_565( + inp: [G; IN_565], record: &mut QueryRecord, io_buffer: &mut IOBuffer, unconstrained: bool, -) -> Result<[G; OUT_569], ExecError> { +) -> Result<[G; OUT_565], ExecError> { stacker::maybe_grow(64 * 1024, 4 * 1024 * 1024, || { let __v_0: G = inp[0]; let __v_1: G = inp[1]; @@ -48959,12 +48675,12 @@ fn aiur_fn_569( let __v_10: G = G::from_u64(1); let __v_11: G = { let __values: [G; 3] = [__v_9, __v_10, __v_10]; let __mq = record.memory_queries.get_mut(&3).ok_or(ExecError::InvalidMemorySize(3))?; if let Some(result) = __mq.get_mut(&__values[..]) { if !unconstrained { *result.multiplicity += G::ONE; } result.output[0] } else { let __ptr = G::from_usize(__mq.len()); __mq.insert(&__values[..], &[__ptr], G::from_bool(!unconstrained)); __ptr } }; let __v_12: G = { let __values: [G; 3] = [__v_8, __v_4, __v_11]; let __mq = record.memory_queries.get_mut(&3).ok_or(ExecError::InvalidMemorySize(3))?; if let Some(result) = __mq.get_mut(&__values[..]) { if !unconstrained { *result.multiplicity += G::ONE; } result.output[0] } else { let __ptr = G::from_usize(__mq.len()); __mq.insert(&__values[..], &[__ptr], G::from_bool(!unconstrained)); __ptr } }; - let __ret: [G; OUT_569] = [__v_12]; - if let Some(result) = record.function_queries[569].get_mut(&inp[..]) { debug_assert_eq!(result.output, &__ret[..]); if !unconstrained { *result.multiplicity += G::ONE; } } else { record.function_queries[569].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained)); }; + let __ret: [G; OUT_565] = [__v_12]; + if let Some(result) = record.function_queries[565].get_mut(&inp[..]) { debug_assert_eq!(result.output, &__ret[..]); if !unconstrained { *result.multiplicity += G::ONE; } } else { record.function_queries[565].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained)); }; return Ok(__ret); }, 0u64 => { - let __r_arr: [G; OUT_556] = { let __args: [G; IN_556] = [__v_2, __v_3]; let __cu = unconstrained; if let Some(result) = record.function_queries[556].get_mut(&__args[..]) { if !__cu && *result.multiplicity == G::ZERO { aiur_fn_556(__args, record, io_buffer, false)? } else { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_556] = unsafe { *(result.output.as_ptr() as *const [G; OUT_556]) }; __ret } } else { aiur_fn_556(__args, record, io_buffer, __cu)? } }; + let __r_arr: [G; OUT_552] = { let __args: [G; IN_552] = [__v_2, __v_3]; let __cu = unconstrained; if let Some(result) = record.function_queries[552].get_mut(&__args[..]) { if !__cu && *result.multiplicity == G::ZERO { aiur_fn_552(__args, record, io_buffer, false)? } else { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_552] = unsafe { *(result.output.as_ptr() as *const [G; OUT_552]) }; __ret } } else { aiur_fn_552(__args, record, io_buffer, __cu)? } }; let __v_8: G = __r_arr[0]; let __v_9: G = __r_arr[1]; let __v_10: G = __r_arr[2]; @@ -48977,7 +48693,7 @@ fn aiur_fn_569( let __v_17: G = __r_arr[9]; let __v_18: G = __r_arr[10]; let __v_19: G = __r_arr[11]; - let __r_arr: [G; OUT_556] = { let __args: [G; IN_556] = [__v_2, __v_6]; let __cu = unconstrained; if let Some(result) = record.function_queries[556].get_mut(&__args[..]) { if !__cu && *result.multiplicity == G::ZERO { aiur_fn_556(__args, record, io_buffer, false)? } else { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_556] = unsafe { *(result.output.as_ptr() as *const [G; OUT_556]) }; __ret } } else { aiur_fn_556(__args, record, io_buffer, __cu)? } }; + let __r_arr: [G; OUT_552] = { let __args: [G; IN_552] = [__v_2, __v_6]; let __cu = unconstrained; if let Some(result) = record.function_queries[552].get_mut(&__args[..]) { if !__cu && *result.multiplicity == G::ZERO { aiur_fn_552(__args, record, io_buffer, false)? } else { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_552] = unsafe { *(result.output.as_ptr() as *const [G; OUT_552]) }; __ret } } else { aiur_fn_552(__args, record, io_buffer, __cu)? } }; let __v_20: G = __r_arr[0]; let __v_21: G = __r_arr[1]; let __v_22: G = __r_arr[2]; @@ -48990,17 +48706,17 @@ fn aiur_fn_569( let __v_29: G = __r_arr[9]; let __v_30: G = __r_arr[10]; let __v_31: G = __r_arr[11]; - let __r_arr: [G; OUT_551] = { let __args: [G; IN_551] = [__v_8, __v_9, __v_10, __v_11, __v_12, __v_13, __v_14, __v_15, __v_16, __v_17, __v_18, __v_19, __v_20, __v_21, __v_22, __v_23, __v_24, __v_25, __v_26, __v_27, __v_28, __v_29, __v_30, __v_31, __v_1]; let __cu = unconstrained; if let Some(result) = record.function_queries[551].get_mut(&__args[..]) { if !__cu && *result.multiplicity == G::ZERO { aiur_fn_551(__args, record, io_buffer, false)? } else { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_551] = unsafe { *(result.output.as_ptr() as *const [G; OUT_551]) }; __ret } } else { aiur_fn_551(__args, record, io_buffer, __cu)? } }; + let __r_arr: [G; OUT_547] = { let __args: [G; IN_547] = [__v_8, __v_9, __v_10, __v_11, __v_12, __v_13, __v_14, __v_15, __v_16, __v_17, __v_18, __v_19, __v_20, __v_21, __v_22, __v_23, __v_24, __v_25, __v_26, __v_27, __v_28, __v_29, __v_30, __v_31, __v_1]; let __cu = unconstrained; if let Some(result) = record.function_queries[547].get_mut(&__args[..]) { if !__cu && *result.multiplicity == G::ZERO { aiur_fn_547(__args, record, io_buffer, false)? } else { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_547] = unsafe { *(result.output.as_ptr() as *const [G; OUT_547]) }; __ret } } else { aiur_fn_547(__args, record, io_buffer, __cu)? } }; let __v_32: G = __r_arr[0]; let __v_33: G = __r_arr[1]; match __v_32.as_canonical_u64() { 1u64 => { - let __r_arr: [G; OUT_757] = { let __args: [G; IN_757] = [__v_4, __v_6]; let __cu = unconstrained; if let Some(result) = record.function_queries[757].get_mut(&__args[..]) { if !__cu && *result.multiplicity == G::ZERO { aiur_fn_757(__args, record, io_buffer, false)? } else { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_757] = unsafe { *(result.output.as_ptr() as *const [G; OUT_757]) }; __ret } } else { aiur_fn_757(__args, record, io_buffer, __cu)? } }; + let __r_arr: [G; OUT_753] = { let __args: [G; IN_753] = [__v_4, __v_6]; let __cu = unconstrained; if let Some(result) = record.function_queries[753].get_mut(&__args[..]) { if !__cu && *result.multiplicity == G::ZERO { aiur_fn_753(__args, record, io_buffer, false)? } else { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_753] = unsafe { *(result.output.as_ptr() as *const [G; OUT_753]) }; __ret } } else { aiur_fn_753(__args, record, io_buffer, __cu)? } }; let __v_34: G = __r_arr[0]; - let __r_arr: [G; OUT_569] = { let __args: [G; IN_569] = [__v_7, __v_1, __v_2, __v_6, __v_34]; let __cu = unconstrained; if let Some(result) = record.function_queries[569].get_mut(&__args[..]) { if !__cu && *result.multiplicity == G::ZERO { aiur_fn_569(__args, record, io_buffer, false)? } else { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_569] = unsafe { *(result.output.as_ptr() as *const [G; OUT_569]) }; __ret } } else { aiur_fn_569(__args, record, io_buffer, __cu)? } }; + let __r_arr: [G; OUT_565] = { let __args: [G; IN_565] = [__v_7, __v_1, __v_2, __v_6, __v_34]; let __cu = unconstrained; if let Some(result) = record.function_queries[565].get_mut(&__args[..]) { if !__cu && *result.multiplicity == G::ZERO { aiur_fn_565(__args, record, io_buffer, false)? } else { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_565] = unsafe { *(result.output.as_ptr() as *const [G; OUT_565]) }; __ret } } else { aiur_fn_565(__args, record, io_buffer, __cu)? } }; let __v_35: G = __r_arr[0]; - let __ret: [G; OUT_569] = [__v_35]; - if let Some(result) = record.function_queries[569].get_mut(&inp[..]) { debug_assert_eq!(result.output, &__ret[..]); if !unconstrained { *result.multiplicity += G::ONE; } } else { record.function_queries[569].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained)); }; + let __ret: [G; OUT_565] = [__v_35]; + if let Some(result) = record.function_queries[565].get_mut(&inp[..]) { debug_assert_eq!(result.output, &__ret[..]); if !unconstrained { *result.multiplicity += G::ONE; } } else { record.function_queries[565].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained)); }; return Ok(__ret); }, _ => { @@ -49010,11 +48726,11 @@ fn aiur_fn_569( let __v_37: G = G::from_u64(1); let __v_38: G = { let __values: [G; 3] = [__v_36, __v_37, __v_37]; let __mq = record.memory_queries.get_mut(&3).ok_or(ExecError::InvalidMemorySize(3))?; if let Some(result) = __mq.get_mut(&__values[..]) { if !unconstrained { *result.multiplicity += G::ONE; } result.output[0] } else { let __ptr = G::from_usize(__mq.len()); __mq.insert(&__values[..], &[__ptr], G::from_bool(!unconstrained)); __ptr } }; let __v_39: G = { let __values: [G; 3] = [__v_35, __v_6, __v_38]; let __mq = record.memory_queries.get_mut(&3).ok_or(ExecError::InvalidMemorySize(3))?; if let Some(result) = __mq.get_mut(&__values[..]) { if !unconstrained { *result.multiplicity += G::ONE; } result.output[0] } else { let __ptr = G::from_usize(__mq.len()); __mq.insert(&__values[..], &[__ptr], G::from_bool(!unconstrained)); __ptr } }; - let __r_arr: [G; OUT_569] = { let __args: [G; IN_569] = [__v_7, __v_1, __v_2, __v_6, __v_39]; let __cu = unconstrained; if let Some(result) = record.function_queries[569].get_mut(&__args[..]) { if !__cu && *result.multiplicity == G::ZERO { aiur_fn_569(__args, record, io_buffer, false)? } else { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_569] = unsafe { *(result.output.as_ptr() as *const [G; OUT_569]) }; __ret } } else { aiur_fn_569(__args, record, io_buffer, __cu)? } }; + let __r_arr: [G; OUT_565] = { let __args: [G; IN_565] = [__v_7, __v_1, __v_2, __v_6, __v_39]; let __cu = unconstrained; if let Some(result) = record.function_queries[565].get_mut(&__args[..]) { if !__cu && *result.multiplicity == G::ZERO { aiur_fn_565(__args, record, io_buffer, false)? } else { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_565] = unsafe { *(result.output.as_ptr() as *const [G; OUT_565]) }; __ret } } else { aiur_fn_565(__args, record, io_buffer, __cu)? } }; let __v_40: G = __r_arr[0]; let __v_41: G = { let __values: [G; 3] = [__v_34, __v_4, __v_40]; let __mq = record.memory_queries.get_mut(&3).ok_or(ExecError::InvalidMemorySize(3))?; if let Some(result) = __mq.get_mut(&__values[..]) { if !unconstrained { *result.multiplicity += G::ONE; } result.output[0] } else { let __ptr = G::from_usize(__mq.len()); __mq.insert(&__values[..], &[__ptr], G::from_bool(!unconstrained)); __ptr } }; - let __ret: [G; OUT_569] = [__v_41]; - if let Some(result) = record.function_queries[569].get_mut(&inp[..]) { debug_assert_eq!(result.output, &__ret[..]); if !unconstrained { *result.multiplicity += G::ONE; } } else { record.function_queries[569].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained)); }; + let __ret: [G; OUT_565] = [__v_41]; + if let Some(result) = record.function_queries[565].get_mut(&inp[..]) { debug_assert_eq!(result.output, &__ret[..]); if !unconstrained { *result.multiplicity += G::ONE; } } else { record.function_queries[565].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained)); }; return Ok(__ret); }, } @@ -49026,15 +48742,15 @@ fn aiur_fn_569( }) } -const INPUT_SIZE_570: usize = 2; -const IN_570: usize = 2; -const OUT_570: usize = 1; -fn aiur_fn_570( - inp: [G; IN_570], +const INPUT_SIZE_566: usize = 2; +const IN_566: usize = 2; +const OUT_566: usize = 1; +fn aiur_fn_566( + inp: [G; IN_566], record: &mut QueryRecord, io_buffer: &mut IOBuffer, unconstrained: bool, -) -> Result<[G; OUT_570], ExecError> { +) -> Result<[G; OUT_566], ExecError> { stacker::maybe_grow(64 * 1024, 4 * 1024 * 1024, || { let __v_0: G = inp[0]; let __v_1: G = inp[1]; @@ -49051,14 +48767,14 @@ fn aiur_fn_570( match __v_5.as_canonical_u64() { 1u64 => { let __v_8: G = G::from_u64(1); - let __ret: [G; OUT_570] = [__v_8]; - if let Some(result) = record.function_queries[570].get_mut(&inp[..]) { debug_assert_eq!(result.output, &__ret[..]); if !unconstrained { *result.multiplicity += G::ONE; } } else { record.function_queries[570].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained)); }; + let __ret: [G; OUT_566] = [__v_8]; + if let Some(result) = record.function_queries[566].get_mut(&inp[..]) { debug_assert_eq!(result.output, &__ret[..]); if !unconstrained { *result.multiplicity += G::ONE; } } else { record.function_queries[566].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained)); }; return Ok(__ret); }, _ => { let __v_8: G = G::from_u64(0); - let __ret: [G; OUT_570] = [__v_8]; - if let Some(result) = record.function_queries[570].get_mut(&inp[..]) { debug_assert_eq!(result.output, &__ret[..]); if !unconstrained { *result.multiplicity += G::ONE; } } else { record.function_queries[570].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained)); }; + let __ret: [G; OUT_566] = [__v_8]; + if let Some(result) = record.function_queries[566].get_mut(&inp[..]) { debug_assert_eq!(result.output, &__ret[..]); if !unconstrained { *result.multiplicity += G::ONE; } } else { record.function_queries[566].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained)); }; return Ok(__ret); }, } @@ -49071,25 +48787,25 @@ fn aiur_fn_570( match __v_5.as_canonical_u64() { 1u64 => { let __v_8: G = G::from_u64(0); - let __ret: [G; OUT_570] = [__v_8]; - if let Some(result) = record.function_queries[570].get_mut(&inp[..]) { debug_assert_eq!(result.output, &__ret[..]); if !unconstrained { *result.multiplicity += G::ONE; } } else { record.function_queries[570].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained)); }; + let __ret: [G; OUT_566] = [__v_8]; + if let Some(result) = record.function_queries[566].get_mut(&inp[..]) { debug_assert_eq!(result.output, &__ret[..]); if !unconstrained { *result.multiplicity += G::ONE; } } else { record.function_queries[566].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained)); }; return Ok(__ret); }, 0u64 => { - let __r_arr: [G; OUT_339] = { let __args: [G; IN_339] = [__v_3, __v_6]; let __cu = unconstrained; if let Some(result) = record.function_queries[339].get_mut(&__args[..]) { if !__cu && *result.multiplicity == G::ZERO { aiur_fn_339(__args, record, io_buffer, false)? } else { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_339] = unsafe { *(result.output.as_ptr() as *const [G; OUT_339]) }; __ret } } else { aiur_fn_339(__args, record, io_buffer, __cu)? } }; + let __r_arr: [G; OUT_335] = { let __args: [G; IN_335] = [__v_3, __v_6]; let __cu = unconstrained; if let Some(result) = record.function_queries[335].get_mut(&__args[..]) { if !__cu && *result.multiplicity == G::ZERO { aiur_fn_335(__args, record, io_buffer, false)? } else { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_335] = unsafe { *(result.output.as_ptr() as *const [G; OUT_335]) }; __ret } } else { aiur_fn_335(__args, record, io_buffer, __cu)? } }; let __v_8: G = __r_arr[0]; match __v_8.as_canonical_u64() { 0u64 => { let __v_9: G = G::from_u64(0); - let __ret: [G; OUT_570] = [__v_9]; - if let Some(result) = record.function_queries[570].get_mut(&inp[..]) { debug_assert_eq!(result.output, &__ret[..]); if !unconstrained { *result.multiplicity += G::ONE; } } else { record.function_queries[570].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained)); }; + let __ret: [G; OUT_566] = [__v_9]; + if let Some(result) = record.function_queries[566].get_mut(&inp[..]) { debug_assert_eq!(result.output, &__ret[..]); if !unconstrained { *result.multiplicity += G::ONE; } } else { record.function_queries[566].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained)); }; return Ok(__ret); }, _ => { - let __r_arr: [G; OUT_570] = { let __args: [G; IN_570] = [__v_4, __v_7]; let __cu = unconstrained; if let Some(result) = record.function_queries[570].get_mut(&__args[..]) { if !__cu && *result.multiplicity == G::ZERO { aiur_fn_570(__args, record, io_buffer, false)? } else { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_570] = unsafe { *(result.output.as_ptr() as *const [G; OUT_570]) }; __ret } } else { aiur_fn_570(__args, record, io_buffer, __cu)? } }; + let __r_arr: [G; OUT_566] = { let __args: [G; IN_566] = [__v_4, __v_7]; let __cu = unconstrained; if let Some(result) = record.function_queries[566].get_mut(&__args[..]) { if !__cu && *result.multiplicity == G::ZERO { aiur_fn_566(__args, record, io_buffer, false)? } else { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_566] = unsafe { *(result.output.as_ptr() as *const [G; OUT_566]) }; __ret } } else { aiur_fn_566(__args, record, io_buffer, __cu)? } }; let __v_9: G = __r_arr[0]; - let __ret: [G; OUT_570] = [__v_9]; - if let Some(result) = record.function_queries[570].get_mut(&inp[..]) { debug_assert_eq!(result.output, &__ret[..]); if !unconstrained { *result.multiplicity += G::ONE; } } else { record.function_queries[570].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained)); }; + let __ret: [G; OUT_566] = [__v_9]; + if let Some(result) = record.function_queries[566].get_mut(&inp[..]) { debug_assert_eq!(result.output, &__ret[..]); if !unconstrained { *result.multiplicity += G::ONE; } } else { record.function_queries[566].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained)); }; return Ok(__ret); }, } @@ -49106,15 +48822,15 @@ fn aiur_fn_570( }) } -const INPUT_SIZE_571: usize = 1; -const IN_571: usize = 1; -const OUT_571: usize = 1; -fn aiur_fn_571( - inp: [G; IN_571], +const INPUT_SIZE_567: usize = 1; +const IN_567: usize = 1; +const OUT_567: usize = 1; +fn aiur_fn_567( + inp: [G; IN_567], record: &mut QueryRecord, io_buffer: &mut IOBuffer, unconstrained: bool, -) -> Result<[G; OUT_571], ExecError> { +) -> Result<[G; OUT_567], ExecError> { stacker::maybe_grow(64 * 1024, 4 * 1024 * 1024, || { let __v_0: G = inp[0]; let __loaded: [G; 3] = { let __mq = record.memory_queries.get_mut(&3).ok_or(ExecError::InvalidMemorySize(3))?; let __ptr_u64 = __v_0.as_canonical_u64(); let __ptr_usize = usize::try_from(__ptr_u64).ok().ok_or(ExecError::PointerTooLarge(__ptr_u64))?; let (__args, __mult) = __mq.get_index_mut(__ptr_usize).ok_or(ExecError::UnboundPointer { ptr: __ptr_u64, size: 3 })?; if !unconstrained { *__mult += G::ONE; } let __arr: [G; 3] = __args[..3].try_into().unwrap(); __arr }; @@ -49126,17 +48842,17 @@ fn aiur_fn_571( let __v_4: G = G::from_u64(1); let __v_5: G = G::from_u64(1); let __v_6: G = { let __values: [G; 3] = [__v_4, __v_5, __v_5]; let __mq = record.memory_queries.get_mut(&3).ok_or(ExecError::InvalidMemorySize(3))?; if let Some(result) = __mq.get_mut(&__values[..]) { if !unconstrained { *result.multiplicity += G::ONE; } result.output[0] } else { let __ptr = G::from_usize(__mq.len()); __mq.insert(&__values[..], &[__ptr], G::from_bool(!unconstrained)); __ptr } }; - let __ret: [G; OUT_571] = [__v_6]; - if let Some(result) = record.function_queries[571].get_mut(&inp[..]) { debug_assert_eq!(result.output, &__ret[..]); if !unconstrained { *result.multiplicity += G::ONE; } } else { record.function_queries[571].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained)); }; + let __ret: [G; OUT_567] = [__v_6]; + if let Some(result) = record.function_queries[567].get_mut(&inp[..]) { debug_assert_eq!(result.output, &__ret[..]); if !unconstrained { *result.multiplicity += G::ONE; } } else { record.function_queries[567].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained)); }; return Ok(__ret); }, 0u64 => { - let __r_arr: [G; OUT_571] = { let __args: [G; IN_571] = [__v_3]; let __cu = unconstrained; if let Some(result) = record.function_queries[571].get_mut(&__args[..]) { if !__cu && *result.multiplicity == G::ZERO { aiur_fn_571(__args, record, io_buffer, false)? } else { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_571] = unsafe { *(result.output.as_ptr() as *const [G; OUT_571]) }; __ret } } else { aiur_fn_571(__args, record, io_buffer, __cu)? } }; + let __r_arr: [G; OUT_567] = { let __args: [G; IN_567] = [__v_3]; let __cu = unconstrained; if let Some(result) = record.function_queries[567].get_mut(&__args[..]) { if !__cu && *result.multiplicity == G::ZERO { aiur_fn_567(__args, record, io_buffer, false)? } else { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_567] = unsafe { *(result.output.as_ptr() as *const [G; OUT_567]) }; __ret } } else { aiur_fn_567(__args, record, io_buffer, __cu)? } }; let __v_4: G = __r_arr[0]; - let __r_arr: [G; OUT_763] = { let __args: [G; IN_763] = [__v_2, __v_4]; let __cu = unconstrained; if let Some(result) = record.function_queries[763].get_mut(&__args[..]) { if !__cu && *result.multiplicity == G::ZERO { aiur_fn_763(__args, record, io_buffer, false)? } else { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_763] = unsafe { *(result.output.as_ptr() as *const [G; OUT_763]) }; __ret } } else { aiur_fn_763(__args, record, io_buffer, __cu)? } }; + let __r_arr: [G; OUT_759] = { let __args: [G; IN_759] = [__v_2, __v_4]; let __cu = unconstrained; if let Some(result) = record.function_queries[759].get_mut(&__args[..]) { if !__cu && *result.multiplicity == G::ZERO { aiur_fn_759(__args, record, io_buffer, false)? } else { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_759] = unsafe { *(result.output.as_ptr() as *const [G; OUT_759]) }; __ret } } else { aiur_fn_759(__args, record, io_buffer, __cu)? } }; let __v_5: G = __r_arr[0]; - let __ret: [G; OUT_571] = [__v_5]; - if let Some(result) = record.function_queries[571].get_mut(&inp[..]) { debug_assert_eq!(result.output, &__ret[..]); if !unconstrained { *result.multiplicity += G::ONE; } } else { record.function_queries[571].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained)); }; + let __ret: [G; OUT_567] = [__v_5]; + if let Some(result) = record.function_queries[567].get_mut(&inp[..]) { debug_assert_eq!(result.output, &__ret[..]); if !unconstrained { *result.multiplicity += G::ONE; } } else { record.function_queries[567].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained)); }; return Ok(__ret); }, _ => { @@ -49146,15 +48862,15 @@ fn aiur_fn_571( }) } -const INPUT_SIZE_572: usize = 1; -const IN_572: usize = 1; -const OUT_572: usize = 1; -fn aiur_fn_572( - inp: [G; IN_572], +const INPUT_SIZE_568: usize = 1; +const IN_568: usize = 1; +const OUT_568: usize = 1; +fn aiur_fn_568( + inp: [G; IN_568], record: &mut QueryRecord, io_buffer: &mut IOBuffer, unconstrained: bool, -) -> Result<[G; OUT_572], ExecError> { +) -> Result<[G; OUT_568], ExecError> { stacker::maybe_grow(64 * 1024, 4 * 1024 * 1024, || { let __v_0: G = inp[0]; let __loaded: [G; 3] = { let __mq = record.memory_queries.get_mut(&3).ok_or(ExecError::InvalidMemorySize(3))?; let __ptr_u64 = __v_0.as_canonical_u64(); let __ptr_usize = usize::try_from(__ptr_u64).ok().ok_or(ExecError::PointerTooLarge(__ptr_u64))?; let (__args, __mult) = __mq.get_index_mut(__ptr_usize).ok_or(ExecError::UnboundPointer { ptr: __ptr_u64, size: 3 })?; if !unconstrained { *__mult += G::ONE; } let __arr: [G; 3] = __args[..3].try_into().unwrap(); __arr }; @@ -49164,25 +48880,25 @@ fn aiur_fn_572( match __v_1.as_canonical_u64() { 1u64 => { let __v_4: G = G::from_u64(1); - let __ret: [G; OUT_572] = [__v_4]; - if let Some(result) = record.function_queries[572].get_mut(&inp[..]) { debug_assert_eq!(result.output, &__ret[..]); if !unconstrained { *result.multiplicity += G::ONE; } } else { record.function_queries[572].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained)); }; + let __ret: [G; OUT_568] = [__v_4]; + if let Some(result) = record.function_queries[568].get_mut(&inp[..]) { debug_assert_eq!(result.output, &__ret[..]); if !unconstrained { *result.multiplicity += G::ONE; } } else { record.function_queries[568].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained)); }; return Ok(__ret); }, 0u64 => { - let __r_arr: [G; OUT_764] = { let __args: [G; IN_764] = [__v_2]; let __cu = unconstrained; if let Some(result) = record.function_queries[764].get_mut(&__args[..]) { if !__cu && *result.multiplicity == G::ZERO { aiur_fn_764(__args, record, io_buffer, false)? } else { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_764] = unsafe { *(result.output.as_ptr() as *const [G; OUT_764]) }; __ret } } else { aiur_fn_764(__args, record, io_buffer, __cu)? } }; + let __r_arr: [G; OUT_760] = { let __args: [G; IN_760] = [__v_2]; let __cu = unconstrained; if let Some(result) = record.function_queries[760].get_mut(&__args[..]) { if !__cu && *result.multiplicity == G::ZERO { aiur_fn_760(__args, record, io_buffer, false)? } else { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_760] = unsafe { *(result.output.as_ptr() as *const [G; OUT_760]) }; __ret } } else { aiur_fn_760(__args, record, io_buffer, __cu)? } }; let __v_4: G = __r_arr[0]; match __v_4.as_canonical_u64() { 1u64 => { - let __r_arr: [G; OUT_572] = { let __args: [G; IN_572] = [__v_3]; let __cu = unconstrained; if let Some(result) = record.function_queries[572].get_mut(&__args[..]) { if !__cu && *result.multiplicity == G::ZERO { aiur_fn_572(__args, record, io_buffer, false)? } else { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_572] = unsafe { *(result.output.as_ptr() as *const [G; OUT_572]) }; __ret } } else { aiur_fn_572(__args, record, io_buffer, __cu)? } }; + let __r_arr: [G; OUT_568] = { let __args: [G; IN_568] = [__v_3]; let __cu = unconstrained; if let Some(result) = record.function_queries[568].get_mut(&__args[..]) { if !__cu && *result.multiplicity == G::ZERO { aiur_fn_568(__args, record, io_buffer, false)? } else { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_568] = unsafe { *(result.output.as_ptr() as *const [G; OUT_568]) }; __ret } } else { aiur_fn_568(__args, record, io_buffer, __cu)? } }; let __v_5: G = __r_arr[0]; - let __ret: [G; OUT_572] = [__v_5]; - if let Some(result) = record.function_queries[572].get_mut(&inp[..]) { debug_assert_eq!(result.output, &__ret[..]); if !unconstrained { *result.multiplicity += G::ONE; } } else { record.function_queries[572].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained)); }; + let __ret: [G; OUT_568] = [__v_5]; + if let Some(result) = record.function_queries[568].get_mut(&inp[..]) { debug_assert_eq!(result.output, &__ret[..]); if !unconstrained { *result.multiplicity += G::ONE; } } else { record.function_queries[568].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained)); }; return Ok(__ret); }, _ => { let __v_5: G = G::from_u64(0); - let __ret: [G; OUT_572] = [__v_5]; - if let Some(result) = record.function_queries[572].get_mut(&inp[..]) { debug_assert_eq!(result.output, &__ret[..]); if !unconstrained { *result.multiplicity += G::ONE; } } else { record.function_queries[572].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained)); }; + let __ret: [G; OUT_568] = [__v_5]; + if let Some(result) = record.function_queries[568].get_mut(&inp[..]) { debug_assert_eq!(result.output, &__ret[..]); if !unconstrained { *result.multiplicity += G::ONE; } } else { record.function_queries[568].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained)); }; return Ok(__ret); }, } @@ -49194,15 +48910,15 @@ fn aiur_fn_572( }) } -const INPUT_SIZE_573: usize = 2; -const IN_573: usize = 2; -const OUT_573: usize = 1; -fn aiur_fn_573( - inp: [G; IN_573], +const INPUT_SIZE_569: usize = 2; +const IN_569: usize = 2; +const OUT_569: usize = 1; +fn aiur_fn_569( + inp: [G; IN_569], record: &mut QueryRecord, io_buffer: &mut IOBuffer, unconstrained: bool, -) -> Result<[G; OUT_573], ExecError> { +) -> Result<[G; OUT_569], ExecError> { stacker::maybe_grow(64 * 1024, 4 * 1024 * 1024, || { let __v_0: G = inp[0]; let __v_1: G = inp[1]; @@ -49259,26 +48975,26 @@ fn aiur_fn_573( let __v_49: G = G::from_u64(1); let __v_50: G = G::from_u64(1); let __v_51: G = { let __values: [G; 3] = [__v_49, __v_50, __v_50]; let __mq = record.memory_queries.get_mut(&3).ok_or(ExecError::InvalidMemorySize(3))?; if let Some(result) = __mq.get_mut(&__values[..]) { if !unconstrained { *result.multiplicity += G::ONE; } result.output[0] } else { let __ptr = G::from_usize(__mq.len()); __mq.insert(&__values[..], &[__ptr], G::from_bool(!unconstrained)); __ptr } }; - let __ret: [G; OUT_573] = [__v_51]; - if let Some(result) = record.function_queries[573].get_mut(&inp[..]) { debug_assert_eq!(result.output, &__ret[..]); if !unconstrained { *result.multiplicity += G::ONE; } } else { record.function_queries[573].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained)); }; + let __ret: [G; OUT_569] = [__v_51]; + if let Some(result) = record.function_queries[569].get_mut(&inp[..]) { debug_assert_eq!(result.output, &__ret[..]); if !unconstrained { *result.multiplicity += G::ONE; } } else { record.function_queries[569].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained)); }; return Ok(__ret); }, 0u64 => { let __v_49: G = G::from_u64(1); let __v_50: G = (__v_1 + __v_49); - let __r_arr: [G; OUT_573] = { let __args: [G; IN_573] = [__v_48, __v_50]; let __cu = unconstrained; if let Some(result) = record.function_queries[573].get_mut(&__args[..]) { if !__cu && *result.multiplicity == G::ZERO { aiur_fn_573(__args, record, io_buffer, false)? } else { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_573] = unsafe { *(result.output.as_ptr() as *const [G; OUT_573]) }; __ret } } else { aiur_fn_573(__args, record, io_buffer, __cu)? } }; + let __r_arr: [G; OUT_569] = { let __args: [G; IN_569] = [__v_48, __v_50]; let __cu = unconstrained; if let Some(result) = record.function_queries[569].get_mut(&__args[..]) { if !__cu && *result.multiplicity == G::ZERO { aiur_fn_569(__args, record, io_buffer, false)? } else { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_569] = unsafe { *(result.output.as_ptr() as *const [G; OUT_569]) }; __ret } } else { aiur_fn_569(__args, record, io_buffer, __cu)? } }; let __v_51: G = __r_arr[0]; match __v_3.as_canonical_u64() { 1u64 => { let __v_52: G = G::from_u64(0); let __v_53: G = { let __values: [G; 3] = [__v_52, __v_1, __v_51]; let __mq = record.memory_queries.get_mut(&3).ok_or(ExecError::InvalidMemorySize(3))?; if let Some(result) = __mq.get_mut(&__values[..]) { if !unconstrained { *result.multiplicity += G::ONE; } result.output[0] } else { let __ptr = G::from_usize(__mq.len()); __mq.insert(&__values[..], &[__ptr], G::from_bool(!unconstrained)); __ptr } }; - let __ret: [G; OUT_573] = [__v_53]; - if let Some(result) = record.function_queries[573].get_mut(&inp[..]) { debug_assert_eq!(result.output, &__ret[..]); if !unconstrained { *result.multiplicity += G::ONE; } } else { record.function_queries[573].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained)); }; + let __ret: [G; OUT_569] = [__v_53]; + if let Some(result) = record.function_queries[569].get_mut(&inp[..]) { debug_assert_eq!(result.output, &__ret[..]); if !unconstrained { *result.multiplicity += G::ONE; } } else { record.function_queries[569].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained)); }; return Ok(__ret); }, _ => { - let __ret: [G; OUT_573] = [__v_51]; - if let Some(result) = record.function_queries[573].get_mut(&inp[..]) { debug_assert_eq!(result.output, &__ret[..]); if !unconstrained { *result.multiplicity += G::ONE; } } else { record.function_queries[573].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained)); }; + let __ret: [G; OUT_569] = [__v_51]; + if let Some(result) = record.function_queries[569].get_mut(&inp[..]) { debug_assert_eq!(result.output, &__ret[..]); if !unconstrained { *result.multiplicity += G::ONE; } } else { record.function_queries[569].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained)); }; return Ok(__ret); }, } @@ -49290,15 +49006,15 @@ fn aiur_fn_573( }) } -const INPUT_SIZE_574: usize = 2; -const IN_574: usize = 2; -const OUT_574: usize = 1; -fn aiur_fn_574( - inp: [G; IN_574], +const INPUT_SIZE_570: usize = 2; +const IN_570: usize = 2; +const OUT_570: usize = 1; +fn aiur_fn_570( + inp: [G; IN_570], record: &mut QueryRecord, io_buffer: &mut IOBuffer, unconstrained: bool, -) -> Result<[G; OUT_574], ExecError> { +) -> Result<[G; OUT_570], ExecError> { stacker::maybe_grow(64 * 1024, 4 * 1024 * 1024, || { let __v_0: G = inp[0]; let __v_1: G = inp[1]; @@ -49353,8 +49069,8 @@ fn aiur_fn_574( match __v_2.as_canonical_u64() { 1u64 => { let __v_49: G = G::from_u64(0); - let __ret: [G; OUT_574] = [__v_49]; - if let Some(result) = record.function_queries[574].get_mut(&inp[..]) { debug_assert_eq!(result.output, &__ret[..]); if !unconstrained { *result.multiplicity += G::ONE; } } else { record.function_queries[574].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained)); }; + let __ret: [G; OUT_570] = [__v_49]; + if let Some(result) = record.function_queries[570].get_mut(&inp[..]) { debug_assert_eq!(result.output, &__ret[..]); if !unconstrained { *result.multiplicity += G::ONE; } } else { record.function_queries[570].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained)); }; return Ok(__ret); }, 0u64 => { @@ -49380,15 +49096,15 @@ fn aiur_fn_574( match __v_49.as_canonical_u64() { 1u64 => { let __v_50: G = G::from_u64(1); - let __ret: [G; OUT_574] = [__v_50]; - if let Some(result) = record.function_queries[574].get_mut(&inp[..]) { debug_assert_eq!(result.output, &__ret[..]); if !unconstrained { *result.multiplicity += G::ONE; } } else { record.function_queries[574].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained)); }; + let __ret: [G; OUT_570] = [__v_50]; + if let Some(result) = record.function_queries[570].get_mut(&inp[..]) { debug_assert_eq!(result.output, &__ret[..]); if !unconstrained { *result.multiplicity += G::ONE; } } else { record.function_queries[570].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained)); }; return Ok(__ret); }, _ => { - let __r_arr: [G; OUT_574] = { let __args: [G; IN_574] = [__v_48, __v_1]; let __cu = unconstrained; if let Some(result) = record.function_queries[574].get_mut(&__args[..]) { if !__cu && *result.multiplicity == G::ZERO { aiur_fn_574(__args, record, io_buffer, false)? } else { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_574] = unsafe { *(result.output.as_ptr() as *const [G; OUT_574]) }; __ret } } else { aiur_fn_574(__args, record, io_buffer, __cu)? } }; + let __r_arr: [G; OUT_570] = { let __args: [G; IN_570] = [__v_48, __v_1]; let __cu = unconstrained; if let Some(result) = record.function_queries[570].get_mut(&__args[..]) { if !__cu && *result.multiplicity == G::ZERO { aiur_fn_570(__args, record, io_buffer, false)? } else { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_570] = unsafe { *(result.output.as_ptr() as *const [G; OUT_570]) }; __ret } } else { aiur_fn_570(__args, record, io_buffer, __cu)? } }; let __v_50: G = __r_arr[0]; - let __ret: [G; OUT_574] = [__v_50]; - if let Some(result) = record.function_queries[574].get_mut(&inp[..]) { debug_assert_eq!(result.output, &__ret[..]); if !unconstrained { *result.multiplicity += G::ONE; } } else { record.function_queries[574].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained)); }; + let __ret: [G; OUT_570] = [__v_50]; + if let Some(result) = record.function_queries[570].get_mut(&inp[..]) { debug_assert_eq!(result.output, &__ret[..]); if !unconstrained { *result.multiplicity += G::ONE; } } else { record.function_queries[570].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained)); }; return Ok(__ret); }, } @@ -49400,18 +49116,18 @@ fn aiur_fn_574( }) } -const INPUT_SIZE_575: usize = 1; -const IN_575: usize = 1; -const OUT_575: usize = 0; -fn aiur_fn_575( - inp: [G; IN_575], +const INPUT_SIZE_571: usize = 1; +const IN_571: usize = 1; +const OUT_571: usize = 0; +fn aiur_fn_571( + inp: [G; IN_571], record: &mut QueryRecord, io_buffer: &mut IOBuffer, unconstrained: bool, -) -> Result<[G; OUT_575], ExecError> { +) -> Result<[G; OUT_571], ExecError> { stacker::maybe_grow(64 * 1024, 4 * 1024 * 1024, || { let __v_0: G = inp[0]; - let __r_arr: [G; OUT_282] = { let __args: [G; IN_282] = [__v_0]; let __cu = unconstrained; if let Some(result) = record.function_queries[282].get_mut(&__args[..]) { if !__cu && *result.multiplicity == G::ZERO { aiur_fn_282(__args, record, io_buffer, false)? } else { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_282] = unsafe { *(result.output.as_ptr() as *const [G; OUT_282]) }; __ret } } else { aiur_fn_282(__args, record, io_buffer, __cu)? } }; + let __r_arr: [G; OUT_278] = { let __args: [G; IN_278] = [__v_0]; let __cu = unconstrained; if let Some(result) = record.function_queries[278].get_mut(&__args[..]) { if !__cu && *result.multiplicity == G::ZERO { aiur_fn_278(__args, record, io_buffer, false)? } else { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_278] = unsafe { *(result.output.as_ptr() as *const [G; OUT_278]) }; __ret } } else { aiur_fn_278(__args, record, io_buffer, __cu)? } }; let __v_1: G = __r_arr[0]; let __v_2: G = __r_arr[1]; let __v_3: G = __r_arr[2]; @@ -49465,31 +49181,31 @@ fn aiur_fn_575( match __v_1.as_canonical_u64() { 8u64 => { let __v_49: G = G::from_u64(0); - let __r_arr: [G; OUT_573] = { let __args: [G; IN_573] = [__v_2, __v_49]; let __cu = unconstrained; if let Some(result) = record.function_queries[573].get_mut(&__args[..]) { if !__cu && *result.multiplicity == G::ZERO { aiur_fn_573(__args, record, io_buffer, false)? } else { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_573] = unsafe { *(result.output.as_ptr() as *const [G; OUT_573]) }; __ret } } else { aiur_fn_573(__args, record, io_buffer, __cu)? } }; + let __r_arr: [G; OUT_569] = { let __args: [G; IN_569] = [__v_2, __v_49]; let __cu = unconstrained; if let Some(result) = record.function_queries[569].get_mut(&__args[..]) { if !__cu && *result.multiplicity == G::ZERO { aiur_fn_569(__args, record, io_buffer, false)? } else { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_569] = unsafe { *(result.output.as_ptr() as *const [G; OUT_569]) }; __ret } } else { aiur_fn_569(__args, record, io_buffer, __cu)? } }; let __v_50: G = __r_arr[0]; let __v_51: G = G::from_u64(1); - let __r_arr: [G; OUT_574] = { let __args: [G; IN_574] = [__v_2, __v_51]; let __cu = unconstrained; if let Some(result) = record.function_queries[574].get_mut(&__args[..]) { if !__cu && *result.multiplicity == G::ZERO { aiur_fn_574(__args, record, io_buffer, false)? } else { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_574] = unsafe { *(result.output.as_ptr() as *const [G; OUT_574]) }; __ret } } else { aiur_fn_574(__args, record, io_buffer, __cu)? } }; + let __r_arr: [G; OUT_570] = { let __args: [G; IN_570] = [__v_2, __v_51]; let __cu = unconstrained; if let Some(result) = record.function_queries[570].get_mut(&__args[..]) { if !__cu && *result.multiplicity == G::ZERO { aiur_fn_570(__args, record, io_buffer, false)? } else { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_570] = unsafe { *(result.output.as_ptr() as *const [G; OUT_570]) }; __ret } } else { aiur_fn_570(__args, record, io_buffer, __cu)? } }; let __v_52: G = __r_arr[0]; let __v_53: G = G::from_u64(0); - let __r_arr: [G; OUT_574] = { let __args: [G; IN_574] = [__v_2, __v_53]; let __cu = unconstrained; if let Some(result) = record.function_queries[574].get_mut(&__args[..]) { if !__cu && *result.multiplicity == G::ZERO { aiur_fn_574(__args, record, io_buffer, false)? } else { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_574] = unsafe { *(result.output.as_ptr() as *const [G; OUT_574]) }; __ret } } else { aiur_fn_574(__args, record, io_buffer, __cu)? } }; + let __r_arr: [G; OUT_570] = { let __args: [G; IN_570] = [__v_2, __v_53]; let __cu = unconstrained; if let Some(result) = record.function_queries[570].get_mut(&__args[..]) { if !__cu && *result.multiplicity == G::ZERO { aiur_fn_570(__args, record, io_buffer, false)? } else { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_570] = unsafe { *(result.output.as_ptr() as *const [G; OUT_570]) }; __ret } } else { aiur_fn_570(__args, record, io_buffer, __cu)? } }; let __v_54: G = __r_arr[0]; let __v_55: G = (__v_52 * __v_54); let __v_56: G = G::from_u64(0); if (__v_55 != __v_56) { return Err(ExecError::AssertEqMismatch { lhs: __v_55.as_canonical_u64(), rhs: __v_56.as_canonical_u64(), msg: Some("mutual block mixes a definition member with inductives".to_string()) }); } - let __r_arr: [G; OUT_764] = { let __args: [G; IN_764] = [__v_50]; let __cu = unconstrained; if let Some(result) = record.function_queries[764].get_mut(&__args[..]) { if !__cu && *result.multiplicity == G::ZERO { aiur_fn_764(__args, record, io_buffer, false)? } else { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_764] = unsafe { *(result.output.as_ptr() as *const [G; OUT_764]) }; __ret } } else { aiur_fn_764(__args, record, io_buffer, __cu)? } }; + let __r_arr: [G; OUT_760] = { let __args: [G; IN_760] = [__v_50]; let __cu = unconstrained; if let Some(result) = record.function_queries[760].get_mut(&__args[..]) { if !__cu && *result.multiplicity == G::ZERO { aiur_fn_760(__args, record, io_buffer, false)? } else { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_760] = unsafe { *(result.output.as_ptr() as *const [G; OUT_760]) }; __ret } } else { aiur_fn_760(__args, record, io_buffer, __cu)? } }; let __v_57: G = __r_arr[0]; let __v_58: G = G::from_u64(2); let __v_59: G = { let __a_val = __v_57.as_canonical_u64(); let __b_val = __v_58.as_canonical_u64(); let __a_u32 = u32::try_from(__a_val).ok().ok_or(ExecError::U32OutOfRange(__a_val))?; let __b_u32 = u32::try_from(__b_val).ok().ok_or(ExecError::U32OutOfRange(__b_val))?; let __result = G::from_bool(__a_u32 < __b_u32); if !unconstrained { let __x_bytes = __a_u32.to_le_bytes(); let __z_bytes = __b_u32.to_le_bytes(); let __c_u32 = __b_u32.wrapping_sub(__a_u32).wrapping_sub(1); let __y_bytes = __c_u32.to_le_bytes(); record.bytes2_queries.bump_range_check(&G::from_u8(__x_bytes[0]), &G::from_u8(__x_bytes[1])); record.bytes2_queries.bump_range_check(&G::from_u8(__x_bytes[2]), &G::from_u8(__x_bytes[3])); record.bytes2_queries.bump_range_check(&G::from_u8(__y_bytes[0]), &G::from_u8(__y_bytes[1])); record.bytes2_queries.bump_range_check(&G::from_u8(__y_bytes[2]), &G::from_u8(__y_bytes[3])); record.bytes2_queries.bump_range_check(&G::from_u8(__z_bytes[0]), &G::from_u8(__z_bytes[1])); record.bytes2_queries.bump_range_check(&G::from_u8(__z_bytes[2]), &G::from_u8(__z_bytes[3])); } __result }; match __v_59.as_canonical_u64() { 1u64 => { - let __ret: [G; OUT_575] = []; - if let Some(result) = record.function_queries[575].get_mut(&inp[..]) { debug_assert_eq!(result.output, &__ret[..]); if !unconstrained { *result.multiplicity += G::ONE; } } else { record.function_queries[575].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained)); }; + let __ret: [G; OUT_571] = []; + if let Some(result) = record.function_queries[571].get_mut(&inp[..]) { debug_assert_eq!(result.output, &__ret[..]); if !unconstrained { *result.multiplicity += G::ONE; } } else { record.function_queries[571].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained)); }; return Ok(__ret); }, _ => { - let __r_arr: [G; OUT_295] = { let __args: [G; IN_295] = [__v_2, __v_0]; let __cu = unconstrained; if let Some(result) = record.function_queries[295].get_mut(&__args[..]) { if !__cu && *result.multiplicity == G::ZERO { aiur_fn_295(__args, record, io_buffer, false)? } else { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_295] = unsafe { *(result.output.as_ptr() as *const [G; OUT_295]) }; __ret } } else { aiur_fn_295(__args, record, io_buffer, __cu)? } }; + let __r_arr: [G; OUT_291] = { let __args: [G; IN_291] = [__v_2, __v_0]; let __cu = unconstrained; if let Some(result) = record.function_queries[291].get_mut(&__args[..]) { if !__cu && *result.multiplicity == G::ZERO { aiur_fn_291(__args, record, io_buffer, false)? } else { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_291] = unsafe { *(result.output.as_ptr() as *const [G; OUT_291]) }; __ret } } else { aiur_fn_291(__args, record, io_buffer, __cu)? } }; let __v_60: G = __r_arr[0]; let __v_61: G = G::from_u64(0); let __v_62: G = G::from_u64(1); @@ -49497,34 +49213,34 @@ fn aiur_fn_575( let __v_64: G = { let __values: [G; 3] = [__v_62, __v_63, __v_63]; let __mq = record.memory_queries.get_mut(&3).ok_or(ExecError::InvalidMemorySize(3))?; if let Some(result) = __mq.get_mut(&__values[..]) { if !unconstrained { *result.multiplicity += G::ONE; } result.output[0] } else { let __ptr = G::from_usize(__mq.len()); __mq.insert(&__values[..], &[__ptr], G::from_bool(!unconstrained)); __ptr } }; let __v_65: G = { let __values: [G; 3] = [__v_61, __v_50, __v_64]; let __mq = record.memory_queries.get_mut(&3).ok_or(ExecError::InvalidMemorySize(3))?; if let Some(result) = __mq.get_mut(&__values[..]) { if !unconstrained { *result.multiplicity += G::ONE; } result.output[0] } else { let __ptr = G::from_usize(__mq.len()); __mq.insert(&__values[..], &[__ptr], G::from_bool(!unconstrained)); __ptr } }; let __v_66: G = G::from_u64(1); - let __r_arr: [G; OUT_764] = { let __args: [G; IN_764] = [__v_50]; let __cu = unconstrained; if let Some(result) = record.function_queries[764].get_mut(&__args[..]) { if !__cu && *result.multiplicity == G::ZERO { aiur_fn_764(__args, record, io_buffer, false)? } else { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_764] = unsafe { *(result.output.as_ptr() as *const [G; OUT_764]) }; __ret } } else { aiur_fn_764(__args, record, io_buffer, __cu)? } }; + let __r_arr: [G; OUT_760] = { let __args: [G; IN_760] = [__v_50]; let __cu = unconstrained; if let Some(result) = record.function_queries[760].get_mut(&__args[..]) { if !__cu && *result.multiplicity == G::ZERO { aiur_fn_760(__args, record, io_buffer, false)? } else { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_760] = unsafe { *(result.output.as_ptr() as *const [G; OUT_760]) }; __ret } } else { aiur_fn_760(__args, record, io_buffer, __cu)? } }; let __v_67: G = __r_arr[0]; let __v_68: G = (__v_66 + __v_67); - let __r_arr: [G; OUT_563] = { let __args: [G; IN_563] = [__v_65, __v_60, __v_0, __v_68]; let __cu = unconstrained; if let Some(result) = record.function_queries[563].get_mut(&__args[..]) { if !__cu && *result.multiplicity == G::ZERO { aiur_fn_563(__args, record, io_buffer, false)? } else { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_563] = unsafe { *(result.output.as_ptr() as *const [G; OUT_563]) }; __ret } } else { aiur_fn_563(__args, record, io_buffer, __cu)? } }; + let __r_arr: [G; OUT_559] = { let __args: [G; IN_559] = [__v_65, __v_60, __v_0, __v_68]; let __cu = unconstrained; if let Some(result) = record.function_queries[559].get_mut(&__args[..]) { if !__cu && *result.multiplicity == G::ZERO { aiur_fn_559(__args, record, io_buffer, false)? } else { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_559] = unsafe { *(result.output.as_ptr() as *const [G; OUT_559]) }; __ret } } else { aiur_fn_559(__args, record, io_buffer, __cu)? } }; let __v_69: G = __r_arr[0]; - let __r_arr: [G; OUT_572] = { let __args: [G; IN_572] = [__v_69]; let __cu = unconstrained; if let Some(result) = record.function_queries[572].get_mut(&__args[..]) { if !__cu && *result.multiplicity == G::ZERO { aiur_fn_572(__args, record, io_buffer, false)? } else { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_572] = unsafe { *(result.output.as_ptr() as *const [G; OUT_572]) }; __ret } } else { aiur_fn_572(__args, record, io_buffer, __cu)? } }; + let __r_arr: [G; OUT_568] = { let __args: [G; IN_568] = [__v_69]; let __cu = unconstrained; if let Some(result) = record.function_queries[568].get_mut(&__args[..]) { if !__cu && *result.multiplicity == G::ZERO { aiur_fn_568(__args, record, io_buffer, false)? } else { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_568] = unsafe { *(result.output.as_ptr() as *const [G; OUT_568]) }; __ret } } else { aiur_fn_568(__args, record, io_buffer, __cu)? } }; let __v_70: G = __r_arr[0]; let __v_71: G = G::from_u64(1); if (__v_70 != __v_71) { return Err(ExecError::AssertEqMismatch { lhs: __v_70.as_canonical_u64(), rhs: __v_71.as_canonical_u64(), msg: Some("canonical block: refinement left members tied, order ambiguous".to_string()) }); } - let __r_arr: [G; OUT_571] = { let __args: [G; IN_571] = [__v_69]; let __cu = unconstrained; if let Some(result) = record.function_queries[571].get_mut(&__args[..]) { if !__cu && *result.multiplicity == G::ZERO { aiur_fn_571(__args, record, io_buffer, false)? } else { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_571] = unsafe { *(result.output.as_ptr() as *const [G; OUT_571]) }; __ret } } else { aiur_fn_571(__args, record, io_buffer, __cu)? } }; + let __r_arr: [G; OUT_567] = { let __args: [G; IN_567] = [__v_69]; let __cu = unconstrained; if let Some(result) = record.function_queries[567].get_mut(&__args[..]) { if !__cu && *result.multiplicity == G::ZERO { aiur_fn_567(__args, record, io_buffer, false)? } else { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_567] = unsafe { *(result.output.as_ptr() as *const [G; OUT_567]) }; __ret } } else { aiur_fn_567(__args, record, io_buffer, __cu)? } }; let __v_72: G = __r_arr[0]; - let __r_arr: [G; OUT_339] = { let __args: [G; IN_339] = [__v_72, __v_50]; let __cu = unconstrained; if let Some(result) = record.function_queries[339].get_mut(&__args[..]) { if !__cu && *result.multiplicity == G::ZERO { aiur_fn_339(__args, record, io_buffer, false)? } else { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_339] = unsafe { *(result.output.as_ptr() as *const [G; OUT_339]) }; __ret } } else { aiur_fn_339(__args, record, io_buffer, __cu)? } }; + let __r_arr: [G; OUT_335] = { let __args: [G; IN_335] = [__v_72, __v_50]; let __cu = unconstrained; if let Some(result) = record.function_queries[335].get_mut(&__args[..]) { if !__cu && *result.multiplicity == G::ZERO { aiur_fn_335(__args, record, io_buffer, false)? } else { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_335] = unsafe { *(result.output.as_ptr() as *const [G; OUT_335]) }; __ret } } else { aiur_fn_335(__args, record, io_buffer, __cu)? } }; let __v_73: G = __r_arr[0]; let __v_74: G = G::from_u64(1); if (__v_73 != __v_74) { return Err(ExecError::AssertEqMismatch { lhs: __v_73.as_canonical_u64(), rhs: __v_74.as_canonical_u64(), msg: Some("canonical block: members are not in canonical order".to_string()) }); } - let __ret: [G; OUT_575] = []; - if let Some(result) = record.function_queries[575].get_mut(&inp[..]) { debug_assert_eq!(result.output, &__ret[..]); if !unconstrained { *result.multiplicity += G::ONE; } } else { record.function_queries[575].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained)); }; + let __ret: [G; OUT_571] = []; + if let Some(result) = record.function_queries[571].get_mut(&inp[..]) { debug_assert_eq!(result.output, &__ret[..]); if !unconstrained { *result.multiplicity += G::ONE; } } else { record.function_queries[571].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained)); }; return Ok(__ret); }, } }, _ => { - let __ret: [G; OUT_575] = []; - if let Some(result) = record.function_queries[575].get_mut(&inp[..]) { debug_assert_eq!(result.output, &__ret[..]); if !unconstrained { *result.multiplicity += G::ONE; } } else { record.function_queries[575].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained)); }; + let __ret: [G; OUT_571] = []; + if let Some(result) = record.function_queries[571].get_mut(&inp[..]) { debug_assert_eq!(result.output, &__ret[..]); if !unconstrained { *result.multiplicity += G::ONE; } } else { record.function_queries[571].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained)); }; return Ok(__ret); }, } @@ -49533,15 +49249,15 @@ fn aiur_fn_575( }) } -const INPUT_SIZE_576: usize = 12; -const IN_576: usize = 12; -const OUT_576: usize = 1; -fn aiur_fn_576( - inp: [G; IN_576], +const INPUT_SIZE_572: usize = 12; +const IN_572: usize = 12; +const OUT_572: usize = 1; +fn aiur_fn_572( + inp: [G; IN_572], record: &mut QueryRecord, io_buffer: &mut IOBuffer, unconstrained: bool, -) -> Result<[G; OUT_576], ExecError> { +) -> Result<[G; OUT_572], ExecError> { stacker::maybe_grow(64 * 1024, 4 * 1024 * 1024, || { let __v_0: G = inp[0]; let __v_1: G = inp[1]; @@ -49557,56 +49273,56 @@ fn aiur_fn_576( let __v_11: G = inp[11]; match __v_0.as_canonical_u64() { 0u64 => { - let __ret: [G; OUT_576] = [__v_3]; - if let Some(result) = record.function_queries[576].get_mut(&inp[..]) { debug_assert_eq!(result.output, &__ret[..]); if !unconstrained { *result.multiplicity += G::ONE; } } else { record.function_queries[576].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained)); }; + let __ret: [G; OUT_572] = [__v_3]; + if let Some(result) = record.function_queries[572].get_mut(&inp[..]) { debug_assert_eq!(result.output, &__ret[..]); if !unconstrained { *result.multiplicity += G::ONE; } } else { record.function_queries[572].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained)); }; return Ok(__ret); }, 1u64 => { match __v_4.as_canonical_u64() { 1u64 => { let __v_12: G = G::from_u64(0); - let __ret: [G; OUT_576] = [__v_12]; - if let Some(result) = record.function_queries[576].get_mut(&inp[..]) { debug_assert_eq!(result.output, &__ret[..]); if !unconstrained { *result.multiplicity += G::ONE; } } else { record.function_queries[576].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained)); }; + let __ret: [G; OUT_572] = [__v_12]; + if let Some(result) = record.function_queries[572].get_mut(&inp[..]) { debug_assert_eq!(result.output, &__ret[..]); if !unconstrained { *result.multiplicity += G::ONE; } } else { record.function_queries[572].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained)); }; return Ok(__ret); }, _ => { let __v_12: G = G::from_u64(1); - let __ret: [G; OUT_576] = [__v_12]; - if let Some(result) = record.function_queries[576].get_mut(&inp[..]) { debug_assert_eq!(result.output, &__ret[..]); if !unconstrained { *result.multiplicity += G::ONE; } } else { record.function_queries[576].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained)); }; + let __ret: [G; OUT_572] = [__v_12]; + if let Some(result) = record.function_queries[572].get_mut(&inp[..]) { debug_assert_eq!(result.output, &__ret[..]); if !unconstrained { *result.multiplicity += G::ONE; } } else { record.function_queries[572].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained)); }; return Ok(__ret); }, } }, 2u64 => { let __v_12: G = G::from_u64(0); - let __ret: [G; OUT_576] = [__v_12]; - if let Some(result) = record.function_queries[576].get_mut(&inp[..]) { debug_assert_eq!(result.output, &__ret[..]); if !unconstrained { *result.multiplicity += G::ONE; } } else { record.function_queries[576].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained)); }; + let __ret: [G; OUT_572] = [__v_12]; + if let Some(result) = record.function_queries[572].get_mut(&inp[..]) { debug_assert_eq!(result.output, &__ret[..]); if !unconstrained { *result.multiplicity += G::ONE; } } else { record.function_queries[572].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained)); }; return Ok(__ret); }, 3u64 => { - let __ret: [G; OUT_576] = [__v_4]; - if let Some(result) = record.function_queries[576].get_mut(&inp[..]) { debug_assert_eq!(result.output, &__ret[..]); if !unconstrained { *result.multiplicity += G::ONE; } } else { record.function_queries[576].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained)); }; + let __ret: [G; OUT_572] = [__v_4]; + if let Some(result) = record.function_queries[572].get_mut(&inp[..]) { debug_assert_eq!(result.output, &__ret[..]); if !unconstrained { *result.multiplicity += G::ONE; } } else { record.function_queries[572].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained)); }; return Ok(__ret); }, 4u64 => { let __v_12: G = G::from_u64(0); - let __ret: [G; OUT_576] = [__v_12]; - if let Some(result) = record.function_queries[576].get_mut(&inp[..]) { debug_assert_eq!(result.output, &__ret[..]); if !unconstrained { *result.multiplicity += G::ONE; } } else { record.function_queries[576].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained)); }; + let __ret: [G; OUT_572] = [__v_12]; + if let Some(result) = record.function_queries[572].get_mut(&inp[..]) { debug_assert_eq!(result.output, &__ret[..]); if !unconstrained { *result.multiplicity += G::ONE; } } else { record.function_queries[572].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained)); }; return Ok(__ret); }, 5u64 => { - let __ret: [G; OUT_576] = [__v_6]; - if let Some(result) = record.function_queries[576].get_mut(&inp[..]) { debug_assert_eq!(result.output, &__ret[..]); if !unconstrained { *result.multiplicity += G::ONE; } } else { record.function_queries[576].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained)); }; + let __ret: [G; OUT_572] = [__v_6]; + if let Some(result) = record.function_queries[572].get_mut(&inp[..]) { debug_assert_eq!(result.output, &__ret[..]); if !unconstrained { *result.multiplicity += G::ONE; } } else { record.function_queries[572].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained)); }; return Ok(__ret); }, 6u64 => { - let __ret: [G; OUT_576] = [__v_8]; - if let Some(result) = record.function_queries[576].get_mut(&inp[..]) { debug_assert_eq!(result.output, &__ret[..]); if !unconstrained { *result.multiplicity += G::ONE; } } else { record.function_queries[576].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained)); }; + let __ret: [G; OUT_572] = [__v_8]; + if let Some(result) = record.function_queries[572].get_mut(&inp[..]) { debug_assert_eq!(result.output, &__ret[..]); if !unconstrained { *result.multiplicity += G::ONE; } } else { record.function_queries[572].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained)); }; return Ok(__ret); }, 7u64 => { - let __ret: [G; OUT_576] = [__v_9]; - if let Some(result) = record.function_queries[576].get_mut(&inp[..]) { debug_assert_eq!(result.output, &__ret[..]); if !unconstrained { *result.multiplicity += G::ONE; } } else { record.function_queries[576].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained)); }; + let __ret: [G; OUT_572] = [__v_9]; + if let Some(result) = record.function_queries[572].get_mut(&inp[..]) { debug_assert_eq!(result.output, &__ret[..]); if !unconstrained { *result.multiplicity += G::ONE; } } else { record.function_queries[572].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained)); }; return Ok(__ret); }, _ => { @@ -49616,15 +49332,15 @@ fn aiur_fn_576( }) } -const INPUT_SIZE_577: usize = 1; -const IN_577: usize = 1; -const OUT_577: usize = 1; -fn aiur_fn_577( - inp: [G; IN_577], +const INPUT_SIZE_573: usize = 1; +const IN_573: usize = 1; +const OUT_573: usize = 1; +fn aiur_fn_573( + inp: [G; IN_573], record: &mut QueryRecord, io_buffer: &mut IOBuffer, unconstrained: bool, -) -> Result<[G; OUT_577], ExecError> { +) -> Result<[G; OUT_573], ExecError> { stacker::maybe_grow(64 * 1024, 4 * 1024 * 1024, || { let __v_0: G = inp[0]; let __loaded: [G; 4] = { let __mq = record.memory_queries.get_mut(&4).ok_or(ExecError::InvalidMemorySize(4))?; let __ptr_u64 = __v_0.as_canonical_u64(); let __ptr_usize = usize::try_from(__ptr_u64).ok().ok_or(ExecError::PointerTooLarge(__ptr_u64))?; let (__args, __mult) = __mq.get_index_mut(__ptr_usize).ok_or(ExecError::UnboundPointer { ptr: __ptr_u64, size: 4 })?; if !unconstrained { *__mult += G::ONE; } let __arr: [G; 4] = __args[..4].try_into().unwrap(); __arr }; @@ -49635,18 +49351,18 @@ fn aiur_fn_577( match __v_1.as_canonical_u64() { 0u64 => { let __v_5: G = G::from_u64(1); - let __ret: [G; OUT_577] = [__v_5]; - if let Some(result) = record.function_queries[577].get_mut(&inp[..]) { debug_assert_eq!(result.output, &__ret[..]); if !unconstrained { *result.multiplicity += G::ONE; } } else { record.function_queries[577].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained)); }; + let __ret: [G; OUT_573] = [__v_5]; + if let Some(result) = record.function_queries[573].get_mut(&inp[..]) { debug_assert_eq!(result.output, &__ret[..]); if !unconstrained { *result.multiplicity += G::ONE; } } else { record.function_queries[573].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained)); }; return Ok(__ret); }, 1u64 => { let __v_5: G = G::from_u64(1); - let __ret: [G; OUT_577] = [__v_5]; - if let Some(result) = record.function_queries[577].get_mut(&inp[..]) { debug_assert_eq!(result.output, &__ret[..]); if !unconstrained { *result.multiplicity += G::ONE; } } else { record.function_queries[577].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained)); }; + let __ret: [G; OUT_573] = [__v_5]; + if let Some(result) = record.function_queries[573].get_mut(&inp[..]) { debug_assert_eq!(result.output, &__ret[..]); if !unconstrained { *result.multiplicity += G::ONE; } } else { record.function_queries[573].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained)); }; return Ok(__ret); }, 2u64 => { - let __r_arr: [G; OUT_287] = { let __args: [G; IN_287] = [__v_2]; let __cu = unconstrained; if let Some(result) = record.function_queries[287].get_mut(&__args[..]) { if !__cu && *result.multiplicity == G::ZERO { aiur_fn_287(__args, record, io_buffer, false)? } else { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_287] = unsafe { *(result.output.as_ptr() as *const [G; OUT_287]) }; __ret } } else { aiur_fn_287(__args, record, io_buffer, __cu)? } }; + let __r_arr: [G; OUT_283] = { let __args: [G; IN_283] = [__v_2]; let __cu = unconstrained; if let Some(result) = record.function_queries[283].get_mut(&__args[..]) { if !__cu && *result.multiplicity == G::ZERO { aiur_fn_283(__args, record, io_buffer, false)? } else { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_283] = unsafe { *(result.output.as_ptr() as *const [G; OUT_283]) }; __ret } } else { aiur_fn_283(__args, record, io_buffer, __cu)? } }; let __v_5: G = __r_arr[0]; let __loaded: [G; 12] = { let __mq = record.memory_queries.get_mut(&12).ok_or(ExecError::InvalidMemorySize(12))?; let __ptr_u64 = __v_5.as_canonical_u64(); let __ptr_usize = usize::try_from(__ptr_u64).ok().ok_or(ExecError::PointerTooLarge(__ptr_u64))?; let (__args, __mult) = __mq.get_index_mut(__ptr_usize).ok_or(ExecError::UnboundPointer { ptr: __ptr_u64, size: 12 })?; if !unconstrained { *__mult += G::ONE; } let __arr: [G; 12] = __args[..12].try_into().unwrap(); __arr }; let __v_6: G = __loaded[0]; @@ -49662,67 +49378,67 @@ fn aiur_fn_577( let __v_16: G = __loaded[10]; let __v_17: G = __loaded[11]; let __v_18: G = G::from_u64(1); - let __r_arr: [G; OUT_576] = { let __args: [G; IN_576] = [__v_6, __v_7, __v_8, __v_9, __v_10, __v_11, __v_12, __v_13, __v_14, __v_15, __v_16, __v_17]; let __cu = unconstrained; if let Some(result) = record.function_queries[576].get_mut(&__args[..]) { if !__cu && *result.multiplicity == G::ZERO { aiur_fn_576(__args, record, io_buffer, false)? } else { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_576] = unsafe { *(result.output.as_ptr() as *const [G; OUT_576]) }; __ret } } else { aiur_fn_576(__args, record, io_buffer, __cu)? } }; + let __r_arr: [G; OUT_572] = { let __args: [G; IN_572] = [__v_6, __v_7, __v_8, __v_9, __v_10, __v_11, __v_12, __v_13, __v_14, __v_15, __v_16, __v_17]; let __cu = unconstrained; if let Some(result) = record.function_queries[572].get_mut(&__args[..]) { if !__cu && *result.multiplicity == G::ZERO { aiur_fn_572(__args, record, io_buffer, false)? } else { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_572] = unsafe { *(result.output.as_ptr() as *const [G; OUT_572]) }; __ret } } else { aiur_fn_572(__args, record, io_buffer, __cu)? } }; let __v_19: G = __r_arr[0]; let __v_20: G = (__v_18 - __v_19); - let __ret: [G; OUT_577] = [__v_20]; - if let Some(result) = record.function_queries[577].get_mut(&inp[..]) { debug_assert_eq!(result.output, &__ret[..]); if !unconstrained { *result.multiplicity += G::ONE; } } else { record.function_queries[577].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained)); }; + let __ret: [G; OUT_573] = [__v_20]; + if let Some(result) = record.function_queries[573].get_mut(&inp[..]) { debug_assert_eq!(result.output, &__ret[..]); if !unconstrained { *result.multiplicity += G::ONE; } } else { record.function_queries[573].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained)); }; return Ok(__ret); }, 3u64 => { - let __r_arr: [G; OUT_577] = { let __args: [G; IN_577] = [__v_2]; let __cu = unconstrained; if let Some(result) = record.function_queries[577].get_mut(&__args[..]) { if !__cu && *result.multiplicity == G::ZERO { aiur_fn_577(__args, record, io_buffer, false)? } else { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_577] = unsafe { *(result.output.as_ptr() as *const [G; OUT_577]) }; __ret } } else { aiur_fn_577(__args, record, io_buffer, __cu)? } }; + let __r_arr: [G; OUT_573] = { let __args: [G; IN_573] = [__v_2]; let __cu = unconstrained; if let Some(result) = record.function_queries[573].get_mut(&__args[..]) { if !__cu && *result.multiplicity == G::ZERO { aiur_fn_573(__args, record, io_buffer, false)? } else { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_573] = unsafe { *(result.output.as_ptr() as *const [G; OUT_573]) }; __ret } } else { aiur_fn_573(__args, record, io_buffer, __cu)? } }; let __v_5: G = __r_arr[0]; - let __r_arr: [G; OUT_577] = { let __args: [G; IN_577] = [__v_3]; let __cu = unconstrained; if let Some(result) = record.function_queries[577].get_mut(&__args[..]) { if !__cu && *result.multiplicity == G::ZERO { aiur_fn_577(__args, record, io_buffer, false)? } else { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_577] = unsafe { *(result.output.as_ptr() as *const [G; OUT_577]) }; __ret } } else { aiur_fn_577(__args, record, io_buffer, __cu)? } }; + let __r_arr: [G; OUT_573] = { let __args: [G; IN_573] = [__v_3]; let __cu = unconstrained; if let Some(result) = record.function_queries[573].get_mut(&__args[..]) { if !__cu && *result.multiplicity == G::ZERO { aiur_fn_573(__args, record, io_buffer, false)? } else { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_573] = unsafe { *(result.output.as_ptr() as *const [G; OUT_573]) }; __ret } } else { aiur_fn_573(__args, record, io_buffer, __cu)? } }; let __v_6: G = __r_arr[0]; let __v_7: G = (__v_5 * __v_6); - let __ret: [G; OUT_577] = [__v_7]; - if let Some(result) = record.function_queries[577].get_mut(&inp[..]) { debug_assert_eq!(result.output, &__ret[..]); if !unconstrained { *result.multiplicity += G::ONE; } } else { record.function_queries[577].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained)); }; + let __ret: [G; OUT_573] = [__v_7]; + if let Some(result) = record.function_queries[573].get_mut(&inp[..]) { debug_assert_eq!(result.output, &__ret[..]); if !unconstrained { *result.multiplicity += G::ONE; } } else { record.function_queries[573].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained)); }; return Ok(__ret); }, 4u64 => { - let __r_arr: [G; OUT_577] = { let __args: [G; IN_577] = [__v_2]; let __cu = unconstrained; if let Some(result) = record.function_queries[577].get_mut(&__args[..]) { if !__cu && *result.multiplicity == G::ZERO { aiur_fn_577(__args, record, io_buffer, false)? } else { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_577] = unsafe { *(result.output.as_ptr() as *const [G; OUT_577]) }; __ret } } else { aiur_fn_577(__args, record, io_buffer, __cu)? } }; + let __r_arr: [G; OUT_573] = { let __args: [G; IN_573] = [__v_2]; let __cu = unconstrained; if let Some(result) = record.function_queries[573].get_mut(&__args[..]) { if !__cu && *result.multiplicity == G::ZERO { aiur_fn_573(__args, record, io_buffer, false)? } else { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_573] = unsafe { *(result.output.as_ptr() as *const [G; OUT_573]) }; __ret } } else { aiur_fn_573(__args, record, io_buffer, __cu)? } }; let __v_5: G = __r_arr[0]; - let __r_arr: [G; OUT_577] = { let __args: [G; IN_577] = [__v_3]; let __cu = unconstrained; if let Some(result) = record.function_queries[577].get_mut(&__args[..]) { if !__cu && *result.multiplicity == G::ZERO { aiur_fn_577(__args, record, io_buffer, false)? } else { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_577] = unsafe { *(result.output.as_ptr() as *const [G; OUT_577]) }; __ret } } else { aiur_fn_577(__args, record, io_buffer, __cu)? } }; + let __r_arr: [G; OUT_573] = { let __args: [G; IN_573] = [__v_3]; let __cu = unconstrained; if let Some(result) = record.function_queries[573].get_mut(&__args[..]) { if !__cu && *result.multiplicity == G::ZERO { aiur_fn_573(__args, record, io_buffer, false)? } else { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_573] = unsafe { *(result.output.as_ptr() as *const [G; OUT_573]) }; __ret } } else { aiur_fn_573(__args, record, io_buffer, __cu)? } }; let __v_6: G = __r_arr[0]; let __v_7: G = (__v_5 * __v_6); - let __ret: [G; OUT_577] = [__v_7]; - if let Some(result) = record.function_queries[577].get_mut(&inp[..]) { debug_assert_eq!(result.output, &__ret[..]); if !unconstrained { *result.multiplicity += G::ONE; } } else { record.function_queries[577].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained)); }; + let __ret: [G; OUT_573] = [__v_7]; + if let Some(result) = record.function_queries[573].get_mut(&inp[..]) { debug_assert_eq!(result.output, &__ret[..]); if !unconstrained { *result.multiplicity += G::ONE; } } else { record.function_queries[573].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained)); }; return Ok(__ret); }, 5u64 => { - let __r_arr: [G; OUT_577] = { let __args: [G; IN_577] = [__v_2]; let __cu = unconstrained; if let Some(result) = record.function_queries[577].get_mut(&__args[..]) { if !__cu && *result.multiplicity == G::ZERO { aiur_fn_577(__args, record, io_buffer, false)? } else { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_577] = unsafe { *(result.output.as_ptr() as *const [G; OUT_577]) }; __ret } } else { aiur_fn_577(__args, record, io_buffer, __cu)? } }; + let __r_arr: [G; OUT_573] = { let __args: [G; IN_573] = [__v_2]; let __cu = unconstrained; if let Some(result) = record.function_queries[573].get_mut(&__args[..]) { if !__cu && *result.multiplicity == G::ZERO { aiur_fn_573(__args, record, io_buffer, false)? } else { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_573] = unsafe { *(result.output.as_ptr() as *const [G; OUT_573]) }; __ret } } else { aiur_fn_573(__args, record, io_buffer, __cu)? } }; let __v_5: G = __r_arr[0]; - let __r_arr: [G; OUT_577] = { let __args: [G; IN_577] = [__v_3]; let __cu = unconstrained; if let Some(result) = record.function_queries[577].get_mut(&__args[..]) { if !__cu && *result.multiplicity == G::ZERO { aiur_fn_577(__args, record, io_buffer, false)? } else { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_577] = unsafe { *(result.output.as_ptr() as *const [G; OUT_577]) }; __ret } } else { aiur_fn_577(__args, record, io_buffer, __cu)? } }; + let __r_arr: [G; OUT_573] = { let __args: [G; IN_573] = [__v_3]; let __cu = unconstrained; if let Some(result) = record.function_queries[573].get_mut(&__args[..]) { if !__cu && *result.multiplicity == G::ZERO { aiur_fn_573(__args, record, io_buffer, false)? } else { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_573] = unsafe { *(result.output.as_ptr() as *const [G; OUT_573]) }; __ret } } else { aiur_fn_573(__args, record, io_buffer, __cu)? } }; let __v_6: G = __r_arr[0]; let __v_7: G = (__v_5 * __v_6); - let __ret: [G; OUT_577] = [__v_7]; - if let Some(result) = record.function_queries[577].get_mut(&inp[..]) { debug_assert_eq!(result.output, &__ret[..]); if !unconstrained { *result.multiplicity += G::ONE; } } else { record.function_queries[577].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained)); }; + let __ret: [G; OUT_573] = [__v_7]; + if let Some(result) = record.function_queries[573].get_mut(&inp[..]) { debug_assert_eq!(result.output, &__ret[..]); if !unconstrained { *result.multiplicity += G::ONE; } } else { record.function_queries[573].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained)); }; return Ok(__ret); }, 6u64 => { - let __r_arr: [G; OUT_577] = { let __args: [G; IN_577] = [__v_2]; let __cu = unconstrained; if let Some(result) = record.function_queries[577].get_mut(&__args[..]) { if !__cu && *result.multiplicity == G::ZERO { aiur_fn_577(__args, record, io_buffer, false)? } else { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_577] = unsafe { *(result.output.as_ptr() as *const [G; OUT_577]) }; __ret } } else { aiur_fn_577(__args, record, io_buffer, __cu)? } }; + let __r_arr: [G; OUT_573] = { let __args: [G; IN_573] = [__v_2]; let __cu = unconstrained; if let Some(result) = record.function_queries[573].get_mut(&__args[..]) { if !__cu && *result.multiplicity == G::ZERO { aiur_fn_573(__args, record, io_buffer, false)? } else { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_573] = unsafe { *(result.output.as_ptr() as *const [G; OUT_573]) }; __ret } } else { aiur_fn_573(__args, record, io_buffer, __cu)? } }; let __v_5: G = __r_arr[0]; - let __r_arr: [G; OUT_577] = { let __args: [G; IN_577] = [__v_3]; let __cu = unconstrained; if let Some(result) = record.function_queries[577].get_mut(&__args[..]) { if !__cu && *result.multiplicity == G::ZERO { aiur_fn_577(__args, record, io_buffer, false)? } else { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_577] = unsafe { *(result.output.as_ptr() as *const [G; OUT_577]) }; __ret } } else { aiur_fn_577(__args, record, io_buffer, __cu)? } }; + let __r_arr: [G; OUT_573] = { let __args: [G; IN_573] = [__v_3]; let __cu = unconstrained; if let Some(result) = record.function_queries[573].get_mut(&__args[..]) { if !__cu && *result.multiplicity == G::ZERO { aiur_fn_573(__args, record, io_buffer, false)? } else { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_573] = unsafe { *(result.output.as_ptr() as *const [G; OUT_573]) }; __ret } } else { aiur_fn_573(__args, record, io_buffer, __cu)? } }; let __v_6: G = __r_arr[0]; - let __r_arr: [G; OUT_577] = { let __args: [G; IN_577] = [__v_4]; let __cu = unconstrained; if let Some(result) = record.function_queries[577].get_mut(&__args[..]) { if !__cu && *result.multiplicity == G::ZERO { aiur_fn_577(__args, record, io_buffer, false)? } else { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_577] = unsafe { *(result.output.as_ptr() as *const [G; OUT_577]) }; __ret } } else { aiur_fn_577(__args, record, io_buffer, __cu)? } }; + let __r_arr: [G; OUT_573] = { let __args: [G; IN_573] = [__v_4]; let __cu = unconstrained; if let Some(result) = record.function_queries[573].get_mut(&__args[..]) { if !__cu && *result.multiplicity == G::ZERO { aiur_fn_573(__args, record, io_buffer, false)? } else { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_573] = unsafe { *(result.output.as_ptr() as *const [G; OUT_573]) }; __ret } } else { aiur_fn_573(__args, record, io_buffer, __cu)? } }; let __v_7: G = __r_arr[0]; let __v_8: G = (__v_6 * __v_7); let __v_9: G = (__v_5 * __v_8); - let __ret: [G; OUT_577] = [__v_9]; - if let Some(result) = record.function_queries[577].get_mut(&inp[..]) { debug_assert_eq!(result.output, &__ret[..]); if !unconstrained { *result.multiplicity += G::ONE; } } else { record.function_queries[577].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained)); }; + let __ret: [G; OUT_573] = [__v_9]; + if let Some(result) = record.function_queries[573].get_mut(&inp[..]) { debug_assert_eq!(result.output, &__ret[..]); if !unconstrained { *result.multiplicity += G::ONE; } } else { record.function_queries[573].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained)); }; return Ok(__ret); }, 7u64 => { let __v_5: G = G::from_u64(1); - let __ret: [G; OUT_577] = [__v_5]; - if let Some(result) = record.function_queries[577].get_mut(&inp[..]) { debug_assert_eq!(result.output, &__ret[..]); if !unconstrained { *result.multiplicity += G::ONE; } } else { record.function_queries[577].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained)); }; + let __ret: [G; OUT_573] = [__v_5]; + if let Some(result) = record.function_queries[573].get_mut(&inp[..]) { debug_assert_eq!(result.output, &__ret[..]); if !unconstrained { *result.multiplicity += G::ONE; } } else { record.function_queries[573].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained)); }; return Ok(__ret); }, 8u64 => { - let __r_arr: [G; OUT_577] = { let __args: [G; IN_577] = [__v_4]; let __cu = unconstrained; if let Some(result) = record.function_queries[577].get_mut(&__args[..]) { if !__cu && *result.multiplicity == G::ZERO { aiur_fn_577(__args, record, io_buffer, false)? } else { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_577] = unsafe { *(result.output.as_ptr() as *const [G; OUT_577]) }; __ret } } else { aiur_fn_577(__args, record, io_buffer, __cu)? } }; + let __r_arr: [G; OUT_573] = { let __args: [G; IN_573] = [__v_4]; let __cu = unconstrained; if let Some(result) = record.function_queries[573].get_mut(&__args[..]) { if !__cu && *result.multiplicity == G::ZERO { aiur_fn_573(__args, record, io_buffer, false)? } else { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_573] = unsafe { *(result.output.as_ptr() as *const [G; OUT_573]) }; __ret } } else { aiur_fn_573(__args, record, io_buffer, __cu)? } }; let __v_5: G = __r_arr[0]; - let __ret: [G; OUT_577] = [__v_5]; - if let Some(result) = record.function_queries[577].get_mut(&inp[..]) { debug_assert_eq!(result.output, &__ret[..]); if !unconstrained { *result.multiplicity += G::ONE; } } else { record.function_queries[577].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained)); }; + let __ret: [G; OUT_573] = [__v_5]; + if let Some(result) = record.function_queries[573].get_mut(&inp[..]) { debug_assert_eq!(result.output, &__ret[..]); if !unconstrained { *result.multiplicity += G::ONE; } } else { record.function_queries[573].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained)); }; return Ok(__ret); }, _ => { @@ -49732,48 +49448,48 @@ fn aiur_fn_577( }) } -const INPUT_SIZE_578: usize = 2; -const IN_578: usize = 2; -const OUT_578: usize = 0; -fn aiur_fn_578( - inp: [G; IN_578], +const INPUT_SIZE_574: usize = 2; +const IN_574: usize = 2; +const OUT_574: usize = 0; +fn aiur_fn_574( + inp: [G; IN_574], record: &mut QueryRecord, io_buffer: &mut IOBuffer, unconstrained: bool, -) -> Result<[G; OUT_578], ExecError> { +) -> Result<[G; OUT_574], ExecError> { stacker::maybe_grow(64 * 1024, 4 * 1024 * 1024, || { let __v_0: G = inp[0]; let __v_1: G = inp[1]; match __v_0.as_canonical_u64() { 1u64 => { - let __ret: [G; OUT_578] = []; - if let Some(result) = record.function_queries[578].get_mut(&inp[..]) { debug_assert_eq!(result.output, &__ret[..]); if !unconstrained { *result.multiplicity += G::ONE; } } else { record.function_queries[578].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained)); }; + let __ret: [G; OUT_574] = []; + if let Some(result) = record.function_queries[574].get_mut(&inp[..]) { debug_assert_eq!(result.output, &__ret[..]); if !unconstrained { *result.multiplicity += G::ONE; } } else { record.function_queries[574].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained)); }; return Ok(__ret); }, _ => { - let __r_arr: [G; OUT_577] = { let __args: [G; IN_577] = [__v_1]; let __cu = unconstrained; if let Some(result) = record.function_queries[577].get_mut(&__args[..]) { if !__cu && *result.multiplicity == G::ZERO { aiur_fn_577(__args, record, io_buffer, false)? } else { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_577] = unsafe { *(result.output.as_ptr() as *const [G; OUT_577]) }; __ret } } else { aiur_fn_577(__args, record, io_buffer, __cu)? } }; + let __r_arr: [G; OUT_573] = { let __args: [G; IN_573] = [__v_1]; let __cu = unconstrained; if let Some(result) = record.function_queries[573].get_mut(&__args[..]) { if !__cu && *result.multiplicity == G::ZERO { aiur_fn_573(__args, record, io_buffer, false)? } else { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_573] = unsafe { *(result.output.as_ptr() as *const [G; OUT_573]) }; __ret } } else { aiur_fn_573(__args, record, io_buffer, __cu)? } }; let __v_2: G = __r_arr[0]; let __v_3: G = G::from_u64(1); if (__v_2 != __v_3) { return Err(ExecError::AssertEqMismatch { lhs: __v_2.as_canonical_u64(), rhs: __v_3.as_canonical_u64(), msg: Some("safe constant references an unsafe constant".to_string()) }); } - let __ret: [G; OUT_578] = []; - if let Some(result) = record.function_queries[578].get_mut(&inp[..]) { debug_assert_eq!(result.output, &__ret[..]); if !unconstrained { *result.multiplicity += G::ONE; } } else { record.function_queries[578].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained)); }; + let __ret: [G; OUT_574] = []; + if let Some(result) = record.function_queries[574].get_mut(&inp[..]) { debug_assert_eq!(result.output, &__ret[..]); if !unconstrained { *result.multiplicity += G::ONE; } } else { record.function_queries[574].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained)); }; return Ok(__ret); }, } }) } -const INPUT_SIZE_579: usize = 2; -const IN_579: usize = 2; -const OUT_579: usize = 0; -fn aiur_fn_579( - inp: [G; IN_579], +const INPUT_SIZE_575: usize = 2; +const IN_575: usize = 2; +const OUT_575: usize = 0; +fn aiur_fn_575( + inp: [G; IN_575], record: &mut QueryRecord, io_buffer: &mut IOBuffer, unconstrained: bool, -) -> Result<[G; OUT_579], ExecError> { +) -> Result<[G; OUT_575], ExecError> { stacker::maybe_grow(64 * 1024, 4 * 1024 * 1024, || { let __v_0: G = inp[0]; let __v_1: G = inp[1]; @@ -49783,28 +49499,28 @@ fn aiur_fn_579( let __v_4: G = __loaded[2]; match __v_2.as_canonical_u64() { 0u64 => { - let __ret: [G; OUT_579] = []; - if let Some(result) = record.function_queries[579].get_mut(&inp[..]) { debug_assert_eq!(result.output, &__ret[..]); if !unconstrained { *result.multiplicity += G::ONE; } } else { record.function_queries[579].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained)); }; + let __ret: [G; OUT_575] = []; + if let Some(result) = record.function_queries[575].get_mut(&inp[..]) { debug_assert_eq!(result.output, &__ret[..]); if !unconstrained { *result.multiplicity += G::ONE; } } else { record.function_queries[575].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained)); }; return Ok(__ret); }, 1u64 => { - let __r_arr: [G; OUT_579] = { let __args: [G; IN_579] = [__v_3, __v_1]; let __cu = unconstrained; if let Some(result) = record.function_queries[579].get_mut(&__args[..]) { if !__cu && *result.multiplicity == G::ZERO { aiur_fn_579(__args, record, io_buffer, false)? } else { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_579] = unsafe { *(result.output.as_ptr() as *const [G; OUT_579]) }; __ret } } else { aiur_fn_579(__args, record, io_buffer, __cu)? } }; - let __ret: [G; OUT_579] = []; - if let Some(result) = record.function_queries[579].get_mut(&inp[..]) { debug_assert_eq!(result.output, &__ret[..]); if !unconstrained { *result.multiplicity += G::ONE; } } else { record.function_queries[579].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained)); }; + let __r_arr: [G; OUT_575] = { let __args: [G; IN_575] = [__v_3, __v_1]; let __cu = unconstrained; if let Some(result) = record.function_queries[575].get_mut(&__args[..]) { if !__cu && *result.multiplicity == G::ZERO { aiur_fn_575(__args, record, io_buffer, false)? } else { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_575] = unsafe { *(result.output.as_ptr() as *const [G; OUT_575]) }; __ret } } else { aiur_fn_575(__args, record, io_buffer, __cu)? } }; + let __ret: [G; OUT_575] = []; + if let Some(result) = record.function_queries[575].get_mut(&inp[..]) { debug_assert_eq!(result.output, &__ret[..]); if !unconstrained { *result.multiplicity += G::ONE; } } else { record.function_queries[575].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained)); }; return Ok(__ret); }, 2u64 => { - let __r_arr: [G; OUT_579] = { let __args: [G; IN_579] = [__v_3, __v_1]; let __cu = unconstrained; if let Some(result) = record.function_queries[579].get_mut(&__args[..]) { if !__cu && *result.multiplicity == G::ZERO { aiur_fn_579(__args, record, io_buffer, false)? } else { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_579] = unsafe { *(result.output.as_ptr() as *const [G; OUT_579]) }; __ret } } else { aiur_fn_579(__args, record, io_buffer, __cu)? } }; - let __r_arr: [G; OUT_579] = { let __args: [G; IN_579] = [__v_4, __v_1]; let __cu = unconstrained; if let Some(result) = record.function_queries[579].get_mut(&__args[..]) { if !__cu && *result.multiplicity == G::ZERO { aiur_fn_579(__args, record, io_buffer, false)? } else { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_579] = unsafe { *(result.output.as_ptr() as *const [G; OUT_579]) }; __ret } } else { aiur_fn_579(__args, record, io_buffer, __cu)? } }; - let __ret: [G; OUT_579] = []; - if let Some(result) = record.function_queries[579].get_mut(&inp[..]) { debug_assert_eq!(result.output, &__ret[..]); if !unconstrained { *result.multiplicity += G::ONE; } } else { record.function_queries[579].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained)); }; + let __r_arr: [G; OUT_575] = { let __args: [G; IN_575] = [__v_3, __v_1]; let __cu = unconstrained; if let Some(result) = record.function_queries[575].get_mut(&__args[..]) { if !__cu && *result.multiplicity == G::ZERO { aiur_fn_575(__args, record, io_buffer, false)? } else { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_575] = unsafe { *(result.output.as_ptr() as *const [G; OUT_575]) }; __ret } } else { aiur_fn_575(__args, record, io_buffer, __cu)? } }; + let __r_arr: [G; OUT_575] = { let __args: [G; IN_575] = [__v_4, __v_1]; let __cu = unconstrained; if let Some(result) = record.function_queries[575].get_mut(&__args[..]) { if !__cu && *result.multiplicity == G::ZERO { aiur_fn_575(__args, record, io_buffer, false)? } else { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_575] = unsafe { *(result.output.as_ptr() as *const [G; OUT_575]) }; __ret } } else { aiur_fn_575(__args, record, io_buffer, __cu)? } }; + let __ret: [G; OUT_575] = []; + if let Some(result) = record.function_queries[575].get_mut(&inp[..]) { debug_assert_eq!(result.output, &__ret[..]); if !unconstrained { *result.multiplicity += G::ONE; } } else { record.function_queries[575].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained)); }; return Ok(__ret); }, 3u64 => { - let __r_arr: [G; OUT_579] = { let __args: [G; IN_579] = [__v_3, __v_1]; let __cu = unconstrained; if let Some(result) = record.function_queries[579].get_mut(&__args[..]) { if !__cu && *result.multiplicity == G::ZERO { aiur_fn_579(__args, record, io_buffer, false)? } else { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_579] = unsafe { *(result.output.as_ptr() as *const [G; OUT_579]) }; __ret } } else { aiur_fn_579(__args, record, io_buffer, __cu)? } }; - let __r_arr: [G; OUT_579] = { let __args: [G; IN_579] = [__v_4, __v_1]; let __cu = unconstrained; if let Some(result) = record.function_queries[579].get_mut(&__args[..]) { if !__cu && *result.multiplicity == G::ZERO { aiur_fn_579(__args, record, io_buffer, false)? } else { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_579] = unsafe { *(result.output.as_ptr() as *const [G; OUT_579]) }; __ret } } else { aiur_fn_579(__args, record, io_buffer, __cu)? } }; - let __ret: [G; OUT_579] = []; - if let Some(result) = record.function_queries[579].get_mut(&inp[..]) { debug_assert_eq!(result.output, &__ret[..]); if !unconstrained { *result.multiplicity += G::ONE; } } else { record.function_queries[579].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained)); }; + let __r_arr: [G; OUT_575] = { let __args: [G; IN_575] = [__v_3, __v_1]; let __cu = unconstrained; if let Some(result) = record.function_queries[575].get_mut(&__args[..]) { if !__cu && *result.multiplicity == G::ZERO { aiur_fn_575(__args, record, io_buffer, false)? } else { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_575] = unsafe { *(result.output.as_ptr() as *const [G; OUT_575]) }; __ret } } else { aiur_fn_575(__args, record, io_buffer, __cu)? } }; + let __r_arr: [G; OUT_575] = { let __args: [G; IN_575] = [__v_4, __v_1]; let __cu = unconstrained; if let Some(result) = record.function_queries[575].get_mut(&__args[..]) { if !__cu && *result.multiplicity == G::ZERO { aiur_fn_575(__args, record, io_buffer, false)? } else { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_575] = unsafe { *(result.output.as_ptr() as *const [G; OUT_575]) }; __ret } } else { aiur_fn_575(__args, record, io_buffer, __cu)? } }; + let __ret: [G; OUT_575] = []; + if let Some(result) = record.function_queries[575].get_mut(&inp[..]) { debug_assert_eq!(result.output, &__ret[..]); if !unconstrained { *result.multiplicity += G::ONE; } } else { record.function_queries[575].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained)); }; return Ok(__ret); }, 4u64 => { @@ -49813,8 +49529,8 @@ fn aiur_fn_579( if (__v_5 != __v_6) { return Err(ExecError::AssertEqMismatch { lhs: __v_5.as_canonical_u64(), rhs: __v_6.as_canonical_u64(), msg: Some("universe param index out of range".to_string()) }); } - let __ret: [G; OUT_579] = []; - if let Some(result) = record.function_queries[579].get_mut(&inp[..]) { debug_assert_eq!(result.output, &__ret[..]); if !unconstrained { *result.multiplicity += G::ONE; } } else { record.function_queries[579].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained)); }; + let __ret: [G; OUT_575] = []; + if let Some(result) = record.function_queries[575].get_mut(&inp[..]) { debug_assert_eq!(result.output, &__ret[..]); if !unconstrained { *result.multiplicity += G::ONE; } } else { record.function_queries[575].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained)); }; return Ok(__ret); }, _ => { @@ -49824,15 +49540,15 @@ fn aiur_fn_579( }) } -const INPUT_SIZE_580: usize = 2; -const IN_580: usize = 2; -const OUT_580: usize = 0; -fn aiur_fn_580( - inp: [G; IN_580], +const INPUT_SIZE_576: usize = 2; +const IN_576: usize = 2; +const OUT_576: usize = 0; +fn aiur_fn_576( + inp: [G; IN_576], record: &mut QueryRecord, io_buffer: &mut IOBuffer, unconstrained: bool, -) -> Result<[G; OUT_580], ExecError> { +) -> Result<[G; OUT_576], ExecError> { stacker::maybe_grow(64 * 1024, 4 * 1024 * 1024, || { let __v_0: G = inp[0]; let __v_1: G = inp[1]; @@ -49842,15 +49558,15 @@ fn aiur_fn_580( let __v_4: G = __loaded[2]; match __v_2.as_canonical_u64() { 1u64 => { - let __ret: [G; OUT_580] = []; - if let Some(result) = record.function_queries[580].get_mut(&inp[..]) { debug_assert_eq!(result.output, &__ret[..]); if !unconstrained { *result.multiplicity += G::ONE; } } else { record.function_queries[580].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained)); }; + let __ret: [G; OUT_576] = []; + if let Some(result) = record.function_queries[576].get_mut(&inp[..]) { debug_assert_eq!(result.output, &__ret[..]); if !unconstrained { *result.multiplicity += G::ONE; } } else { record.function_queries[576].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained)); }; return Ok(__ret); }, 0u64 => { - let __r_arr: [G; OUT_579] = { let __args: [G; IN_579] = [__v_3, __v_1]; let __cu = unconstrained; if let Some(result) = record.function_queries[579].get_mut(&__args[..]) { if !__cu && *result.multiplicity == G::ZERO { aiur_fn_579(__args, record, io_buffer, false)? } else { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_579] = unsafe { *(result.output.as_ptr() as *const [G; OUT_579]) }; __ret } } else { aiur_fn_579(__args, record, io_buffer, __cu)? } }; - let __r_arr: [G; OUT_580] = { let __args: [G; IN_580] = [__v_4, __v_1]; let __cu = unconstrained; if let Some(result) = record.function_queries[580].get_mut(&__args[..]) { if !__cu && *result.multiplicity == G::ZERO { aiur_fn_580(__args, record, io_buffer, false)? } else { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_580] = unsafe { *(result.output.as_ptr() as *const [G; OUT_580]) }; __ret } } else { aiur_fn_580(__args, record, io_buffer, __cu)? } }; - let __ret: [G; OUT_580] = []; - if let Some(result) = record.function_queries[580].get_mut(&inp[..]) { debug_assert_eq!(result.output, &__ret[..]); if !unconstrained { *result.multiplicity += G::ONE; } } else { record.function_queries[580].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained)); }; + let __r_arr: [G; OUT_575] = { let __args: [G; IN_575] = [__v_3, __v_1]; let __cu = unconstrained; if let Some(result) = record.function_queries[575].get_mut(&__args[..]) { if !__cu && *result.multiplicity == G::ZERO { aiur_fn_575(__args, record, io_buffer, false)? } else { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_575] = unsafe { *(result.output.as_ptr() as *const [G; OUT_575]) }; __ret } } else { aiur_fn_575(__args, record, io_buffer, __cu)? } }; + let __r_arr: [G; OUT_576] = { let __args: [G; IN_576] = [__v_4, __v_1]; let __cu = unconstrained; if let Some(result) = record.function_queries[576].get_mut(&__args[..]) { if !__cu && *result.multiplicity == G::ZERO { aiur_fn_576(__args, record, io_buffer, false)? } else { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_576] = unsafe { *(result.output.as_ptr() as *const [G; OUT_576]) }; __ret } } else { aiur_fn_576(__args, record, io_buffer, __cu)? } }; + let __ret: [G; OUT_576] = []; + if let Some(result) = record.function_queries[576].get_mut(&inp[..]) { debug_assert_eq!(result.output, &__ret[..]); if !unconstrained { *result.multiplicity += G::ONE; } } else { record.function_queries[576].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained)); }; return Ok(__ret); }, _ => { @@ -49860,15 +49576,15 @@ fn aiur_fn_580( }) } -const INPUT_SIZE_581: usize = 3; -const IN_581: usize = 3; -const OUT_581: usize = 0; -fn aiur_fn_581( - inp: [G; IN_581], +const INPUT_SIZE_577: usize = 3; +const IN_577: usize = 3; +const OUT_577: usize = 0; +fn aiur_fn_577( + inp: [G; IN_577], record: &mut QueryRecord, io_buffer: &mut IOBuffer, unconstrained: bool, -) -> Result<[G; OUT_581], ExecError> { +) -> Result<[G; OUT_577], ExecError> { stacker::maybe_grow(64 * 1024, 4 * 1024 * 1024, || { let __v_0: G = inp[0]; let __v_1: G = inp[1]; @@ -49885,18 +49601,18 @@ fn aiur_fn_581( if (__v_7 != __v_8) { return Err(ExecError::AssertEqMismatch { lhs: __v_7.as_canonical_u64(), rhs: __v_8.as_canonical_u64(), msg: Some("loose bound variable: BVar index exceeds binder depth".to_string()) }); } - let __ret: [G; OUT_581] = []; - if let Some(result) = record.function_queries[581].get_mut(&inp[..]) { debug_assert_eq!(result.output, &__ret[..]); if !unconstrained { *result.multiplicity += G::ONE; } } else { record.function_queries[581].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained)); }; + let __ret: [G; OUT_577] = []; + if let Some(result) = record.function_queries[577].get_mut(&inp[..]) { debug_assert_eq!(result.output, &__ret[..]); if !unconstrained { *result.multiplicity += G::ONE; } } else { record.function_queries[577].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained)); }; return Ok(__ret); }, 1u64 => { - let __r_arr: [G; OUT_579] = { let __args: [G; IN_579] = [__v_4, __v_2]; let __cu = unconstrained; if let Some(result) = record.function_queries[579].get_mut(&__args[..]) { if !__cu && *result.multiplicity == G::ZERO { aiur_fn_579(__args, record, io_buffer, false)? } else { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_579] = unsafe { *(result.output.as_ptr() as *const [G; OUT_579]) }; __ret } } else { aiur_fn_579(__args, record, io_buffer, __cu)? } }; - let __ret: [G; OUT_581] = []; - if let Some(result) = record.function_queries[581].get_mut(&inp[..]) { debug_assert_eq!(result.output, &__ret[..]); if !unconstrained { *result.multiplicity += G::ONE; } } else { record.function_queries[581].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained)); }; + let __r_arr: [G; OUT_575] = { let __args: [G; IN_575] = [__v_4, __v_2]; let __cu = unconstrained; if let Some(result) = record.function_queries[575].get_mut(&__args[..]) { if !__cu && *result.multiplicity == G::ZERO { aiur_fn_575(__args, record, io_buffer, false)? } else { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_575] = unsafe { *(result.output.as_ptr() as *const [G; OUT_575]) }; __ret } } else { aiur_fn_575(__args, record, io_buffer, __cu)? } }; + let __ret: [G; OUT_577] = []; + if let Some(result) = record.function_queries[577].get_mut(&inp[..]) { debug_assert_eq!(result.output, &__ret[..]); if !unconstrained { *result.multiplicity += G::ONE; } } else { record.function_queries[577].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained)); }; return Ok(__ret); }, 2u64 => { - let __r_arr: [G; OUT_287] = { let __args: [G; IN_287] = [__v_4]; let __cu = unconstrained; if let Some(result) = record.function_queries[287].get_mut(&__args[..]) { if !__cu && *result.multiplicity == G::ZERO { aiur_fn_287(__args, record, io_buffer, false)? } else { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_287] = unsafe { *(result.output.as_ptr() as *const [G; OUT_287]) }; __ret } } else { aiur_fn_287(__args, record, io_buffer, __cu)? } }; + let __r_arr: [G; OUT_283] = { let __args: [G; IN_283] = [__v_4]; let __cu = unconstrained; if let Some(result) = record.function_queries[283].get_mut(&__args[..]) { if !__cu && *result.multiplicity == G::ZERO { aiur_fn_283(__args, record, io_buffer, false)? } else { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_283] = unsafe { *(result.output.as_ptr() as *const [G; OUT_283]) }; __ret } } else { aiur_fn_283(__args, record, io_buffer, __cu)? } }; let __v_7: G = __r_arr[0]; let __loaded: [G; 12] = { let __mq = record.memory_queries.get_mut(&12).ok_or(ExecError::InvalidMemorySize(12))?; let __ptr_u64 = __v_7.as_canonical_u64(); let __ptr_usize = usize::try_from(__ptr_u64).ok().ok_or(ExecError::PointerTooLarge(__ptr_u64))?; let (__args, __mult) = __mq.get_index_mut(__ptr_usize).ok_or(ExecError::UnboundPointer { ptr: __ptr_u64, size: 12 })?; if !unconstrained { *__mult += G::ONE; } let __arr: [G; 12] = __args[..12].try_into().unwrap(); __arr }; let __v_8: G = __loaded[0]; @@ -49911,62 +49627,62 @@ fn aiur_fn_581( let __v_17: G = __loaded[9]; let __v_18: G = __loaded[10]; let __v_19: G = __loaded[11]; - let __r_arr: [G; OUT_431] = { let __args: [G; IN_431] = [__v_8, __v_9, __v_10, __v_11, __v_12, __v_13, __v_14, __v_15, __v_16, __v_17, __v_18, __v_19]; let __cu = unconstrained; if let Some(result) = record.function_queries[431].get_mut(&__args[..]) { if !__cu && *result.multiplicity == G::ZERO { aiur_fn_431(__args, record, io_buffer, false)? } else { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_431] = unsafe { *(result.output.as_ptr() as *const [G; OUT_431]) }; __ret } } else { aiur_fn_431(__args, record, io_buffer, __cu)? } }; + let __r_arr: [G; OUT_427] = { let __args: [G; IN_427] = [__v_8, __v_9, __v_10, __v_11, __v_12, __v_13, __v_14, __v_15, __v_16, __v_17, __v_18, __v_19]; let __cu = unconstrained; if let Some(result) = record.function_queries[427].get_mut(&__args[..]) { if !__cu && *result.multiplicity == G::ZERO { aiur_fn_427(__args, record, io_buffer, false)? } else { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_427] = unsafe { *(result.output.as_ptr() as *const [G; OUT_427]) }; __ret } } else { aiur_fn_427(__args, record, io_buffer, __cu)? } }; let __v_20: G = __r_arr[0]; - let __r_arr: [G; OUT_764] = { let __args: [G; IN_764] = [__v_5]; let __cu = unconstrained; if let Some(result) = record.function_queries[764].get_mut(&__args[..]) { if !__cu && *result.multiplicity == G::ZERO { aiur_fn_764(__args, record, io_buffer, false)? } else { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_764] = unsafe { *(result.output.as_ptr() as *const [G; OUT_764]) }; __ret } } else { aiur_fn_764(__args, record, io_buffer, __cu)? } }; + let __r_arr: [G; OUT_760] = { let __args: [G; IN_760] = [__v_5]; let __cu = unconstrained; if let Some(result) = record.function_queries[760].get_mut(&__args[..]) { if !__cu && *result.multiplicity == G::ZERO { aiur_fn_760(__args, record, io_buffer, false)? } else { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_760] = unsafe { *(result.output.as_ptr() as *const [G; OUT_760]) }; __ret } } else { aiur_fn_760(__args, record, io_buffer, __cu)? } }; let __v_21: G = __r_arr[0]; if (__v_21 != __v_20) { return Err(ExecError::AssertEqMismatch { lhs: __v_21.as_canonical_u64(), rhs: __v_20.as_canonical_u64(), msg: Some("Const applied to wrong number of universe levels".to_string()) }); } - let __r_arr: [G; OUT_580] = { let __args: [G; IN_580] = [__v_5, __v_2]; let __cu = unconstrained; if let Some(result) = record.function_queries[580].get_mut(&__args[..]) { if !__cu && *result.multiplicity == G::ZERO { aiur_fn_580(__args, record, io_buffer, false)? } else { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_580] = unsafe { *(result.output.as_ptr() as *const [G; OUT_580]) }; __ret } } else { aiur_fn_580(__args, record, io_buffer, __cu)? } }; - let __ret: [G; OUT_581] = []; - if let Some(result) = record.function_queries[581].get_mut(&inp[..]) { debug_assert_eq!(result.output, &__ret[..]); if !unconstrained { *result.multiplicity += G::ONE; } } else { record.function_queries[581].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained)); }; + let __r_arr: [G; OUT_576] = { let __args: [G; IN_576] = [__v_5, __v_2]; let __cu = unconstrained; if let Some(result) = record.function_queries[576].get_mut(&__args[..]) { if !__cu && *result.multiplicity == G::ZERO { aiur_fn_576(__args, record, io_buffer, false)? } else { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_576] = unsafe { *(result.output.as_ptr() as *const [G; OUT_576]) }; __ret } } else { aiur_fn_576(__args, record, io_buffer, __cu)? } }; + let __ret: [G; OUT_577] = []; + if let Some(result) = record.function_queries[577].get_mut(&inp[..]) { debug_assert_eq!(result.output, &__ret[..]); if !unconstrained { *result.multiplicity += G::ONE; } } else { record.function_queries[577].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained)); }; return Ok(__ret); }, 3u64 => { - let __r_arr: [G; OUT_581] = { let __args: [G; IN_581] = [__v_4, __v_1, __v_2]; let __cu = unconstrained; if let Some(result) = record.function_queries[581].get_mut(&__args[..]) { if !__cu && *result.multiplicity == G::ZERO { aiur_fn_581(__args, record, io_buffer, false)? } else { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_581] = unsafe { *(result.output.as_ptr() as *const [G; OUT_581]) }; __ret } } else { aiur_fn_581(__args, record, io_buffer, __cu)? } }; - let __r_arr: [G; OUT_581] = { let __args: [G; IN_581] = [__v_5, __v_1, __v_2]; let __cu = unconstrained; if let Some(result) = record.function_queries[581].get_mut(&__args[..]) { if !__cu && *result.multiplicity == G::ZERO { aiur_fn_581(__args, record, io_buffer, false)? } else { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_581] = unsafe { *(result.output.as_ptr() as *const [G; OUT_581]) }; __ret } } else { aiur_fn_581(__args, record, io_buffer, __cu)? } }; - let __ret: [G; OUT_581] = []; - if let Some(result) = record.function_queries[581].get_mut(&inp[..]) { debug_assert_eq!(result.output, &__ret[..]); if !unconstrained { *result.multiplicity += G::ONE; } } else { record.function_queries[581].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained)); }; + let __r_arr: [G; OUT_577] = { let __args: [G; IN_577] = [__v_4, __v_1, __v_2]; let __cu = unconstrained; if let Some(result) = record.function_queries[577].get_mut(&__args[..]) { if !__cu && *result.multiplicity == G::ZERO { aiur_fn_577(__args, record, io_buffer, false)? } else { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_577] = unsafe { *(result.output.as_ptr() as *const [G; OUT_577]) }; __ret } } else { aiur_fn_577(__args, record, io_buffer, __cu)? } }; + let __r_arr: [G; OUT_577] = { let __args: [G; IN_577] = [__v_5, __v_1, __v_2]; let __cu = unconstrained; if let Some(result) = record.function_queries[577].get_mut(&__args[..]) { if !__cu && *result.multiplicity == G::ZERO { aiur_fn_577(__args, record, io_buffer, false)? } else { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_577] = unsafe { *(result.output.as_ptr() as *const [G; OUT_577]) }; __ret } } else { aiur_fn_577(__args, record, io_buffer, __cu)? } }; + let __ret: [G; OUT_577] = []; + if let Some(result) = record.function_queries[577].get_mut(&inp[..]) { debug_assert_eq!(result.output, &__ret[..]); if !unconstrained { *result.multiplicity += G::ONE; } } else { record.function_queries[577].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained)); }; return Ok(__ret); }, 4u64 => { - let __r_arr: [G; OUT_581] = { let __args: [G; IN_581] = [__v_4, __v_1, __v_2]; let __cu = unconstrained; if let Some(result) = record.function_queries[581].get_mut(&__args[..]) { if !__cu && *result.multiplicity == G::ZERO { aiur_fn_581(__args, record, io_buffer, false)? } else { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_581] = unsafe { *(result.output.as_ptr() as *const [G; OUT_581]) }; __ret } } else { aiur_fn_581(__args, record, io_buffer, __cu)? } }; + let __r_arr: [G; OUT_577] = { let __args: [G; IN_577] = [__v_4, __v_1, __v_2]; let __cu = unconstrained; if let Some(result) = record.function_queries[577].get_mut(&__args[..]) { if !__cu && *result.multiplicity == G::ZERO { aiur_fn_577(__args, record, io_buffer, false)? } else { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_577] = unsafe { *(result.output.as_ptr() as *const [G; OUT_577]) }; __ret } } else { aiur_fn_577(__args, record, io_buffer, __cu)? } }; let __v_7: G = G::from_u64(1); let __v_8: G = (__v_1 + __v_7); - let __r_arr: [G; OUT_581] = { let __args: [G; IN_581] = [__v_5, __v_8, __v_2]; let __cu = unconstrained; if let Some(result) = record.function_queries[581].get_mut(&__args[..]) { if !__cu && *result.multiplicity == G::ZERO { aiur_fn_581(__args, record, io_buffer, false)? } else { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_581] = unsafe { *(result.output.as_ptr() as *const [G; OUT_581]) }; __ret } } else { aiur_fn_581(__args, record, io_buffer, __cu)? } }; - let __ret: [G; OUT_581] = []; - if let Some(result) = record.function_queries[581].get_mut(&inp[..]) { debug_assert_eq!(result.output, &__ret[..]); if !unconstrained { *result.multiplicity += G::ONE; } } else { record.function_queries[581].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained)); }; + let __r_arr: [G; OUT_577] = { let __args: [G; IN_577] = [__v_5, __v_8, __v_2]; let __cu = unconstrained; if let Some(result) = record.function_queries[577].get_mut(&__args[..]) { if !__cu && *result.multiplicity == G::ZERO { aiur_fn_577(__args, record, io_buffer, false)? } else { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_577] = unsafe { *(result.output.as_ptr() as *const [G; OUT_577]) }; __ret } } else { aiur_fn_577(__args, record, io_buffer, __cu)? } }; + let __ret: [G; OUT_577] = []; + if let Some(result) = record.function_queries[577].get_mut(&inp[..]) { debug_assert_eq!(result.output, &__ret[..]); if !unconstrained { *result.multiplicity += G::ONE; } } else { record.function_queries[577].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained)); }; return Ok(__ret); }, 5u64 => { - let __r_arr: [G; OUT_581] = { let __args: [G; IN_581] = [__v_4, __v_1, __v_2]; let __cu = unconstrained; if let Some(result) = record.function_queries[581].get_mut(&__args[..]) { if !__cu && *result.multiplicity == G::ZERO { aiur_fn_581(__args, record, io_buffer, false)? } else { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_581] = unsafe { *(result.output.as_ptr() as *const [G; OUT_581]) }; __ret } } else { aiur_fn_581(__args, record, io_buffer, __cu)? } }; + let __r_arr: [G; OUT_577] = { let __args: [G; IN_577] = [__v_4, __v_1, __v_2]; let __cu = unconstrained; if let Some(result) = record.function_queries[577].get_mut(&__args[..]) { if !__cu && *result.multiplicity == G::ZERO { aiur_fn_577(__args, record, io_buffer, false)? } else { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_577] = unsafe { *(result.output.as_ptr() as *const [G; OUT_577]) }; __ret } } else { aiur_fn_577(__args, record, io_buffer, __cu)? } }; let __v_7: G = G::from_u64(1); let __v_8: G = (__v_1 + __v_7); - let __r_arr: [G; OUT_581] = { let __args: [G; IN_581] = [__v_5, __v_8, __v_2]; let __cu = unconstrained; if let Some(result) = record.function_queries[581].get_mut(&__args[..]) { if !__cu && *result.multiplicity == G::ZERO { aiur_fn_581(__args, record, io_buffer, false)? } else { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_581] = unsafe { *(result.output.as_ptr() as *const [G; OUT_581]) }; __ret } } else { aiur_fn_581(__args, record, io_buffer, __cu)? } }; - let __ret: [G; OUT_581] = []; - if let Some(result) = record.function_queries[581].get_mut(&inp[..]) { debug_assert_eq!(result.output, &__ret[..]); if !unconstrained { *result.multiplicity += G::ONE; } } else { record.function_queries[581].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained)); }; + let __r_arr: [G; OUT_577] = { let __args: [G; IN_577] = [__v_5, __v_8, __v_2]; let __cu = unconstrained; if let Some(result) = record.function_queries[577].get_mut(&__args[..]) { if !__cu && *result.multiplicity == G::ZERO { aiur_fn_577(__args, record, io_buffer, false)? } else { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_577] = unsafe { *(result.output.as_ptr() as *const [G; OUT_577]) }; __ret } } else { aiur_fn_577(__args, record, io_buffer, __cu)? } }; + let __ret: [G; OUT_577] = []; + if let Some(result) = record.function_queries[577].get_mut(&inp[..]) { debug_assert_eq!(result.output, &__ret[..]); if !unconstrained { *result.multiplicity += G::ONE; } } else { record.function_queries[577].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained)); }; return Ok(__ret); }, 6u64 => { - let __r_arr: [G; OUT_581] = { let __args: [G; IN_581] = [__v_4, __v_1, __v_2]; let __cu = unconstrained; if let Some(result) = record.function_queries[581].get_mut(&__args[..]) { if !__cu && *result.multiplicity == G::ZERO { aiur_fn_581(__args, record, io_buffer, false)? } else { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_581] = unsafe { *(result.output.as_ptr() as *const [G; OUT_581]) }; __ret } } else { aiur_fn_581(__args, record, io_buffer, __cu)? } }; - let __r_arr: [G; OUT_581] = { let __args: [G; IN_581] = [__v_5, __v_1, __v_2]; let __cu = unconstrained; if let Some(result) = record.function_queries[581].get_mut(&__args[..]) { if !__cu && *result.multiplicity == G::ZERO { aiur_fn_581(__args, record, io_buffer, false)? } else { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_581] = unsafe { *(result.output.as_ptr() as *const [G; OUT_581]) }; __ret } } else { aiur_fn_581(__args, record, io_buffer, __cu)? } }; + let __r_arr: [G; OUT_577] = { let __args: [G; IN_577] = [__v_4, __v_1, __v_2]; let __cu = unconstrained; if let Some(result) = record.function_queries[577].get_mut(&__args[..]) { if !__cu && *result.multiplicity == G::ZERO { aiur_fn_577(__args, record, io_buffer, false)? } else { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_577] = unsafe { *(result.output.as_ptr() as *const [G; OUT_577]) }; __ret } } else { aiur_fn_577(__args, record, io_buffer, __cu)? } }; + let __r_arr: [G; OUT_577] = { let __args: [G; IN_577] = [__v_5, __v_1, __v_2]; let __cu = unconstrained; if let Some(result) = record.function_queries[577].get_mut(&__args[..]) { if !__cu && *result.multiplicity == G::ZERO { aiur_fn_577(__args, record, io_buffer, false)? } else { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_577] = unsafe { *(result.output.as_ptr() as *const [G; OUT_577]) }; __ret } } else { aiur_fn_577(__args, record, io_buffer, __cu)? } }; let __v_7: G = G::from_u64(1); let __v_8: G = (__v_1 + __v_7); - let __r_arr: [G; OUT_581] = { let __args: [G; IN_581] = [__v_6, __v_8, __v_2]; let __cu = unconstrained; if let Some(result) = record.function_queries[581].get_mut(&__args[..]) { if !__cu && *result.multiplicity == G::ZERO { aiur_fn_581(__args, record, io_buffer, false)? } else { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_581] = unsafe { *(result.output.as_ptr() as *const [G; OUT_581]) }; __ret } } else { aiur_fn_581(__args, record, io_buffer, __cu)? } }; - let __ret: [G; OUT_581] = []; - if let Some(result) = record.function_queries[581].get_mut(&inp[..]) { debug_assert_eq!(result.output, &__ret[..]); if !unconstrained { *result.multiplicity += G::ONE; } } else { record.function_queries[581].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained)); }; + let __r_arr: [G; OUT_577] = { let __args: [G; IN_577] = [__v_6, __v_8, __v_2]; let __cu = unconstrained; if let Some(result) = record.function_queries[577].get_mut(&__args[..]) { if !__cu && *result.multiplicity == G::ZERO { aiur_fn_577(__args, record, io_buffer, false)? } else { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_577] = unsafe { *(result.output.as_ptr() as *const [G; OUT_577]) }; __ret } } else { aiur_fn_577(__args, record, io_buffer, __cu)? } }; + let __ret: [G; OUT_577] = []; + if let Some(result) = record.function_queries[577].get_mut(&inp[..]) { debug_assert_eq!(result.output, &__ret[..]); if !unconstrained { *result.multiplicity += G::ONE; } } else { record.function_queries[577].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained)); }; return Ok(__ret); }, 7u64 => { - let __ret: [G; OUT_581] = []; - if let Some(result) = record.function_queries[581].get_mut(&inp[..]) { debug_assert_eq!(result.output, &__ret[..]); if !unconstrained { *result.multiplicity += G::ONE; } } else { record.function_queries[581].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained)); }; + let __ret: [G; OUT_577] = []; + if let Some(result) = record.function_queries[577].get_mut(&inp[..]) { debug_assert_eq!(result.output, &__ret[..]); if !unconstrained { *result.multiplicity += G::ONE; } } else { record.function_queries[577].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained)); }; return Ok(__ret); }, 8u64 => { - let __r_arr: [G; OUT_581] = { let __args: [G; IN_581] = [__v_6, __v_1, __v_2]; let __cu = unconstrained; if let Some(result) = record.function_queries[581].get_mut(&__args[..]) { if !__cu && *result.multiplicity == G::ZERO { aiur_fn_581(__args, record, io_buffer, false)? } else { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_581] = unsafe { *(result.output.as_ptr() as *const [G; OUT_581]) }; __ret } } else { aiur_fn_581(__args, record, io_buffer, __cu)? } }; - let __ret: [G; OUT_581] = []; - if let Some(result) = record.function_queries[581].get_mut(&inp[..]) { debug_assert_eq!(result.output, &__ret[..]); if !unconstrained { *result.multiplicity += G::ONE; } } else { record.function_queries[581].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained)); }; + let __r_arr: [G; OUT_577] = { let __args: [G; IN_577] = [__v_6, __v_1, __v_2]; let __cu = unconstrained; if let Some(result) = record.function_queries[577].get_mut(&__args[..]) { if !__cu && *result.multiplicity == G::ZERO { aiur_fn_577(__args, record, io_buffer, false)? } else { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_577] = unsafe { *(result.output.as_ptr() as *const [G; OUT_577]) }; __ret } } else { aiur_fn_577(__args, record, io_buffer, __cu)? } }; + let __ret: [G; OUT_577] = []; + if let Some(result) = record.function_queries[577].get_mut(&inp[..]) { debug_assert_eq!(result.output, &__ret[..]); if !unconstrained { *result.multiplicity += G::ONE; } } else { record.function_queries[577].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained)); }; return Ok(__ret); }, _ => { @@ -49976,15 +49692,15 @@ fn aiur_fn_581( }) } -const INPUT_SIZE_582: usize = 0; -const IN_582: usize = 0; -const OUT_582: usize = 1; -fn aiur_fn_582( - inp: [G; IN_582], +const INPUT_SIZE_578: usize = 0; +const IN_578: usize = 0; +const OUT_578: usize = 1; +fn aiur_fn_578( + inp: [G; IN_578], record: &mut QueryRecord, io_buffer: &mut IOBuffer, unconstrained: bool, -) -> Result<[G; OUT_582], ExecError> { +) -> Result<[G; OUT_578], ExecError> { stacker::maybe_grow(64 * 1024, 4 * 1024 * 1024, || { let __v_0: G = G::from_u64(171); let __v_1: G = G::from_u64(104); @@ -50019,21 +49735,21 @@ fn aiur_fn_582( let __v_30: G = G::from_u64(202); let __v_31: G = G::from_u64(184); let __v_32: G = { let __values: [G; 32] = [__v_0, __v_1, __v_2, __v_3, __v_4, __v_5, __v_6, __v_7, __v_8, __v_9, __v_10, __v_11, __v_12, __v_13, __v_14, __v_15, __v_16, __v_17, __v_18, __v_19, __v_20, __v_21, __v_22, __v_23, __v_24, __v_25, __v_26, __v_27, __v_28, __v_29, __v_30, __v_31]; let __mq = record.memory_queries.get_mut(&32).ok_or(ExecError::InvalidMemorySize(32))?; if let Some(result) = __mq.get_mut(&__values[..]) { if !unconstrained { *result.multiplicity += G::ONE; } result.output[0] } else { let __ptr = G::from_usize(__mq.len()); __mq.insert(&__values[..], &[__ptr], G::from_bool(!unconstrained)); __ptr } }; - let __ret: [G; OUT_582] = [__v_32]; - if let Some(result) = record.function_queries[582].get_mut(&inp[..]) { debug_assert_eq!(result.output, &__ret[..]); if !unconstrained { *result.multiplicity += G::ONE; } } else { record.function_queries[582].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained)); }; + let __ret: [G; OUT_578] = [__v_32]; + if let Some(result) = record.function_queries[578].get_mut(&inp[..]) { debug_assert_eq!(result.output, &__ret[..]); if !unconstrained { *result.multiplicity += G::ONE; } } else { record.function_queries[578].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained)); }; return Ok(__ret); }) } -const INPUT_SIZE_583: usize = 3; -const IN_583: usize = 3; -const OUT_583: usize = 1; -fn aiur_fn_583( - inp: [G; IN_583], +const INPUT_SIZE_579: usize = 3; +const IN_579: usize = 3; +const OUT_579: usize = 1; +fn aiur_fn_579( + inp: [G; IN_579], record: &mut QueryRecord, io_buffer: &mut IOBuffer, unconstrained: bool, -) -> Result<[G; OUT_583], ExecError> { +) -> Result<[G; OUT_579], ExecError> { stacker::maybe_grow(64 * 1024, 4 * 1024 * 1024, || { let __v_0: G = inp[0]; let __v_1: G = inp[1]; @@ -50042,8 +49758,8 @@ fn aiur_fn_583( match __v_3.as_canonical_u64() { 0u64 => { let __v_4: G = G::from_u64(1); - let __ret: [G; OUT_583] = [__v_4]; - if let Some(result) = record.function_queries[583].get_mut(&inp[..]) { debug_assert_eq!(result.output, &__ret[..]); if !unconstrained { *result.multiplicity += G::ONE; } } else { record.function_queries[583].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained)); }; + let __ret: [G; OUT_579] = [__v_4]; + if let Some(result) = record.function_queries[579].get_mut(&inp[..]) { debug_assert_eq!(result.output, &__ret[..]); if !unconstrained { *result.multiplicity += G::ONE; } } else { record.function_queries[579].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained)); }; return Ok(__ret); }, _ => { @@ -50056,16 +49772,16 @@ fn aiur_fn_583( 5u64 => { let __v_8: G = G::from_u64(1); let __v_9: G = (__v_2 + __v_8); - let __r_arr: [G; OUT_583] = { let __args: [G; IN_583] = [__v_6, __v_1, __v_9]; let __cu = unconstrained; if let Some(result) = record.function_queries[583].get_mut(&__args[..]) { if !__cu && *result.multiplicity == G::ZERO { aiur_fn_583(__args, record, io_buffer, false)? } else { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_583] = unsafe { *(result.output.as_ptr() as *const [G; OUT_583]) }; __ret } } else { aiur_fn_583(__args, record, io_buffer, __cu)? } }; + let __r_arr: [G; OUT_579] = { let __args: [G; IN_579] = [__v_6, __v_1, __v_9]; let __cu = unconstrained; if let Some(result) = record.function_queries[579].get_mut(&__args[..]) { if !__cu && *result.multiplicity == G::ZERO { aiur_fn_579(__args, record, io_buffer, false)? } else { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_579] = unsafe { *(result.output.as_ptr() as *const [G; OUT_579]) }; __ret } } else { aiur_fn_579(__args, record, io_buffer, __cu)? } }; let __v_10: G = __r_arr[0]; - let __ret: [G; OUT_583] = [__v_10]; - if let Some(result) = record.function_queries[583].get_mut(&inp[..]) { debug_assert_eq!(result.output, &__ret[..]); if !unconstrained { *result.multiplicity += G::ONE; } } else { record.function_queries[583].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained)); }; + let __ret: [G; OUT_579] = [__v_10]; + if let Some(result) = record.function_queries[579].get_mut(&inp[..]) { debug_assert_eq!(result.output, &__ret[..]); if !unconstrained { *result.multiplicity += G::ONE; } } else { record.function_queries[579].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained)); }; return Ok(__ret); }, _ => { let __v_8: G = G::from_u64(0); - let __ret: [G; OUT_583] = [__v_8]; - if let Some(result) = record.function_queries[583].get_mut(&inp[..]) { debug_assert_eq!(result.output, &__ret[..]); if !unconstrained { *result.multiplicity += G::ONE; } } else { record.function_queries[583].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained)); }; + let __ret: [G; OUT_579] = [__v_8]; + if let Some(result) = record.function_queries[579].get_mut(&inp[..]) { debug_assert_eq!(result.output, &__ret[..]); if !unconstrained { *result.multiplicity += G::ONE; } } else { record.function_queries[579].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained)); }; return Ok(__ret); }, } @@ -50074,15 +49790,15 @@ fn aiur_fn_583( }) } -const INPUT_SIZE_584: usize = 0; -const IN_584: usize = 0; -const OUT_584: usize = 0; -fn aiur_fn_584( - inp: [G; IN_584], +const INPUT_SIZE_580: usize = 0; +const IN_580: usize = 0; +const OUT_580: usize = 0; +fn aiur_fn_580( + inp: [G; IN_580], record: &mut QueryRecord, io_buffer: &mut IOBuffer, unconstrained: bool, -) -> Result<[G; OUT_584], ExecError> { +) -> Result<[G; OUT_580], ExecError> { stacker::maybe_grow(64 * 1024, 4 * 1024 * 1024, || { let __v_0: G = G::from_u64(3); let __v_1: G = G::from_u64(107); @@ -50117,7 +49833,7 @@ fn aiur_fn_584( let __v_30: G = G::from_u64(224); let __v_31: G = G::from_u64(201); let __v_32: G = { let __values: [G; 32] = [__v_0, __v_1, __v_2, __v_3, __v_4, __v_5, __v_6, __v_7, __v_8, __v_9, __v_10, __v_11, __v_12, __v_13, __v_14, __v_15, __v_16, __v_17, __v_18, __v_19, __v_20, __v_21, __v_22, __v_23, __v_24, __v_25, __v_26, __v_27, __v_28, __v_29, __v_30, __v_31]; let __mq = record.memory_queries.get_mut(&32).ok_or(ExecError::InvalidMemorySize(32))?; if let Some(result) = __mq.get_mut(&__values[..]) { if !unconstrained { *result.multiplicity += G::ONE; } result.output[0] } else { let __ptr = G::from_usize(__mq.len()); __mq.insert(&__values[..], &[__ptr], G::from_bool(!unconstrained)); __ptr } }; - let __r_arr: [G; OUT_287] = { let __args: [G; IN_287] = [__v_32]; let __cu = unconstrained; if let Some(result) = record.function_queries[287].get_mut(&__args[..]) { if !__cu && *result.multiplicity == G::ZERO { aiur_fn_287(__args, record, io_buffer, false)? } else { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_287] = unsafe { *(result.output.as_ptr() as *const [G; OUT_287]) }; __ret } } else { aiur_fn_287(__args, record, io_buffer, __cu)? } }; + let __r_arr: [G; OUT_283] = { let __args: [G; IN_283] = [__v_32]; let __cu = unconstrained; if let Some(result) = record.function_queries[283].get_mut(&__args[..]) { if !__cu && *result.multiplicity == G::ZERO { aiur_fn_283(__args, record, io_buffer, false)? } else { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_283] = unsafe { *(result.output.as_ptr() as *const [G; OUT_283]) }; __ret } } else { aiur_fn_283(__args, record, io_buffer, __cu)? } }; let __v_33: G = __r_arr[0]; let __loaded: [G; 12] = { let __mq = record.memory_queries.get_mut(&12).ok_or(ExecError::InvalidMemorySize(12))?; let __ptr_u64 = __v_33.as_canonical_u64(); let __ptr_usize = usize::try_from(__ptr_u64).ok().ok_or(ExecError::PointerTooLarge(__ptr_u64))?; let (__args, __mult) = __mq.get_index_mut(__ptr_usize).ok_or(ExecError::UnboundPointer { ptr: __ptr_u64, size: 12 })?; if !unconstrained { *__mult += G::ONE; } let __arr: [G; 12] = __args[..12].try_into().unwrap(); __arr }; let __v_34: G = __loaded[0]; @@ -50146,8 +49862,8 @@ fn aiur_fn_584( if (__v_39 != __v_48) { return Err(ExecError::AssertEqMismatch { lhs: __v_39.as_canonical_u64(), rhs: __v_48.as_canonical_u64(), msg: Some("Eq inductive: wrong constructor count".to_string()) }); } - let __ret: [G; OUT_584] = []; - if let Some(result) = record.function_queries[584].get_mut(&inp[..]) { debug_assert_eq!(result.output, &__ret[..]); if !unconstrained { *result.multiplicity += G::ONE; } } else { record.function_queries[584].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained)); }; + let __ret: [G; OUT_580] = []; + if let Some(result) = record.function_queries[580].get_mut(&inp[..]) { debug_assert_eq!(result.output, &__ret[..]); if !unconstrained { *result.multiplicity += G::ONE; } } else { record.function_queries[580].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained)); }; return Ok(__ret); }, _ => { @@ -50157,15 +49873,15 @@ fn aiur_fn_584( }) } -const INPUT_SIZE_585: usize = 4; -const IN_585: usize = 4; -const OUT_585: usize = 0; -fn aiur_fn_585( - inp: [G; IN_585], +const INPUT_SIZE_581: usize = 4; +const IN_581: usize = 4; +const OUT_581: usize = 0; +fn aiur_fn_581( + inp: [G; IN_581], record: &mut QueryRecord, io_buffer: &mut IOBuffer, unconstrained: bool, -) -> Result<[G; OUT_585], ExecError> { +) -> Result<[G; OUT_581], ExecError> { stacker::maybe_grow(64 * 1024, 4 * 1024 * 1024, || { let __v_0: G = inp[0]; let __v_1: G = inp[1]; @@ -50173,7 +49889,7 @@ fn aiur_fn_585( let __v_3: G = inp[3]; let __mc_out___mc_0: [G; 2] = '__mc_0: { match __v_1.as_canonical_u64() { 0u64 => { - let __r_arr: [G; OUT_582] = { let __args: [G; IN_582] = []; let __cu = unconstrained; if let Some(result) = record.function_queries[582].get_mut(&__args[..]) { if !__cu && *result.multiplicity == G::ZERO { aiur_fn_582(__args, record, io_buffer, false)? } else { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_582] = unsafe { *(result.output.as_ptr() as *const [G; OUT_582]) }; __ret } } else { aiur_fn_582(__args, record, io_buffer, __cu)? } }; + let __r_arr: [G; OUT_578] = { let __args: [G; IN_578] = []; let __cu = unconstrained; if let Some(result) = record.function_queries[578].get_mut(&__args[..]) { if !__cu && *result.multiplicity == G::ZERO { aiur_fn_578(__args, record, io_buffer, false)? } else { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_578] = unsafe { *(result.output.as_ptr() as *const [G; OUT_578]) }; __ret } } else { aiur_fn_578(__args, record, io_buffer, __cu)? } }; let __v_4: G = __r_arr[0]; let __r_arr: [G; OUT_1] = { let __args: [G; IN_1] = [__v_0, __v_4]; let __cu = unconstrained; if let Some(result) = record.function_queries[1].get_mut(&__args[..]) { if !__cu && *result.multiplicity == G::ZERO { aiur_fn_1(__args, record, io_buffer, false)? } else { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_1] = unsafe { *(result.output.as_ptr() as *const [G; OUT_1]) }; __ret } } else { aiur_fn_1(__args, record, io_buffer, __cu)? } }; let __v_5: G = __r_arr[0]; @@ -50186,7 +49902,7 @@ fn aiur_fn_585( break '__mc_0 [__v_7, __v_8]; }, 1u64 => { - let __r_arr: [G; OUT_383] = { let __args: [G; IN_383] = []; let __cu = unconstrained; if let Some(result) = record.function_queries[383].get_mut(&__args[..]) { if !__cu && *result.multiplicity == G::ZERO { aiur_fn_383(__args, record, io_buffer, false)? } else { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_383] = unsafe { *(result.output.as_ptr() as *const [G; OUT_383]) }; __ret } } else { aiur_fn_383(__args, record, io_buffer, __cu)? } }; + let __r_arr: [G; OUT_379] = { let __args: [G; IN_379] = []; let __cu = unconstrained; if let Some(result) = record.function_queries[379].get_mut(&__args[..]) { if !__cu && *result.multiplicity == G::ZERO { aiur_fn_379(__args, record, io_buffer, false)? } else { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_379] = unsafe { *(result.output.as_ptr() as *const [G; OUT_379]) }; __ret } } else { aiur_fn_379(__args, record, io_buffer, __cu)? } }; let __v_4: G = __r_arr[0]; let __r_arr: [G; OUT_1] = { let __args: [G; IN_1] = [__v_0, __v_4]; let __cu = unconstrained; if let Some(result) = record.function_queries[1].get_mut(&__args[..]) { if !__cu && *result.multiplicity == G::ZERO { aiur_fn_1(__args, record, io_buffer, false)? } else { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_1] = unsafe { *(result.output.as_ptr() as *const [G; OUT_1]) }; __ret } } else { aiur_fn_1(__args, record, io_buffer, __cu)? } }; let __v_5: G = __r_arr[0]; @@ -50199,8 +49915,8 @@ fn aiur_fn_585( break '__mc_0 [__v_7, __v_8]; }, 2u64 => { - let __r_arr: [G; OUT_584] = { let __args: [G; IN_584] = []; let __cu = unconstrained; if let Some(result) = record.function_queries[584].get_mut(&__args[..]) { if !__cu && *result.multiplicity == G::ZERO { aiur_fn_584(__args, record, io_buffer, false)? } else { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_584] = unsafe { *(result.output.as_ptr() as *const [G; OUT_584]) }; __ret } } else { aiur_fn_584(__args, record, io_buffer, __cu)? } }; - let __r_arr: [G; OUT_384] = { let __args: [G; IN_384] = []; let __cu = unconstrained; if let Some(result) = record.function_queries[384].get_mut(&__args[..]) { if !__cu && *result.multiplicity == G::ZERO { aiur_fn_384(__args, record, io_buffer, false)? } else { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_384] = unsafe { *(result.output.as_ptr() as *const [G; OUT_384]) }; __ret } } else { aiur_fn_384(__args, record, io_buffer, __cu)? } }; + let __r_arr: [G; OUT_580] = { let __args: [G; IN_580] = []; let __cu = unconstrained; if let Some(result) = record.function_queries[580].get_mut(&__args[..]) { if !__cu && *result.multiplicity == G::ZERO { aiur_fn_580(__args, record, io_buffer, false)? } else { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_580] = unsafe { *(result.output.as_ptr() as *const [G; OUT_580]) }; __ret } } else { aiur_fn_580(__args, record, io_buffer, __cu)? } }; + let __r_arr: [G; OUT_380] = { let __args: [G; IN_380] = []; let __cu = unconstrained; if let Some(result) = record.function_queries[380].get_mut(&__args[..]) { if !__cu && *result.multiplicity == G::ZERO { aiur_fn_380(__args, record, io_buffer, false)? } else { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_380] = unsafe { *(result.output.as_ptr() as *const [G; OUT_380]) }; __ret } } else { aiur_fn_380(__args, record, io_buffer, __cu)? } }; let __v_4: G = __r_arr[0]; let __r_arr: [G; OUT_1] = { let __args: [G; IN_1] = [__v_0, __v_4]; let __cu = unconstrained; if let Some(result) = record.function_queries[1].get_mut(&__args[..]) { if !__cu && *result.multiplicity == G::ZERO { aiur_fn_1(__args, record, io_buffer, false)? } else { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_1] = unsafe { *(result.output.as_ptr() as *const [G; OUT_1]) }; __ret } } else { aiur_fn_1(__args, record, io_buffer, __cu)? } }; let __v_5: G = __r_arr[0]; @@ -50213,7 +49929,7 @@ fn aiur_fn_585( break '__mc_0 [__v_7, __v_8]; }, 3u64 => { - let __r_arr: [G; OUT_385] = { let __args: [G; IN_385] = []; let __cu = unconstrained; if let Some(result) = record.function_queries[385].get_mut(&__args[..]) { if !__cu && *result.multiplicity == G::ZERO { aiur_fn_385(__args, record, io_buffer, false)? } else { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_385] = unsafe { *(result.output.as_ptr() as *const [G; OUT_385]) }; __ret } } else { aiur_fn_385(__args, record, io_buffer, __cu)? } }; + let __r_arr: [G; OUT_381] = { let __args: [G; IN_381] = []; let __cu = unconstrained; if let Some(result) = record.function_queries[381].get_mut(&__args[..]) { if !__cu && *result.multiplicity == G::ZERO { aiur_fn_381(__args, record, io_buffer, false)? } else { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_381] = unsafe { *(result.output.as_ptr() as *const [G; OUT_381]) }; __ret } } else { aiur_fn_381(__args, record, io_buffer, __cu)? } }; let __v_4: G = __r_arr[0]; let __r_arr: [G; OUT_1] = { let __args: [G; IN_1] = [__v_0, __v_4]; let __cu = unconstrained; if let Some(result) = record.function_queries[1].get_mut(&__args[..]) { if !__cu && *result.multiplicity == G::ZERO { aiur_fn_1(__args, record, io_buffer, false)? } else { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_1] = unsafe { *(result.output.as_ptr() as *const [G; OUT_1]) }; __ret } } else { aiur_fn_1(__args, record, io_buffer, __cu)? } }; let __v_5: G = __r_arr[0]; @@ -50236,34 +49952,34 @@ fn aiur_fn_585( return Err(ExecError::AssertEqMismatch { lhs: __v_2.as_canonical_u64(), rhs: __v_4.as_canonical_u64(), msg: Some("Quot constant: wrong universe param count for its kind".to_string()) }); } let __v_6: G = G::from_u64(0); - let __r_arr: [G; OUT_583] = { let __args: [G; IN_583] = [__v_3, __v_5, __v_6]; let __cu = unconstrained; if let Some(result) = record.function_queries[583].get_mut(&__args[..]) { if !__cu && *result.multiplicity == G::ZERO { aiur_fn_583(__args, record, io_buffer, false)? } else { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_583] = unsafe { *(result.output.as_ptr() as *const [G; OUT_583]) }; __ret } } else { aiur_fn_583(__args, record, io_buffer, __cu)? } }; + let __r_arr: [G; OUT_579] = { let __args: [G; IN_579] = [__v_3, __v_5, __v_6]; let __cu = unconstrained; if let Some(result) = record.function_queries[579].get_mut(&__args[..]) { if !__cu && *result.multiplicity == G::ZERO { aiur_fn_579(__args, record, io_buffer, false)? } else { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_579] = unsafe { *(result.output.as_ptr() as *const [G; OUT_579]) }; __ret } } else { aiur_fn_579(__args, record, io_buffer, __cu)? } }; let __v_7: G = __r_arr[0]; let __v_8: G = G::from_u64(1); if (__v_7 != __v_8) { return Err(ExecError::AssertEqMismatch { lhs: __v_7.as_canonical_u64(), rhs: __v_8.as_canonical_u64(), msg: Some("Quot constant: type has too few foralls for its kind".to_string()) }); } - let __ret: [G; OUT_585] = []; - if let Some(result) = record.function_queries[585].get_mut(&inp[..]) { debug_assert_eq!(result.output, &__ret[..]); if !unconstrained { *result.multiplicity += G::ONE; } } else { record.function_queries[585].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained)); }; + let __ret: [G; OUT_581] = []; + if let Some(result) = record.function_queries[581].get_mut(&inp[..]) { debug_assert_eq!(result.output, &__ret[..]); if !unconstrained { *result.multiplicity += G::ONE; } } else { record.function_queries[581].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained)); }; return Ok(__ret); }) } -const INPUT_SIZE_586: usize = 2; -const IN_586: usize = 2; -const OUT_586: usize = 1; -fn aiur_fn_586( - inp: [G; IN_586], +const INPUT_SIZE_582: usize = 2; +const IN_582: usize = 2; +const OUT_582: usize = 1; +fn aiur_fn_582( + inp: [G; IN_582], record: &mut QueryRecord, io_buffer: &mut IOBuffer, unconstrained: bool, -) -> Result<[G; OUT_586], ExecError> { +) -> Result<[G; OUT_582], ExecError> { stacker::maybe_grow(64 * 1024, 4 * 1024 * 1024, || { let __v_0: G = inp[0]; let __v_1: G = inp[1]; match __v_1.as_canonical_u64() { 0u64 => { - let __ret: [G; OUT_586] = [__v_0]; - if let Some(result) = record.function_queries[586].get_mut(&inp[..]) { debug_assert_eq!(result.output, &__ret[..]); if !unconstrained { *result.multiplicity += G::ONE; } } else { record.function_queries[586].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained)); }; + let __ret: [G; OUT_582] = [__v_0]; + if let Some(result) = record.function_queries[582].get_mut(&inp[..]) { debug_assert_eq!(result.output, &__ret[..]); if !unconstrained { *result.multiplicity += G::ONE; } } else { record.function_queries[582].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained)); }; return Ok(__ret); }, _ => { @@ -50276,10 +49992,10 @@ fn aiur_fn_586( 5u64 => { let __v_6: G = G::from_u64(1); let __v_7: G = (__v_1 - __v_6); - let __r_arr: [G; OUT_586] = { let __args: [G; IN_586] = [__v_4, __v_7]; let __cu = unconstrained; if let Some(result) = record.function_queries[586].get_mut(&__args[..]) { if !__cu && *result.multiplicity == G::ZERO { aiur_fn_586(__args, record, io_buffer, false)? } else { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_586] = unsafe { *(result.output.as_ptr() as *const [G; OUT_586]) }; __ret } } else { aiur_fn_586(__args, record, io_buffer, __cu)? } }; + let __r_arr: [G; OUT_582] = { let __args: [G; IN_582] = [__v_4, __v_7]; let __cu = unconstrained; if let Some(result) = record.function_queries[582].get_mut(&__args[..]) { if !__cu && *result.multiplicity == G::ZERO { aiur_fn_582(__args, record, io_buffer, false)? } else { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_582] = unsafe { *(result.output.as_ptr() as *const [G; OUT_582]) }; __ret } } else { aiur_fn_582(__args, record, io_buffer, __cu)? } }; let __v_8: G = __r_arr[0]; - let __ret: [G; OUT_586] = [__v_8]; - if let Some(result) = record.function_queries[586].get_mut(&inp[..]) { debug_assert_eq!(result.output, &__ret[..]); if !unconstrained { *result.multiplicity += G::ONE; } } else { record.function_queries[586].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained)); }; + let __ret: [G; OUT_582] = [__v_8]; + if let Some(result) = record.function_queries[582].get_mut(&inp[..]) { debug_assert_eq!(result.output, &__ret[..]); if !unconstrained { *result.multiplicity += G::ONE; } } else { record.function_queries[582].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained)); }; return Ok(__ret); }, _ => { @@ -50291,29 +50007,29 @@ fn aiur_fn_586( }) } -const INPUT_SIZE_587: usize = 3; -const IN_587: usize = 3; -const OUT_587: usize = 0; -fn aiur_fn_587( - inp: [G; IN_587], +const INPUT_SIZE_583: usize = 3; +const IN_583: usize = 3; +const OUT_583: usize = 0; +fn aiur_fn_583( + inp: [G; IN_583], record: &mut QueryRecord, io_buffer: &mut IOBuffer, unconstrained: bool, -) -> Result<[G; OUT_587], ExecError> { +) -> Result<[G; OUT_583], ExecError> { stacker::maybe_grow(64 * 1024, 4 * 1024 * 1024, || { let __v_0: G = inp[0]; let __v_1: G = inp[1]; let __v_2: G = inp[2]; match __v_1.as_canonical_u64() { 0u64 => { - let __r_arr: [G; OUT_764] = { let __args: [G; IN_764] = [__v_0]; let __cu = unconstrained; if let Some(result) = record.function_queries[764].get_mut(&__args[..]) { if !__cu && *result.multiplicity == G::ZERO { aiur_fn_764(__args, record, io_buffer, false)? } else { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_764] = unsafe { *(result.output.as_ptr() as *const [G; OUT_764]) }; __ret } } else { aiur_fn_764(__args, record, io_buffer, __cu)? } }; + let __r_arr: [G; OUT_760] = { let __args: [G; IN_760] = [__v_0]; let __cu = unconstrained; if let Some(result) = record.function_queries[760].get_mut(&__args[..]) { if !__cu && *result.multiplicity == G::ZERO { aiur_fn_760(__args, record, io_buffer, false)? } else { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_760] = unsafe { *(result.output.as_ptr() as *const [G; OUT_760]) }; __ret } } else { aiur_fn_760(__args, record, io_buffer, __cu)? } }; let __v_3: G = __r_arr[0]; let __v_4: G = G::from_u64(0); if (__v_3 != __v_4) { return Err(ExecError::AssertEqMismatch { lhs: __v_3.as_canonical_u64(), rhs: __v_4.as_canonical_u64(), msg: Some("more universe levels than the inductive declares".to_string()) }); } - let __ret: [G; OUT_587] = []; - if let Some(result) = record.function_queries[587].get_mut(&inp[..]) { debug_assert_eq!(result.output, &__ret[..]); if !unconstrained { *result.multiplicity += G::ONE; } } else { record.function_queries[587].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained)); }; + let __ret: [G; OUT_583] = []; + if let Some(result) = record.function_queries[583].get_mut(&inp[..]) { debug_assert_eq!(result.output, &__ret[..]); if !unconstrained { *result.multiplicity += G::ONE; } } else { record.function_queries[583].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained)); }; return Ok(__ret); }, _ => { @@ -50333,12 +50049,12 @@ fn aiur_fn_587( let __v_10: G = (__v_1 - __v_9); let __v_11: G = G::from_u64(1); let __v_12: G = (__v_2 + __v_11); - let __r_arr: [G; OUT_587] = { let __args: [G; IN_587] = [__v_5, __v_10, __v_12]; let __cu = unconstrained; if let Some(result) = record.function_queries[587].get_mut(&__args[..]) { if !__cu && *result.multiplicity == G::ZERO { aiur_fn_587(__args, record, io_buffer, false)? } else { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_587] = unsafe { *(result.output.as_ptr() as *const [G; OUT_587]) }; __ret } } else { aiur_fn_587(__args, record, io_buffer, __cu)? } }; + let __r_arr: [G; OUT_583] = { let __args: [G; IN_583] = [__v_5, __v_10, __v_12]; let __cu = unconstrained; if let Some(result) = record.function_queries[583].get_mut(&__args[..]) { if !__cu && *result.multiplicity == G::ZERO { aiur_fn_583(__args, record, io_buffer, false)? } else { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_583] = unsafe { *(result.output.as_ptr() as *const [G; OUT_583]) }; __ret } } else { aiur_fn_583(__args, record, io_buffer, __cu)? } }; if (__v_7 != __v_2) { return Err(ExecError::AssertEqMismatch { lhs: __v_7.as_canonical_u64(), rhs: __v_2.as_canonical_u64(), msg: Some("ctor return type: universe level is not Param(i) in order".to_string()) }); } - let __ret: [G; OUT_587] = []; - if let Some(result) = record.function_queries[587].get_mut(&inp[..]) { debug_assert_eq!(result.output, &__ret[..]); if !unconstrained { *result.multiplicity += G::ONE; } } else { record.function_queries[587].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained)); }; + let __ret: [G; OUT_583] = []; + if let Some(result) = record.function_queries[583].get_mut(&inp[..]) { debug_assert_eq!(result.output, &__ret[..]); if !unconstrained { *result.multiplicity += G::ONE; } } else { record.function_queries[583].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained)); }; return Ok(__ret); }, _ => { @@ -50355,15 +50071,15 @@ fn aiur_fn_587( }) } -const INPUT_SIZE_588: usize = 4; -const IN_588: usize = 4; -const OUT_588: usize = 0; -fn aiur_fn_588( - inp: [G; IN_588], +const INPUT_SIZE_584: usize = 4; +const IN_584: usize = 4; +const OUT_584: usize = 0; +fn aiur_fn_584( + inp: [G; IN_584], record: &mut QueryRecord, io_buffer: &mut IOBuffer, unconstrained: bool, -) -> Result<[G; OUT_588], ExecError> { +) -> Result<[G; OUT_584], ExecError> { stacker::maybe_grow(64 * 1024, 4 * 1024 * 1024, || { let __v_0: G = inp[0]; let __v_1: G = inp[1]; @@ -50372,8 +50088,8 @@ fn aiur_fn_588( let __v_4: G = (__v_1 - __v_3); match __v_4.as_canonical_u64() { 0u64 => { - let __ret: [G; OUT_588] = []; - if let Some(result) = record.function_queries[588].get_mut(&inp[..]) { debug_assert_eq!(result.output, &__ret[..]); if !unconstrained { *result.multiplicity += G::ONE; } } else { record.function_queries[588].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained)); }; + let __ret: [G; OUT_584] = []; + if let Some(result) = record.function_queries[584].get_mut(&inp[..]) { debug_assert_eq!(result.output, &__ret[..]); if !unconstrained { *result.multiplicity += G::ONE; } } else { record.function_queries[584].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained)); }; return Ok(__ret); }, _ => { @@ -50392,7 +50108,7 @@ fn aiur_fn_588( 0u64 => { let __v_12: G = G::from_u64(1); let __v_13: G = (__v_3 + __v_12); - let __r_arr: [G; OUT_588] = { let __args: [G; IN_588] = [__v_7, __v_1, __v_2, __v_13]; let __cu = unconstrained; if let Some(result) = record.function_queries[588].get_mut(&__args[..]) { if !__cu && *result.multiplicity == G::ZERO { aiur_fn_588(__args, record, io_buffer, false)? } else { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_588] = unsafe { *(result.output.as_ptr() as *const [G; OUT_588]) }; __ret } } else { aiur_fn_588(__args, record, io_buffer, __cu)? } }; + let __r_arr: [G; OUT_584] = { let __args: [G; IN_584] = [__v_7, __v_1, __v_2, __v_13]; let __cu = unconstrained; if let Some(result) = record.function_queries[584].get_mut(&__args[..]) { if !__cu && *result.multiplicity == G::ZERO { aiur_fn_584(__args, record, io_buffer, false)? } else { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_584] = unsafe { *(result.output.as_ptr() as *const [G; OUT_584]) }; __ret } } else { aiur_fn_584(__args, record, io_buffer, __cu)? } }; let __v_14: G = (__v_2 + __v_1); let __v_15: G = G::from_u64(1); let __v_16: G = (__v_14 - __v_15); @@ -50400,8 +50116,8 @@ fn aiur_fn_588( if (__v_9 != __v_17) { return Err(ExecError::AssertEqMismatch { lhs: __v_9.as_canonical_u64(), rhs: __v_17.as_canonical_u64(), msg: Some("ctor return type: param arg is not the expected param BVar".to_string()) }); } - let __ret: [G; OUT_588] = []; - if let Some(result) = record.function_queries[588].get_mut(&inp[..]) { debug_assert_eq!(result.output, &__ret[..]); if !unconstrained { *result.multiplicity += G::ONE; } } else { record.function_queries[588].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained)); }; + let __ret: [G; OUT_584] = []; + if let Some(result) = record.function_queries[584].get_mut(&inp[..]) { debug_assert_eq!(result.output, &__ret[..]); if !unconstrained { *result.multiplicity += G::ONE; } } else { record.function_queries[584].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained)); }; return Ok(__ret); }, _ => { @@ -50418,20 +50134,20 @@ fn aiur_fn_588( }) } -const INPUT_SIZE_589: usize = 3; -const IN_589: usize = 3; -const OUT_589: usize = 0; -fn aiur_fn_589( - inp: [G; IN_589], +const INPUT_SIZE_585: usize = 3; +const IN_585: usize = 3; +const OUT_585: usize = 0; +fn aiur_fn_585( + inp: [G; IN_585], record: &mut QueryRecord, io_buffer: &mut IOBuffer, unconstrained: bool, -) -> Result<[G; OUT_589], ExecError> { +) -> Result<[G; OUT_585], ExecError> { stacker::maybe_grow(64 * 1024, 4 * 1024 * 1024, || { let __v_0: G = inp[0]; let __v_1: G = inp[1]; let __v_2: G = inp[2]; - let __r_arr: [G; OUT_287] = { let __args: [G; IN_287] = [__v_0]; let __cu = unconstrained; if let Some(result) = record.function_queries[287].get_mut(&__args[..]) { if !__cu && *result.multiplicity == G::ZERO { aiur_fn_287(__args, record, io_buffer, false)? } else { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_287] = unsafe { *(result.output.as_ptr() as *const [G; OUT_287]) }; __ret } } else { aiur_fn_287(__args, record, io_buffer, __cu)? } }; + let __r_arr: [G; OUT_283] = { let __args: [G; IN_283] = [__v_0]; let __cu = unconstrained; if let Some(result) = record.function_queries[283].get_mut(&__args[..]) { if !__cu && *result.multiplicity == G::ZERO { aiur_fn_283(__args, record, io_buffer, false)? } else { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_283] = unsafe { *(result.output.as_ptr() as *const [G; OUT_283]) }; __ret } } else { aiur_fn_283(__args, record, io_buffer, __cu)? } }; let __v_3: G = __r_arr[0]; let __loaded: [G; 12] = { let __mq = record.memory_queries.get_mut(&12).ok_or(ExecError::InvalidMemorySize(12))?; let __ptr_u64 = __v_3.as_canonical_u64(); let __ptr_usize = usize::try_from(__ptr_u64).ok().ok_or(ExecError::PointerTooLarge(__ptr_u64))?; let (__args, __mult) = __mq.get_index_mut(__ptr_usize).ok_or(ExecError::UnboundPointer { ptr: __ptr_u64, size: 12 })?; if !unconstrained { *__mult += G::ONE; } let __arr: [G; 12] = __args[..12].try_into().unwrap(); __arr }; let __v_4: G = __loaded[0]; @@ -50457,8 +50173,8 @@ fn aiur_fn_589( if (__v_12 != __v_2) { return Err(ExecError::AssertEqMismatch { lhs: __v_12.as_canonical_u64(), rhs: __v_2.as_canonical_u64(), msg: Some("ctor return head is a different member of the block".to_string()) }); } - let __ret: [G; OUT_589] = []; - if let Some(result) = record.function_queries[589].get_mut(&inp[..]) { debug_assert_eq!(result.output, &__ret[..]); if !unconstrained { *result.multiplicity += G::ONE; } } else { record.function_queries[589].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained)); }; + let __ret: [G; OUT_585] = []; + if let Some(result) = record.function_queries[585].get_mut(&inp[..]) { debug_assert_eq!(result.output, &__ret[..]); if !unconstrained { *result.multiplicity += G::ONE; } } else { record.function_queries[585].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained)); }; return Ok(__ret); }, _ => { @@ -50468,15 +50184,15 @@ fn aiur_fn_589( }) } -const INPUT_SIZE_590: usize = 7; -const IN_590: usize = 7; -const OUT_590: usize = 0; -fn aiur_fn_590( - inp: [G; IN_590], +const INPUT_SIZE_586: usize = 7; +const IN_586: usize = 7; +const OUT_586: usize = 0; +fn aiur_fn_586( + inp: [G; IN_586], record: &mut QueryRecord, io_buffer: &mut IOBuffer, unconstrained: bool, -) -> Result<[G; OUT_590], ExecError> { +) -> Result<[G; OUT_586], ExecError> { stacker::maybe_grow(64 * 1024, 4 * 1024 * 1024, || { let __v_0: G = inp[0]; let __v_1: G = inp[1]; @@ -50486,7 +50202,7 @@ fn aiur_fn_590( let __v_5: G = inp[5]; let __v_6: G = inp[6]; let __v_7: G = (__v_1 + __v_3); - let __r_arr: [G; OUT_586] = { let __args: [G; IN_586] = [__v_0, __v_7]; let __cu = unconstrained; if let Some(result) = record.function_queries[586].get_mut(&__args[..]) { if !__cu && *result.multiplicity == G::ZERO { aiur_fn_586(__args, record, io_buffer, false)? } else { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_586] = unsafe { *(result.output.as_ptr() as *const [G; OUT_586]) }; __ret } } else { aiur_fn_586(__args, record, io_buffer, __cu)? } }; + let __r_arr: [G; OUT_582] = { let __args: [G; IN_582] = [__v_0, __v_7]; let __cu = unconstrained; if let Some(result) = record.function_queries[582].get_mut(&__args[..]) { if !__cu && *result.multiplicity == G::ZERO { aiur_fn_582(__args, record, io_buffer, false)? } else { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_582] = unsafe { *(result.output.as_ptr() as *const [G; OUT_582]) }; __ret } } else { aiur_fn_582(__args, record, io_buffer, __cu)? } }; let __v_8: G = __r_arr[0]; let __r_arr: [G; OUT_111] = { let __args: [G; IN_111] = [__v_8]; let __cu = unconstrained; if let Some(result) = record.function_queries[111].get_mut(&__args[..]) { if !__cu && *result.multiplicity == G::ZERO { aiur_fn_111(__args, record, io_buffer, false)? } else { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_111] = unsafe { *(result.output.as_ptr() as *const [G; OUT_111]) }; __ret } } else { aiur_fn_111(__args, record, io_buffer, __cu)? } }; let __v_9: G = __r_arr[0]; @@ -50498,32 +50214,32 @@ fn aiur_fn_590( let __v_14: G = __loaded[3]; match __v_11.as_canonical_u64() { 2u64 => { - let __r_arr: [G; OUT_589] = { let __args: [G; IN_589] = [__v_12, __v_5, __v_6]; let __cu = unconstrained; if let Some(result) = record.function_queries[589].get_mut(&__args[..]) { if !__cu && *result.multiplicity == G::ZERO { aiur_fn_589(__args, record, io_buffer, false)? } else { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_589] = unsafe { *(result.output.as_ptr() as *const [G; OUT_589]) }; __ret } } else { aiur_fn_589(__args, record, io_buffer, __cu)? } }; + let __r_arr: [G; OUT_585] = { let __args: [G; IN_585] = [__v_12, __v_5, __v_6]; let __cu = unconstrained; if let Some(result) = record.function_queries[585].get_mut(&__args[..]) { if !__cu && *result.multiplicity == G::ZERO { aiur_fn_585(__args, record, io_buffer, false)? } else { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_585] = unsafe { *(result.output.as_ptr() as *const [G; OUT_585]) }; __ret } } else { aiur_fn_585(__args, record, io_buffer, __cu)? } }; let __v_15: G = G::from_u64(0); - let __r_arr: [G; OUT_587] = { let __args: [G; IN_587] = [__v_13, __v_4, __v_15]; let __cu = unconstrained; if let Some(result) = record.function_queries[587].get_mut(&__args[..]) { if !__cu && *result.multiplicity == G::ZERO { aiur_fn_587(__args, record, io_buffer, false)? } else { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_587] = unsafe { *(result.output.as_ptr() as *const [G; OUT_587]) }; __ret } } else { aiur_fn_587(__args, record, io_buffer, __cu)? } }; + let __r_arr: [G; OUT_583] = { let __args: [G; IN_583] = [__v_13, __v_4, __v_15]; let __cu = unconstrained; if let Some(result) = record.function_queries[583].get_mut(&__args[..]) { if !__cu && *result.multiplicity == G::ZERO { aiur_fn_583(__args, record, io_buffer, false)? } else { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_583] = unsafe { *(result.output.as_ptr() as *const [G; OUT_583]) }; __ret } } else { aiur_fn_583(__args, record, io_buffer, __cu)? } }; let __v_16: G = G::from_u64(0); - let __r_arr: [G; OUT_588] = { let __args: [G; IN_588] = [__v_10, __v_1, __v_3, __v_16]; let __cu = unconstrained; if let Some(result) = record.function_queries[588].get_mut(&__args[..]) { if !__cu && *result.multiplicity == G::ZERO { aiur_fn_588(__args, record, io_buffer, false)? } else { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_588] = unsafe { *(result.output.as_ptr() as *const [G; OUT_588]) }; __ret } } else { aiur_fn_588(__args, record, io_buffer, __cu)? } }; - let __r_arr: [G; OUT_775] = { let __args: [G; IN_775] = [__v_10, __v_1]; let __cu = unconstrained; if let Some(result) = record.function_queries[775].get_mut(&__args[..]) { if !__cu && *result.multiplicity == G::ZERO { aiur_fn_775(__args, record, io_buffer, false)? } else { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_775] = unsafe { *(result.output.as_ptr() as *const [G; OUT_775]) }; __ret } } else { aiur_fn_775(__args, record, io_buffer, __cu)? } }; + let __r_arr: [G; OUT_584] = { let __args: [G; IN_584] = [__v_10, __v_1, __v_3, __v_16]; let __cu = unconstrained; if let Some(result) = record.function_queries[584].get_mut(&__args[..]) { if !__cu && *result.multiplicity == G::ZERO { aiur_fn_584(__args, record, io_buffer, false)? } else { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_584] = unsafe { *(result.output.as_ptr() as *const [G; OUT_584]) }; __ret } } else { aiur_fn_584(__args, record, io_buffer, __cu)? } }; + let __r_arr: [G; OUT_771] = { let __args: [G; IN_771] = [__v_10, __v_1]; let __cu = unconstrained; if let Some(result) = record.function_queries[771].get_mut(&__args[..]) { if !__cu && *result.multiplicity == G::ZERO { aiur_fn_771(__args, record, io_buffer, false)? } else { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_771] = unsafe { *(result.output.as_ptr() as *const [G; OUT_771]) }; __ret } } else { aiur_fn_771(__args, record, io_buffer, __cu)? } }; let __v_17: G = __r_arr[0]; let __v_18: G = G::from_u64(0); let __v_19: G = G::from_u64(1); let __v_20: G = G::from_u64(1); let __v_21: G = { let __values: [G; 3] = [__v_19, __v_20, __v_20]; let __mq = record.memory_queries.get_mut(&3).ok_or(ExecError::InvalidMemorySize(3))?; if let Some(result) = __mq.get_mut(&__values[..]) { if !unconstrained { *result.multiplicity += G::ONE; } result.output[0] } else { let __ptr = G::from_usize(__mq.len()); __mq.insert(&__values[..], &[__ptr], G::from_bool(!unconstrained)); __ptr } }; let __v_22: G = { let __values: [G; 3] = [__v_18, __v_5, __v_21]; let __mq = record.memory_queries.get_mut(&3).ok_or(ExecError::InvalidMemorySize(3))?; if let Some(result) = __mq.get_mut(&__values[..]) { if !unconstrained { *result.multiplicity += G::ONE; } result.output[0] } else { let __ptr = G::from_usize(__mq.len()); __mq.insert(&__values[..], &[__ptr], G::from_bool(!unconstrained)); __ptr } }; - let __r_arr: [G; OUT_764] = { let __args: [G; IN_764] = [__v_10]; let __cu = unconstrained; if let Some(result) = record.function_queries[764].get_mut(&__args[..]) { if !__cu && *result.multiplicity == G::ZERO { aiur_fn_764(__args, record, io_buffer, false)? } else { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_764] = unsafe { *(result.output.as_ptr() as *const [G; OUT_764]) }; __ret } } else { aiur_fn_764(__args, record, io_buffer, __cu)? } }; + let __r_arr: [G; OUT_760] = { let __args: [G; IN_760] = [__v_10]; let __cu = unconstrained; if let Some(result) = record.function_queries[760].get_mut(&__args[..]) { if !__cu && *result.multiplicity == G::ZERO { aiur_fn_760(__args, record, io_buffer, false)? } else { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_760] = unsafe { *(result.output.as_ptr() as *const [G; OUT_760]) }; __ret } } else { aiur_fn_760(__args, record, io_buffer, __cu)? } }; let __v_23: G = __r_arr[0]; let __v_24: G = (__v_1 + __v_2); if (__v_23 != __v_24) { return Err(ExecError::AssertEqMismatch { lhs: __v_23.as_canonical_u64(), rhs: __v_24.as_canonical_u64(), msg: Some("ctor return type: wrong number of spine arguments".to_string()) }); } - let __r_arr: [G; OUT_601] = { let __args: [G; IN_601] = [__v_17, __v_22]; let __cu = unconstrained; if let Some(result) = record.function_queries[601].get_mut(&__args[..]) { if !__cu && *result.multiplicity == G::ZERO { aiur_fn_601(__args, record, io_buffer, false)? } else { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_601] = unsafe { *(result.output.as_ptr() as *const [G; OUT_601]) }; __ret } } else { aiur_fn_601(__args, record, io_buffer, __cu)? } }; + let __r_arr: [G; OUT_597] = { let __args: [G; IN_597] = [__v_17, __v_22]; let __cu = unconstrained; if let Some(result) = record.function_queries[597].get_mut(&__args[..]) { if !__cu && *result.multiplicity == G::ZERO { aiur_fn_597(__args, record, io_buffer, false)? } else { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_597] = unsafe { *(result.output.as_ptr() as *const [G; OUT_597]) }; __ret } } else { aiur_fn_597(__args, record, io_buffer, __cu)? } }; let __v_25: G = __r_arr[0]; let __v_26: G = G::from_u64(0); if (__v_25 != __v_26) { return Err(ExecError::AssertEqMismatch { lhs: __v_25.as_canonical_u64(), rhs: __v_26.as_canonical_u64(), msg: Some("ctor return type: reflexive occurrence in an index argument".to_string()) }); } - let __ret: [G; OUT_590] = []; - if let Some(result) = record.function_queries[590].get_mut(&inp[..]) { debug_assert_eq!(result.output, &__ret[..]); if !unconstrained { *result.multiplicity += G::ONE; } } else { record.function_queries[590].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained)); }; + let __ret: [G; OUT_586] = []; + if let Some(result) = record.function_queries[586].get_mut(&inp[..]) { debug_assert_eq!(result.output, &__ret[..]); if !unconstrained { *result.multiplicity += G::ONE; } } else { record.function_queries[586].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained)); }; return Ok(__ret); }, _ => { @@ -50533,15 +50249,15 @@ fn aiur_fn_590( }) } -const INPUT_SIZE_591: usize = 4; -const IN_591: usize = 4; -const OUT_591: usize = 0; -fn aiur_fn_591( - inp: [G; IN_591], +const INPUT_SIZE_587: usize = 4; +const IN_587: usize = 4; +const OUT_587: usize = 0; +fn aiur_fn_587( + inp: [G; IN_587], record: &mut QueryRecord, io_buffer: &mut IOBuffer, unconstrained: bool, -) -> Result<[G; OUT_591], ExecError> { +) -> Result<[G; OUT_587], ExecError> { stacker::maybe_grow(64 * 1024, 4 * 1024 * 1024, || { let __v_0: G = inp[0]; let __v_1: G = inp[1]; @@ -50549,8 +50265,8 @@ fn aiur_fn_591( let __v_3: G = inp[3]; match __v_2.as_canonical_u64() { 0u64 => { - let __ret: [G; OUT_591] = []; - if let Some(result) = record.function_queries[591].get_mut(&inp[..]) { debug_assert_eq!(result.output, &__ret[..]); if !unconstrained { *result.multiplicity += G::ONE; } } else { record.function_queries[591].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained)); }; + let __ret: [G; OUT_587] = []; + if let Some(result) = record.function_queries[587].get_mut(&inp[..]) { debug_assert_eq!(result.output, &__ret[..]); if !unconstrained { *result.multiplicity += G::ONE; } } else { record.function_queries[587].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained)); }; return Ok(__ret); }, _ => { @@ -50568,7 +50284,7 @@ fn aiur_fn_591( let __v_11: G = __loaded[3]; match __v_8.as_canonical_u64() { 5u64 => { - let __r_arr: [G; OUT_439] = { let __args: [G; IN_439] = [__v_5, __v_9, __v_3]; let __cu = unconstrained; if let Some(result) = record.function_queries[439].get_mut(&__args[..]) { if !__cu && *result.multiplicity == G::ZERO { aiur_fn_439(__args, record, io_buffer, false)? } else { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_439] = unsafe { *(result.output.as_ptr() as *const [G; OUT_439]) }; __ret } } else { aiur_fn_439(__args, record, io_buffer, __cu)? } }; + let __r_arr: [G; OUT_435] = { let __args: [G; IN_435] = [__v_5, __v_9, __v_3]; let __cu = unconstrained; if let Some(result) = record.function_queries[435].get_mut(&__args[..]) { if !__cu && *result.multiplicity == G::ZERO { aiur_fn_435(__args, record, io_buffer, false)? } else { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_435] = unsafe { *(result.output.as_ptr() as *const [G; OUT_435]) }; __ret } } else { aiur_fn_435(__args, record, io_buffer, __cu)? } }; let __v_12: G = __r_arr[0]; let __v_13: G = G::from_u64(0); let __v_14: G = { let __values: [G; 3] = [__v_13, __v_5, __v_3]; let __mq = record.memory_queries.get_mut(&3).ok_or(ExecError::InvalidMemorySize(3))?; if let Some(result) = __mq.get_mut(&__values[..]) { if !unconstrained { *result.multiplicity += G::ONE; } result.output[0] } else { let __ptr = G::from_usize(__mq.len()); __mq.insert(&__values[..], &[__ptr], G::from_bool(!unconstrained)); __ptr } }; @@ -50578,9 +50294,9 @@ fn aiur_fn_591( } let __v_16: G = G::from_u64(1); let __v_17: G = (__v_2 - __v_16); - let __r_arr: [G; OUT_591] = { let __args: [G; IN_591] = [__v_6, __v_10, __v_17, __v_14]; let __cu = unconstrained; if let Some(result) = record.function_queries[591].get_mut(&__args[..]) { if !__cu && *result.multiplicity == G::ZERO { aiur_fn_591(__args, record, io_buffer, false)? } else { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_591] = unsafe { *(result.output.as_ptr() as *const [G; OUT_591]) }; __ret } } else { aiur_fn_591(__args, record, io_buffer, __cu)? } }; - let __ret: [G; OUT_591] = []; - if let Some(result) = record.function_queries[591].get_mut(&inp[..]) { debug_assert_eq!(result.output, &__ret[..]); if !unconstrained { *result.multiplicity += G::ONE; } } else { record.function_queries[591].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained)); }; + let __r_arr: [G; OUT_587] = { let __args: [G; IN_587] = [__v_6, __v_10, __v_17, __v_14]; let __cu = unconstrained; if let Some(result) = record.function_queries[587].get_mut(&__args[..]) { if !__cu && *result.multiplicity == G::ZERO { aiur_fn_587(__args, record, io_buffer, false)? } else { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_587] = unsafe { *(result.output.as_ptr() as *const [G; OUT_587]) }; __ret } } else { aiur_fn_587(__args, record, io_buffer, __cu)? } }; + let __ret: [G; OUT_587] = []; + if let Some(result) = record.function_queries[587].get_mut(&inp[..]) { debug_assert_eq!(result.output, &__ret[..]); if !unconstrained { *result.multiplicity += G::ONE; } } else { record.function_queries[587].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained)); }; return Ok(__ret); }, _ => { @@ -50597,15 +50313,15 @@ fn aiur_fn_591( }) } -const INPUT_SIZE_592: usize = 3; -const IN_592: usize = 3; -const OUT_592: usize = 0; -fn aiur_fn_592( - inp: [G; IN_592], +const INPUT_SIZE_588: usize = 3; +const IN_588: usize = 3; +const OUT_588: usize = 0; +fn aiur_fn_588( + inp: [G; IN_588], record: &mut QueryRecord, io_buffer: &mut IOBuffer, unconstrained: bool, -) -> Result<[G; OUT_592], ExecError> { +) -> Result<[G; OUT_588], ExecError> { stacker::maybe_grow(64 * 1024, 4 * 1024 * 1024, || { let __v_0: G = inp[0]; let __v_1: G = inp[1]; @@ -50613,27 +50329,27 @@ fn aiur_fn_592( let __v_3: G = G::from_u64(1); let __v_4: G = G::from_u64(1); let __v_5: G = { let __values: [G; 3] = [__v_3, __v_4, __v_4]; let __mq = record.memory_queries.get_mut(&3).ok_or(ExecError::InvalidMemorySize(3))?; if let Some(result) = __mq.get_mut(&__values[..]) { if !unconstrained { *result.multiplicity += G::ONE; } result.output[0] } else { let __ptr = G::from_usize(__mq.len()); __mq.insert(&__values[..], &[__ptr], G::from_bool(!unconstrained)); __ptr } }; - let __r_arr: [G; OUT_591] = { let __args: [G; IN_591] = [__v_0, __v_1, __v_2, __v_5]; let __cu = unconstrained; if let Some(result) = record.function_queries[591].get_mut(&__args[..]) { if !__cu && *result.multiplicity == G::ZERO { aiur_fn_591(__args, record, io_buffer, false)? } else { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_591] = unsafe { *(result.output.as_ptr() as *const [G; OUT_591]) }; __ret } } else { aiur_fn_591(__args, record, io_buffer, __cu)? } }; - let __ret: [G; OUT_592] = []; - if let Some(result) = record.function_queries[592].get_mut(&inp[..]) { debug_assert_eq!(result.output, &__ret[..]); if !unconstrained { *result.multiplicity += G::ONE; } } else { record.function_queries[592].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained)); }; + let __r_arr: [G; OUT_587] = { let __args: [G; IN_587] = [__v_0, __v_1, __v_2, __v_5]; let __cu = unconstrained; if let Some(result) = record.function_queries[587].get_mut(&__args[..]) { if !__cu && *result.multiplicity == G::ZERO { aiur_fn_587(__args, record, io_buffer, false)? } else { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_587] = unsafe { *(result.output.as_ptr() as *const [G; OUT_587]) }; __ret } } else { aiur_fn_587(__args, record, io_buffer, __cu)? } }; + let __ret: [G; OUT_588] = []; + if let Some(result) = record.function_queries[588].get_mut(&inp[..]) { debug_assert_eq!(result.output, &__ret[..]); if !unconstrained { *result.multiplicity += G::ONE; } } else { record.function_queries[588].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained)); }; return Ok(__ret); }) } -const INPUT_SIZE_593: usize = 3; -const IN_593: usize = 3; -const OUT_593: usize = 1; -fn aiur_fn_593( - inp: [G; IN_593], +const INPUT_SIZE_589: usize = 3; +const IN_589: usize = 3; +const OUT_589: usize = 1; +fn aiur_fn_589( + inp: [G; IN_589], record: &mut QueryRecord, io_buffer: &mut IOBuffer, unconstrained: bool, -) -> Result<[G; OUT_593], ExecError> { +) -> Result<[G; OUT_589], ExecError> { stacker::maybe_grow(64 * 1024, 4 * 1024 * 1024, || { let __v_0: G = inp[0]; let __v_1: G = inp[1]; let __v_2: G = inp[2]; - let __r_arr: [G; OUT_418] = { let __args: [G; IN_418] = [__v_0, __v_2]; let __cu = unconstrained; if let Some(result) = record.function_queries[418].get_mut(&__args[..]) { if !__cu && *result.multiplicity == G::ZERO { aiur_fn_418(__args, record, io_buffer, false)? } else { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_418] = unsafe { *(result.output.as_ptr() as *const [G; OUT_418]) }; __ret } } else { aiur_fn_418(__args, record, io_buffer, __cu)? } }; + let __r_arr: [G; OUT_414] = { let __args: [G; IN_414] = [__v_0, __v_2]; let __cu = unconstrained; if let Some(result) = record.function_queries[414].get_mut(&__args[..]) { if !__cu && *result.multiplicity == G::ZERO { aiur_fn_414(__args, record, io_buffer, false)? } else { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_414] = unsafe { *(result.output.as_ptr() as *const [G; OUT_414]) }; __ret } } else { aiur_fn_414(__args, record, io_buffer, __cu)? } }; let __v_3: G = __r_arr[0]; match __v_1.as_canonical_u64() { 0u64 => { @@ -50644,8 +50360,8 @@ fn aiur_fn_593( let __v_7: G = __loaded[3]; match __v_4.as_canonical_u64() { 1u64 => { - let __ret: [G; OUT_593] = [__v_5]; - if let Some(result) = record.function_queries[593].get_mut(&inp[..]) { debug_assert_eq!(result.output, &__ret[..]); if !unconstrained { *result.multiplicity += G::ONE; } } else { record.function_queries[593].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained)); }; + let __ret: [G; OUT_589] = [__v_5]; + if let Some(result) = record.function_queries[589].get_mut(&inp[..]) { debug_assert_eq!(result.output, &__ret[..]); if !unconstrained { *result.multiplicity += G::ONE; } } else { record.function_queries[589].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained)); }; return Ok(__ret); }, _ => { @@ -50665,10 +50381,10 @@ fn aiur_fn_593( let __v_9: G = (__v_1 - __v_8); let __v_10: G = G::from_u64(0); let __v_11: G = { let __values: [G; 3] = [__v_10, __v_5, __v_2]; let __mq = record.memory_queries.get_mut(&3).ok_or(ExecError::InvalidMemorySize(3))?; if let Some(result) = __mq.get_mut(&__values[..]) { if !unconstrained { *result.multiplicity += G::ONE; } result.output[0] } else { let __ptr = G::from_usize(__mq.len()); __mq.insert(&__values[..], &[__ptr], G::from_bool(!unconstrained)); __ptr } }; - let __r_arr: [G; OUT_593] = { let __args: [G; IN_593] = [__v_6, __v_9, __v_11]; let __cu = unconstrained; if let Some(result) = record.function_queries[593].get_mut(&__args[..]) { if !__cu && *result.multiplicity == G::ZERO { aiur_fn_593(__args, record, io_buffer, false)? } else { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_593] = unsafe { *(result.output.as_ptr() as *const [G; OUT_593]) }; __ret } } else { aiur_fn_593(__args, record, io_buffer, __cu)? } }; + let __r_arr: [G; OUT_589] = { let __args: [G; IN_589] = [__v_6, __v_9, __v_11]; let __cu = unconstrained; if let Some(result) = record.function_queries[589].get_mut(&__args[..]) { if !__cu && *result.multiplicity == G::ZERO { aiur_fn_589(__args, record, io_buffer, false)? } else { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_589] = unsafe { *(result.output.as_ptr() as *const [G; OUT_589]) }; __ret } } else { aiur_fn_589(__args, record, io_buffer, __cu)? } }; let __v_12: G = __r_arr[0]; - let __ret: [G; OUT_593] = [__v_12]; - if let Some(result) = record.function_queries[593].get_mut(&inp[..]) { debug_assert_eq!(result.output, &__ret[..]); if !unconstrained { *result.multiplicity += G::ONE; } } else { record.function_queries[593].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained)); }; + let __ret: [G; OUT_589] = [__v_12]; + if let Some(result) = record.function_queries[589].get_mut(&inp[..]) { debug_assert_eq!(result.output, &__ret[..]); if !unconstrained { *result.multiplicity += G::ONE; } } else { record.function_queries[589].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained)); }; return Ok(__ret); }, _ => { @@ -50680,15 +50396,15 @@ fn aiur_fn_593( }) } -const INPUT_SIZE_594: usize = 3; -const IN_594: usize = 3; -const OUT_594: usize = 0; -fn aiur_fn_594( - inp: [G; IN_594], +const INPUT_SIZE_590: usize = 3; +const IN_590: usize = 3; +const OUT_590: usize = 0; +fn aiur_fn_590( + inp: [G; IN_590], record: &mut QueryRecord, io_buffer: &mut IOBuffer, unconstrained: bool, -) -> Result<[G; OUT_594], ExecError> { +) -> Result<[G; OUT_590], ExecError> { stacker::maybe_grow(64 * 1024, 4 * 1024 * 1024, || { let __v_0: G = inp[0]; let __v_1: G = inp[1]; @@ -50700,9 +50416,9 @@ fn aiur_fn_594( let __v_6: G = __loaded[3]; match __v_3.as_canonical_u64() { 5u64 => { - let __r_arr: [G; OUT_499] = { let __args: [G; IN_499] = [__v_4, __v_2]; let __cu = unconstrained; if let Some(result) = record.function_queries[499].get_mut(&__args[..]) { if !__cu && *result.multiplicity == G::ZERO { aiur_fn_499(__args, record, io_buffer, false)? } else { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_499] = unsafe { *(result.output.as_ptr() as *const [G; OUT_499]) }; __ret } } else { aiur_fn_499(__args, record, io_buffer, __cu)? } }; + let __r_arr: [G; OUT_495] = { let __args: [G; IN_495] = [__v_4, __v_2]; let __cu = unconstrained; if let Some(result) = record.function_queries[495].get_mut(&__args[..]) { if !__cu && *result.multiplicity == G::ZERO { aiur_fn_495(__args, record, io_buffer, false)? } else { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_495] = unsafe { *(result.output.as_ptr() as *const [G; OUT_495]) }; __ret } } else { aiur_fn_495(__args, record, io_buffer, __cu)? } }; let __v_7: G = __r_arr[0]; - let __r_arr: [G; OUT_323] = { let __args: [G; IN_323] = [__v_7, __v_1]; let __cu = unconstrained; if let Some(result) = record.function_queries[323].get_mut(&__args[..]) { if !__cu && *result.multiplicity == G::ZERO { aiur_fn_323(__args, record, io_buffer, false)? } else { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_323] = unsafe { *(result.output.as_ptr() as *const [G; OUT_323]) }; __ret } } else { aiur_fn_323(__args, record, io_buffer, __cu)? } }; + let __r_arr: [G; OUT_319] = { let __args: [G; IN_319] = [__v_7, __v_1]; let __cu = unconstrained; if let Some(result) = record.function_queries[319].get_mut(&__args[..]) { if !__cu && *result.multiplicity == G::ZERO { aiur_fn_319(__args, record, io_buffer, false)? } else { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_319] = unsafe { *(result.output.as_ptr() as *const [G; OUT_319]) }; __ret } } else { aiur_fn_319(__args, record, io_buffer, __cu)? } }; let __v_8: G = __r_arr[0]; let __v_9: G = G::from_u64(1); if (__v_8 != __v_9) { @@ -50710,29 +50426,29 @@ fn aiur_fn_594( } let __v_10: G = G::from_u64(0); let __v_11: G = { let __values: [G; 3] = [__v_10, __v_4, __v_2]; let __mq = record.memory_queries.get_mut(&3).ok_or(ExecError::InvalidMemorySize(3))?; if let Some(result) = __mq.get_mut(&__values[..]) { if !unconstrained { *result.multiplicity += G::ONE; } result.output[0] } else { let __ptr = G::from_usize(__mq.len()); __mq.insert(&__values[..], &[__ptr], G::from_bool(!unconstrained)); __ptr } }; - let __r_arr: [G; OUT_594] = { let __args: [G; IN_594] = [__v_5, __v_1, __v_11]; let __cu = unconstrained; if let Some(result) = record.function_queries[594].get_mut(&__args[..]) { if !__cu && *result.multiplicity == G::ZERO { aiur_fn_594(__args, record, io_buffer, false)? } else { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_594] = unsafe { *(result.output.as_ptr() as *const [G; OUT_594]) }; __ret } } else { aiur_fn_594(__args, record, io_buffer, __cu)? } }; - let __ret: [G; OUT_594] = []; - if let Some(result) = record.function_queries[594].get_mut(&inp[..]) { debug_assert_eq!(result.output, &__ret[..]); if !unconstrained { *result.multiplicity += G::ONE; } } else { record.function_queries[594].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained)); }; + let __r_arr: [G; OUT_590] = { let __args: [G; IN_590] = [__v_5, __v_1, __v_11]; let __cu = unconstrained; if let Some(result) = record.function_queries[590].get_mut(&__args[..]) { if !__cu && *result.multiplicity == G::ZERO { aiur_fn_590(__args, record, io_buffer, false)? } else { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_590] = unsafe { *(result.output.as_ptr() as *const [G; OUT_590]) }; __ret } } else { aiur_fn_590(__args, record, io_buffer, __cu)? } }; + let __ret: [G; OUT_590] = []; + if let Some(result) = record.function_queries[590].get_mut(&inp[..]) { debug_assert_eq!(result.output, &__ret[..]); if !unconstrained { *result.multiplicity += G::ONE; } } else { record.function_queries[590].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained)); }; return Ok(__ret); }, _ => { - let __ret: [G; OUT_594] = []; - if let Some(result) = record.function_queries[594].get_mut(&inp[..]) { debug_assert_eq!(result.output, &__ret[..]); if !unconstrained { *result.multiplicity += G::ONE; } } else { record.function_queries[594].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained)); }; + let __ret: [G; OUT_590] = []; + if let Some(result) = record.function_queries[590].get_mut(&inp[..]) { debug_assert_eq!(result.output, &__ret[..]); if !unconstrained { *result.multiplicity += G::ONE; } } else { record.function_queries[590].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained)); }; return Ok(__ret); }, } }) } -const INPUT_SIZE_595: usize = 4; -const IN_595: usize = 4; -const OUT_595: usize = 0; -fn aiur_fn_595( - inp: [G; IN_595], +const INPUT_SIZE_591: usize = 4; +const IN_591: usize = 4; +const OUT_591: usize = 0; +fn aiur_fn_591( + inp: [G; IN_591], record: &mut QueryRecord, io_buffer: &mut IOBuffer, unconstrained: bool, -) -> Result<[G; OUT_595], ExecError> { +) -> Result<[G; OUT_591], ExecError> { stacker::maybe_grow(64 * 1024, 4 * 1024 * 1024, || { let __v_0: G = inp[0]; let __v_1: G = inp[1]; @@ -50740,9 +50456,9 @@ fn aiur_fn_595( let __v_3: G = inp[3]; match __v_1.as_canonical_u64() { 0u64 => { - let __r_arr: [G; OUT_594] = { let __args: [G; IN_594] = [__v_0, __v_2, __v_3]; let __cu = unconstrained; if let Some(result) = record.function_queries[594].get_mut(&__args[..]) { if !__cu && *result.multiplicity == G::ZERO { aiur_fn_594(__args, record, io_buffer, false)? } else { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_594] = unsafe { *(result.output.as_ptr() as *const [G; OUT_594]) }; __ret } } else { aiur_fn_594(__args, record, io_buffer, __cu)? } }; - let __ret: [G; OUT_595] = []; - if let Some(result) = record.function_queries[595].get_mut(&inp[..]) { debug_assert_eq!(result.output, &__ret[..]); if !unconstrained { *result.multiplicity += G::ONE; } } else { record.function_queries[595].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained)); }; + let __r_arr: [G; OUT_590] = { let __args: [G; IN_590] = [__v_0, __v_2, __v_3]; let __cu = unconstrained; if let Some(result) = record.function_queries[590].get_mut(&__args[..]) { if !__cu && *result.multiplicity == G::ZERO { aiur_fn_590(__args, record, io_buffer, false)? } else { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_590] = unsafe { *(result.output.as_ptr() as *const [G; OUT_590]) }; __ret } } else { aiur_fn_590(__args, record, io_buffer, __cu)? } }; + let __ret: [G; OUT_591] = []; + if let Some(result) = record.function_queries[591].get_mut(&inp[..]) { debug_assert_eq!(result.output, &__ret[..]); if !unconstrained { *result.multiplicity += G::ONE; } } else { record.function_queries[591].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained)); }; return Ok(__ret); }, _ => { @@ -50757,9 +50473,9 @@ fn aiur_fn_595( let __v_9: G = (__v_1 - __v_8); let __v_10: G = G::from_u64(0); let __v_11: G = { let __values: [G; 3] = [__v_10, __v_5, __v_3]; let __mq = record.memory_queries.get_mut(&3).ok_or(ExecError::InvalidMemorySize(3))?; if let Some(result) = __mq.get_mut(&__values[..]) { if !unconstrained { *result.multiplicity += G::ONE; } result.output[0] } else { let __ptr = G::from_usize(__mq.len()); __mq.insert(&__values[..], &[__ptr], G::from_bool(!unconstrained)); __ptr } }; - let __r_arr: [G; OUT_595] = { let __args: [G; IN_595] = [__v_6, __v_9, __v_2, __v_11]; let __cu = unconstrained; if let Some(result) = record.function_queries[595].get_mut(&__args[..]) { if !__cu && *result.multiplicity == G::ZERO { aiur_fn_595(__args, record, io_buffer, false)? } else { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_595] = unsafe { *(result.output.as_ptr() as *const [G; OUT_595]) }; __ret } } else { aiur_fn_595(__args, record, io_buffer, __cu)? } }; - let __ret: [G; OUT_595] = []; - if let Some(result) = record.function_queries[595].get_mut(&inp[..]) { debug_assert_eq!(result.output, &__ret[..]); if !unconstrained { *result.multiplicity += G::ONE; } } else { record.function_queries[595].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained)); }; + let __r_arr: [G; OUT_591] = { let __args: [G; IN_591] = [__v_6, __v_9, __v_2, __v_11]; let __cu = unconstrained; if let Some(result) = record.function_queries[591].get_mut(&__args[..]) { if !__cu && *result.multiplicity == G::ZERO { aiur_fn_591(__args, record, io_buffer, false)? } else { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_591] = unsafe { *(result.output.as_ptr() as *const [G; OUT_591]) }; __ret } } else { aiur_fn_591(__args, record, io_buffer, __cu)? } }; + let __ret: [G; OUT_591] = []; + if let Some(result) = record.function_queries[591].get_mut(&inp[..]) { debug_assert_eq!(result.output, &__ret[..]); if !unconstrained { *result.multiplicity += G::ONE; } } else { record.function_queries[591].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained)); }; return Ok(__ret); }, _ => { @@ -50771,15 +50487,15 @@ fn aiur_fn_595( }) } -const INPUT_SIZE_596: usize = 3; -const IN_596: usize = 3; -const OUT_596: usize = 0; -fn aiur_fn_596( - inp: [G; IN_596], +const INPUT_SIZE_592: usize = 3; +const IN_592: usize = 3; +const OUT_592: usize = 0; +fn aiur_fn_592( + inp: [G; IN_592], record: &mut QueryRecord, io_buffer: &mut IOBuffer, unconstrained: bool, -) -> Result<[G; OUT_596], ExecError> { +) -> Result<[G; OUT_592], ExecError> { stacker::maybe_grow(64 * 1024, 4 * 1024 * 1024, || { let __v_0: G = inp[0]; let __v_1: G = inp[1]; @@ -50790,52 +50506,52 @@ fn aiur_fn_596( let __v_5: G = __loaded[2]; match __v_3.as_canonical_u64() { 0u64 => { - let __ret: [G; OUT_596] = []; - if let Some(result) = record.function_queries[596].get_mut(&inp[..]) { debug_assert_eq!(result.output, &__ret[..]); if !unconstrained { *result.multiplicity += G::ONE; } } else { record.function_queries[596].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained)); }; + let __ret: [G; OUT_592] = []; + if let Some(result) = record.function_queries[592].get_mut(&inp[..]) { debug_assert_eq!(result.output, &__ret[..]); if !unconstrained { *result.multiplicity += G::ONE; } } else { record.function_queries[592].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained)); }; return Ok(__ret); }, _ => { let __v_6: G = G::from_u64(1); let __v_7: G = G::from_u64(1); let __v_8: G = { let __values: [G; 3] = [__v_6, __v_7, __v_7]; let __mq = record.memory_queries.get_mut(&3).ok_or(ExecError::InvalidMemorySize(3))?; if let Some(result) = __mq.get_mut(&__values[..]) { if !unconstrained { *result.multiplicity += G::ONE; } result.output[0] } else { let __ptr = G::from_usize(__mq.len()); __mq.insert(&__values[..], &[__ptr], G::from_bool(!unconstrained)); __ptr } }; - let __r_arr: [G; OUT_595] = { let __args: [G; IN_595] = [__v_0, __v_1, __v_2, __v_8]; let __cu = unconstrained; if let Some(result) = record.function_queries[595].get_mut(&__args[..]) { if !__cu && *result.multiplicity == G::ZERO { aiur_fn_595(__args, record, io_buffer, false)? } else { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_595] = unsafe { *(result.output.as_ptr() as *const [G; OUT_595]) }; __ret } } else { aiur_fn_595(__args, record, io_buffer, __cu)? } }; - let __ret: [G; OUT_596] = []; - if let Some(result) = record.function_queries[596].get_mut(&inp[..]) { debug_assert_eq!(result.output, &__ret[..]); if !unconstrained { *result.multiplicity += G::ONE; } } else { record.function_queries[596].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained)); }; + let __r_arr: [G; OUT_591] = { let __args: [G; IN_591] = [__v_0, __v_1, __v_2, __v_8]; let __cu = unconstrained; if let Some(result) = record.function_queries[591].get_mut(&__args[..]) { if !__cu && *result.multiplicity == G::ZERO { aiur_fn_591(__args, record, io_buffer, false)? } else { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_591] = unsafe { *(result.output.as_ptr() as *const [G; OUT_591]) }; __ret } } else { aiur_fn_591(__args, record, io_buffer, __cu)? } }; + let __ret: [G; OUT_592] = []; + if let Some(result) = record.function_queries[592].get_mut(&inp[..]) { debug_assert_eq!(result.output, &__ret[..]); if !unconstrained { *result.multiplicity += G::ONE; } } else { record.function_queries[592].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained)); }; return Ok(__ret); }, } }) } -const INPUT_SIZE_597: usize = 2; -const IN_597: usize = 2; -const OUT_597: usize = 1; -fn aiur_fn_597( - inp: [G; IN_597], +const INPUT_SIZE_593: usize = 2; +const IN_593: usize = 2; +const OUT_593: usize = 1; +fn aiur_fn_593( + inp: [G; IN_593], record: &mut QueryRecord, io_buffer: &mut IOBuffer, unconstrained: bool, -) -> Result<[G; OUT_597], ExecError> { +) -> Result<[G; OUT_593], ExecError> { stacker::maybe_grow(64 * 1024, 4 * 1024 * 1024, || { let __v_0: G = inp[0]; let __v_1: G = inp[1]; - let __r_arr: [G; OUT_289] = { let __args: [G; IN_289] = [__v_0, __v_1]; let __cu = unconstrained; if let Some(result) = record.function_queries[289].get_mut(&__args[..]) { if !__cu && *result.multiplicity == G::ZERO { aiur_fn_289(__args, record, io_buffer, false)? } else { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_289] = unsafe { *(result.output.as_ptr() as *const [G; OUT_289]) }; __ret } } else { aiur_fn_289(__args, record, io_buffer, __cu)? } }; + let __r_arr: [G; OUT_285] = { let __args: [G; IN_285] = [__v_0, __v_1]; let __cu = unconstrained; if let Some(result) = record.function_queries[285].get_mut(&__args[..]) { if !__cu && *result.multiplicity == G::ZERO { aiur_fn_285(__args, record, io_buffer, false)? } else { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_285] = unsafe { *(result.output.as_ptr() as *const [G; OUT_285]) }; __ret } } else { aiur_fn_285(__args, record, io_buffer, __cu)? } }; let __v_2: G = __r_arr[0]; - let __ret: [G; OUT_597] = [__v_2]; - if let Some(result) = record.function_queries[597].get_mut(&inp[..]) { debug_assert_eq!(result.output, &__ret[..]); if !unconstrained { *result.multiplicity += G::ONE; } } else { record.function_queries[597].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained)); }; + let __ret: [G; OUT_593] = [__v_2]; + if let Some(result) = record.function_queries[593].get_mut(&inp[..]) { debug_assert_eq!(result.output, &__ret[..]); if !unconstrained { *result.multiplicity += G::ONE; } } else { record.function_queries[593].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained)); }; return Ok(__ret); }) } -const INPUT_SIZE_598: usize = 2; -const IN_598: usize = 2; -const OUT_598: usize = 1; -fn aiur_fn_598( - inp: [G; IN_598], +const INPUT_SIZE_594: usize = 2; +const IN_594: usize = 2; +const OUT_594: usize = 1; +fn aiur_fn_594( + inp: [G; IN_594], record: &mut QueryRecord, io_buffer: &mut IOBuffer, unconstrained: bool, -) -> Result<[G; OUT_598], ExecError> { +) -> Result<[G; OUT_594], ExecError> { stacker::maybe_grow(64 * 1024, 4 * 1024 * 1024, || { let __v_0: G = inp[0]; let __v_1: G = inp[1]; @@ -50846,8 +50562,8 @@ fn aiur_fn_598( match __v_2.as_canonical_u64() { 1u64 => { let __v_5: G = G::from_u64(0); - let __ret: [G; OUT_598] = [__v_5]; - if let Some(result) = record.function_queries[598].get_mut(&inp[..]) { debug_assert_eq!(result.output, &__ret[..]); if !unconstrained { *result.multiplicity += G::ONE; } } else { record.function_queries[598].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained)); }; + let __ret: [G; OUT_594] = [__v_5]; + if let Some(result) = record.function_queries[594].get_mut(&inp[..]) { debug_assert_eq!(result.output, &__ret[..]); if !unconstrained { *result.multiplicity += G::ONE; } } else { record.function_queries[594].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained)); }; return Ok(__ret); }, 0u64 => { @@ -50856,15 +50572,15 @@ fn aiur_fn_598( match __v_5.as_canonical_u64() { 1u64 => { let __v_6: G = G::from_u64(1); - let __ret: [G; OUT_598] = [__v_6]; - if let Some(result) = record.function_queries[598].get_mut(&inp[..]) { debug_assert_eq!(result.output, &__ret[..]); if !unconstrained { *result.multiplicity += G::ONE; } } else { record.function_queries[598].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained)); }; + let __ret: [G; OUT_594] = [__v_6]; + if let Some(result) = record.function_queries[594].get_mut(&inp[..]) { debug_assert_eq!(result.output, &__ret[..]); if !unconstrained { *result.multiplicity += G::ONE; } } else { record.function_queries[594].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained)); }; return Ok(__ret); }, _ => { - let __r_arr: [G; OUT_598] = { let __args: [G; IN_598] = [__v_4, __v_1]; let __cu = unconstrained; if let Some(result) = record.function_queries[598].get_mut(&__args[..]) { if !__cu && *result.multiplicity == G::ZERO { aiur_fn_598(__args, record, io_buffer, false)? } else { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_598] = unsafe { *(result.output.as_ptr() as *const [G; OUT_598]) }; __ret } } else { aiur_fn_598(__args, record, io_buffer, __cu)? } }; + let __r_arr: [G; OUT_594] = { let __args: [G; IN_594] = [__v_4, __v_1]; let __cu = unconstrained; if let Some(result) = record.function_queries[594].get_mut(&__args[..]) { if !__cu && *result.multiplicity == G::ZERO { aiur_fn_594(__args, record, io_buffer, false)? } else { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_594] = unsafe { *(result.output.as_ptr() as *const [G; OUT_594]) }; __ret } } else { aiur_fn_594(__args, record, io_buffer, __cu)? } }; let __v_6: G = __r_arr[0]; - let __ret: [G; OUT_598] = [__v_6]; - if let Some(result) = record.function_queries[598].get_mut(&inp[..]) { debug_assert_eq!(result.output, &__ret[..]); if !unconstrained { *result.multiplicity += G::ONE; } } else { record.function_queries[598].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained)); }; + let __ret: [G; OUT_594] = [__v_6]; + if let Some(result) = record.function_queries[594].get_mut(&inp[..]) { debug_assert_eq!(result.output, &__ret[..]); if !unconstrained { *result.multiplicity += G::ONE; } } else { record.function_queries[594].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained)); }; return Ok(__ret); }, } @@ -50876,19 +50592,19 @@ fn aiur_fn_598( }) } -const INPUT_SIZE_599: usize = 2; -const IN_599: usize = 2; -const OUT_599: usize = 1; -fn aiur_fn_599( - inp: [G; IN_599], +const INPUT_SIZE_595: usize = 2; +const IN_595: usize = 2; +const OUT_595: usize = 1; +fn aiur_fn_595( + inp: [G; IN_595], record: &mut QueryRecord, io_buffer: &mut IOBuffer, unconstrained: bool, -) -> Result<[G; OUT_599], ExecError> { +) -> Result<[G; OUT_595], ExecError> { stacker::maybe_grow(64 * 1024, 4 * 1024 * 1024, || { let __v_0: G = inp[0]; let __v_1: G = inp[1]; - let __r_arr: [G; OUT_287] = { let __args: [G; IN_287] = [__v_0]; let __cu = unconstrained; if let Some(result) = record.function_queries[287].get_mut(&__args[..]) { if !__cu && *result.multiplicity == G::ZERO { aiur_fn_287(__args, record, io_buffer, false)? } else { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_287] = unsafe { *(result.output.as_ptr() as *const [G; OUT_287]) }; __ret } } else { aiur_fn_287(__args, record, io_buffer, __cu)? } }; + let __r_arr: [G; OUT_283] = { let __args: [G; IN_283] = [__v_0]; let __cu = unconstrained; if let Some(result) = record.function_queries[283].get_mut(&__args[..]) { if !__cu && *result.multiplicity == G::ZERO { aiur_fn_283(__args, record, io_buffer, false)? } else { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_283] = unsafe { *(result.output.as_ptr() as *const [G; OUT_283]) }; __ret } } else { aiur_fn_283(__args, record, io_buffer, __cu)? } }; let __v_2: G = __r_arr[0]; let __loaded: [G; 12] = { let __mq = record.memory_queries.get_mut(&12).ok_or(ExecError::InvalidMemorySize(12))?; let __ptr_u64 = __v_2.as_canonical_u64(); let __ptr_usize = usize::try_from(__ptr_u64).ok().ok_or(ExecError::PointerTooLarge(__ptr_u64))?; let (__args, __mult) = __mq.get_index_mut(__ptr_usize).ok_or(ExecError::UnboundPointer { ptr: __ptr_u64, size: 12 })?; if !unconstrained { *__mult += G::ONE; } let __arr: [G; 12] = __args[..12].try_into().unwrap(); __arr }; let __v_3: G = __loaded[0]; @@ -50905,31 +50621,31 @@ fn aiur_fn_599( let __v_14: G = __loaded[11]; match __v_3.as_canonical_u64() { 5u64 => { - let __r_arr: [G; OUT_598] = { let __args: [G; IN_598] = [__v_1, __v_10]; let __cu = unconstrained; if let Some(result) = record.function_queries[598].get_mut(&__args[..]) { if !__cu && *result.multiplicity == G::ZERO { aiur_fn_598(__args, record, io_buffer, false)? } else { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_598] = unsafe { *(result.output.as_ptr() as *const [G; OUT_598]) }; __ret } } else { aiur_fn_598(__args, record, io_buffer, __cu)? } }; + let __r_arr: [G; OUT_594] = { let __args: [G; IN_594] = [__v_1, __v_10]; let __cu = unconstrained; if let Some(result) = record.function_queries[594].get_mut(&__args[..]) { if !__cu && *result.multiplicity == G::ZERO { aiur_fn_594(__args, record, io_buffer, false)? } else { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_594] = unsafe { *(result.output.as_ptr() as *const [G; OUT_594]) }; __ret } } else { aiur_fn_594(__args, record, io_buffer, __cu)? } }; let __v_15: G = __r_arr[0]; - let __ret: [G; OUT_599] = [__v_15]; - if let Some(result) = record.function_queries[599].get_mut(&inp[..]) { debug_assert_eq!(result.output, &__ret[..]); if !unconstrained { *result.multiplicity += G::ONE; } } else { record.function_queries[599].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained)); }; + let __ret: [G; OUT_595] = [__v_15]; + if let Some(result) = record.function_queries[595].get_mut(&inp[..]) { debug_assert_eq!(result.output, &__ret[..]); if !unconstrained { *result.multiplicity += G::ONE; } } else { record.function_queries[595].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained)); }; return Ok(__ret); }, _ => { let __v_15: G = G::from_u64(0); - let __ret: [G; OUT_599] = [__v_15]; - if let Some(result) = record.function_queries[599].get_mut(&inp[..]) { debug_assert_eq!(result.output, &__ret[..]); if !unconstrained { *result.multiplicity += G::ONE; } } else { record.function_queries[599].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained)); }; + let __ret: [G; OUT_595] = [__v_15]; + if let Some(result) = record.function_queries[595].get_mut(&inp[..]) { debug_assert_eq!(result.output, &__ret[..]); if !unconstrained { *result.multiplicity += G::ONE; } } else { record.function_queries[595].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained)); }; return Ok(__ret); }, } }) } -const INPUT_SIZE_600: usize = 2; -const IN_600: usize = 2; -const OUT_600: usize = 1; -fn aiur_fn_600( - inp: [G; IN_600], +const INPUT_SIZE_596: usize = 2; +const IN_596: usize = 2; +const OUT_596: usize = 1; +fn aiur_fn_596( + inp: [G; IN_596], record: &mut QueryRecord, io_buffer: &mut IOBuffer, unconstrained: bool, -) -> Result<[G; OUT_600], ExecError> { +) -> Result<[G; OUT_596], ExecError> { stacker::maybe_grow(64 * 1024, 4 * 1024 * 1024, || { let __v_0: G = inp[0]; let __v_1: G = inp[1]; @@ -50941,105 +50657,105 @@ fn aiur_fn_600( match __v_2.as_canonical_u64() { 0u64 => { let __v_6: G = G::from_u64(0); - let __ret: [G; OUT_600] = [__v_6]; - if let Some(result) = record.function_queries[600].get_mut(&inp[..]) { debug_assert_eq!(result.output, &__ret[..]); if !unconstrained { *result.multiplicity += G::ONE; } } else { record.function_queries[600].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained)); }; + let __ret: [G; OUT_596] = [__v_6]; + if let Some(result) = record.function_queries[596].get_mut(&inp[..]) { debug_assert_eq!(result.output, &__ret[..]); if !unconstrained { *result.multiplicity += G::ONE; } } else { record.function_queries[596].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained)); }; return Ok(__ret); }, 1u64 => { let __v_6: G = G::from_u64(0); - let __ret: [G; OUT_600] = [__v_6]; - if let Some(result) = record.function_queries[600].get_mut(&inp[..]) { debug_assert_eq!(result.output, &__ret[..]); if !unconstrained { *result.multiplicity += G::ONE; } } else { record.function_queries[600].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained)); }; + let __ret: [G; OUT_596] = [__v_6]; + if let Some(result) = record.function_queries[596].get_mut(&inp[..]) { debug_assert_eq!(result.output, &__ret[..]); if !unconstrained { *result.multiplicity += G::ONE; } } else { record.function_queries[596].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained)); }; return Ok(__ret); }, 2u64 => { - let __r_arr: [G; OUT_599] = { let __args: [G; IN_599] = [__v_3, __v_1]; let __cu = unconstrained; if let Some(result) = record.function_queries[599].get_mut(&__args[..]) { if !__cu && *result.multiplicity == G::ZERO { aiur_fn_599(__args, record, io_buffer, false)? } else { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_599] = unsafe { *(result.output.as_ptr() as *const [G; OUT_599]) }; __ret } } else { aiur_fn_599(__args, record, io_buffer, __cu)? } }; + let __r_arr: [G; OUT_595] = { let __args: [G; IN_595] = [__v_3, __v_1]; let __cu = unconstrained; if let Some(result) = record.function_queries[595].get_mut(&__args[..]) { if !__cu && *result.multiplicity == G::ZERO { aiur_fn_595(__args, record, io_buffer, false)? } else { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_595] = unsafe { *(result.output.as_ptr() as *const [G; OUT_595]) }; __ret } } else { aiur_fn_595(__args, record, io_buffer, __cu)? } }; let __v_6: G = __r_arr[0]; - let __ret: [G; OUT_600] = [__v_6]; - if let Some(result) = record.function_queries[600].get_mut(&inp[..]) { debug_assert_eq!(result.output, &__ret[..]); if !unconstrained { *result.multiplicity += G::ONE; } } else { record.function_queries[600].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained)); }; + let __ret: [G; OUT_596] = [__v_6]; + if let Some(result) = record.function_queries[596].get_mut(&inp[..]) { debug_assert_eq!(result.output, &__ret[..]); if !unconstrained { *result.multiplicity += G::ONE; } } else { record.function_queries[596].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained)); }; return Ok(__ret); }, 3u64 => { - let __r_arr: [G; OUT_600] = { let __args: [G; IN_600] = [__v_3, __v_1]; let __cu = unconstrained; if let Some(result) = record.function_queries[600].get_mut(&__args[..]) { if !__cu && *result.multiplicity == G::ZERO { aiur_fn_600(__args, record, io_buffer, false)? } else { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_600] = unsafe { *(result.output.as_ptr() as *const [G; OUT_600]) }; __ret } } else { aiur_fn_600(__args, record, io_buffer, __cu)? } }; + let __r_arr: [G; OUT_596] = { let __args: [G; IN_596] = [__v_3, __v_1]; let __cu = unconstrained; if let Some(result) = record.function_queries[596].get_mut(&__args[..]) { if !__cu && *result.multiplicity == G::ZERO { aiur_fn_596(__args, record, io_buffer, false)? } else { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_596] = unsafe { *(result.output.as_ptr() as *const [G; OUT_596]) }; __ret } } else { aiur_fn_596(__args, record, io_buffer, __cu)? } }; let __v_6: G = __r_arr[0]; match __v_6.as_canonical_u64() { 1u64 => { let __v_7: G = G::from_u64(1); - let __ret: [G; OUT_600] = [__v_7]; - if let Some(result) = record.function_queries[600].get_mut(&inp[..]) { debug_assert_eq!(result.output, &__ret[..]); if !unconstrained { *result.multiplicity += G::ONE; } } else { record.function_queries[600].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained)); }; + let __ret: [G; OUT_596] = [__v_7]; + if let Some(result) = record.function_queries[596].get_mut(&inp[..]) { debug_assert_eq!(result.output, &__ret[..]); if !unconstrained { *result.multiplicity += G::ONE; } } else { record.function_queries[596].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained)); }; return Ok(__ret); }, _ => { - let __r_arr: [G; OUT_600] = { let __args: [G; IN_600] = [__v_4, __v_1]; let __cu = unconstrained; if let Some(result) = record.function_queries[600].get_mut(&__args[..]) { if !__cu && *result.multiplicity == G::ZERO { aiur_fn_600(__args, record, io_buffer, false)? } else { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_600] = unsafe { *(result.output.as_ptr() as *const [G; OUT_600]) }; __ret } } else { aiur_fn_600(__args, record, io_buffer, __cu)? } }; + let __r_arr: [G; OUT_596] = { let __args: [G; IN_596] = [__v_4, __v_1]; let __cu = unconstrained; if let Some(result) = record.function_queries[596].get_mut(&__args[..]) { if !__cu && *result.multiplicity == G::ZERO { aiur_fn_596(__args, record, io_buffer, false)? } else { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_596] = unsafe { *(result.output.as_ptr() as *const [G; OUT_596]) }; __ret } } else { aiur_fn_596(__args, record, io_buffer, __cu)? } }; let __v_7: G = __r_arr[0]; - let __ret: [G; OUT_600] = [__v_7]; - if let Some(result) = record.function_queries[600].get_mut(&inp[..]) { debug_assert_eq!(result.output, &__ret[..]); if !unconstrained { *result.multiplicity += G::ONE; } } else { record.function_queries[600].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained)); }; + let __ret: [G; OUT_596] = [__v_7]; + if let Some(result) = record.function_queries[596].get_mut(&inp[..]) { debug_assert_eq!(result.output, &__ret[..]); if !unconstrained { *result.multiplicity += G::ONE; } } else { record.function_queries[596].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained)); }; return Ok(__ret); }, } }, 4u64 => { - let __r_arr: [G; OUT_600] = { let __args: [G; IN_600] = [__v_3, __v_1]; let __cu = unconstrained; if let Some(result) = record.function_queries[600].get_mut(&__args[..]) { if !__cu && *result.multiplicity == G::ZERO { aiur_fn_600(__args, record, io_buffer, false)? } else { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_600] = unsafe { *(result.output.as_ptr() as *const [G; OUT_600]) }; __ret } } else { aiur_fn_600(__args, record, io_buffer, __cu)? } }; + let __r_arr: [G; OUT_596] = { let __args: [G; IN_596] = [__v_3, __v_1]; let __cu = unconstrained; if let Some(result) = record.function_queries[596].get_mut(&__args[..]) { if !__cu && *result.multiplicity == G::ZERO { aiur_fn_596(__args, record, io_buffer, false)? } else { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_596] = unsafe { *(result.output.as_ptr() as *const [G; OUT_596]) }; __ret } } else { aiur_fn_596(__args, record, io_buffer, __cu)? } }; let __v_6: G = __r_arr[0]; match __v_6.as_canonical_u64() { 1u64 => { let __v_7: G = G::from_u64(1); - let __ret: [G; OUT_600] = [__v_7]; - if let Some(result) = record.function_queries[600].get_mut(&inp[..]) { debug_assert_eq!(result.output, &__ret[..]); if !unconstrained { *result.multiplicity += G::ONE; } } else { record.function_queries[600].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained)); }; + let __ret: [G; OUT_596] = [__v_7]; + if let Some(result) = record.function_queries[596].get_mut(&inp[..]) { debug_assert_eq!(result.output, &__ret[..]); if !unconstrained { *result.multiplicity += G::ONE; } } else { record.function_queries[596].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained)); }; return Ok(__ret); }, _ => { - let __r_arr: [G; OUT_600] = { let __args: [G; IN_600] = [__v_4, __v_1]; let __cu = unconstrained; if let Some(result) = record.function_queries[600].get_mut(&__args[..]) { if !__cu && *result.multiplicity == G::ZERO { aiur_fn_600(__args, record, io_buffer, false)? } else { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_600] = unsafe { *(result.output.as_ptr() as *const [G; OUT_600]) }; __ret } } else { aiur_fn_600(__args, record, io_buffer, __cu)? } }; + let __r_arr: [G; OUT_596] = { let __args: [G; IN_596] = [__v_4, __v_1]; let __cu = unconstrained; if let Some(result) = record.function_queries[596].get_mut(&__args[..]) { if !__cu && *result.multiplicity == G::ZERO { aiur_fn_596(__args, record, io_buffer, false)? } else { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_596] = unsafe { *(result.output.as_ptr() as *const [G; OUT_596]) }; __ret } } else { aiur_fn_596(__args, record, io_buffer, __cu)? } }; let __v_7: G = __r_arr[0]; - let __ret: [G; OUT_600] = [__v_7]; - if let Some(result) = record.function_queries[600].get_mut(&inp[..]) { debug_assert_eq!(result.output, &__ret[..]); if !unconstrained { *result.multiplicity += G::ONE; } } else { record.function_queries[600].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained)); }; + let __ret: [G; OUT_596] = [__v_7]; + if let Some(result) = record.function_queries[596].get_mut(&inp[..]) { debug_assert_eq!(result.output, &__ret[..]); if !unconstrained { *result.multiplicity += G::ONE; } } else { record.function_queries[596].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained)); }; return Ok(__ret); }, } }, 5u64 => { - let __r_arr: [G; OUT_600] = { let __args: [G; IN_600] = [__v_3, __v_1]; let __cu = unconstrained; if let Some(result) = record.function_queries[600].get_mut(&__args[..]) { if !__cu && *result.multiplicity == G::ZERO { aiur_fn_600(__args, record, io_buffer, false)? } else { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_600] = unsafe { *(result.output.as_ptr() as *const [G; OUT_600]) }; __ret } } else { aiur_fn_600(__args, record, io_buffer, __cu)? } }; + let __r_arr: [G; OUT_596] = { let __args: [G; IN_596] = [__v_3, __v_1]; let __cu = unconstrained; if let Some(result) = record.function_queries[596].get_mut(&__args[..]) { if !__cu && *result.multiplicity == G::ZERO { aiur_fn_596(__args, record, io_buffer, false)? } else { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_596] = unsafe { *(result.output.as_ptr() as *const [G; OUT_596]) }; __ret } } else { aiur_fn_596(__args, record, io_buffer, __cu)? } }; let __v_6: G = __r_arr[0]; match __v_6.as_canonical_u64() { 1u64 => { let __v_7: G = G::from_u64(1); - let __ret: [G; OUT_600] = [__v_7]; - if let Some(result) = record.function_queries[600].get_mut(&inp[..]) { debug_assert_eq!(result.output, &__ret[..]); if !unconstrained { *result.multiplicity += G::ONE; } } else { record.function_queries[600].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained)); }; + let __ret: [G; OUT_596] = [__v_7]; + if let Some(result) = record.function_queries[596].get_mut(&inp[..]) { debug_assert_eq!(result.output, &__ret[..]); if !unconstrained { *result.multiplicity += G::ONE; } } else { record.function_queries[596].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained)); }; return Ok(__ret); }, _ => { - let __r_arr: [G; OUT_600] = { let __args: [G; IN_600] = [__v_4, __v_1]; let __cu = unconstrained; if let Some(result) = record.function_queries[600].get_mut(&__args[..]) { if !__cu && *result.multiplicity == G::ZERO { aiur_fn_600(__args, record, io_buffer, false)? } else { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_600] = unsafe { *(result.output.as_ptr() as *const [G; OUT_600]) }; __ret } } else { aiur_fn_600(__args, record, io_buffer, __cu)? } }; + let __r_arr: [G; OUT_596] = { let __args: [G; IN_596] = [__v_4, __v_1]; let __cu = unconstrained; if let Some(result) = record.function_queries[596].get_mut(&__args[..]) { if !__cu && *result.multiplicity == G::ZERO { aiur_fn_596(__args, record, io_buffer, false)? } else { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_596] = unsafe { *(result.output.as_ptr() as *const [G; OUT_596]) }; __ret } } else { aiur_fn_596(__args, record, io_buffer, __cu)? } }; let __v_7: G = __r_arr[0]; - let __ret: [G; OUT_600] = [__v_7]; - if let Some(result) = record.function_queries[600].get_mut(&inp[..]) { debug_assert_eq!(result.output, &__ret[..]); if !unconstrained { *result.multiplicity += G::ONE; } } else { record.function_queries[600].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained)); }; + let __ret: [G; OUT_596] = [__v_7]; + if let Some(result) = record.function_queries[596].get_mut(&inp[..]) { debug_assert_eq!(result.output, &__ret[..]); if !unconstrained { *result.multiplicity += G::ONE; } } else { record.function_queries[596].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained)); }; return Ok(__ret); }, } }, 6u64 => { - let __r_arr: [G; OUT_600] = { let __args: [G; IN_600] = [__v_3, __v_1]; let __cu = unconstrained; if let Some(result) = record.function_queries[600].get_mut(&__args[..]) { if !__cu && *result.multiplicity == G::ZERO { aiur_fn_600(__args, record, io_buffer, false)? } else { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_600] = unsafe { *(result.output.as_ptr() as *const [G; OUT_600]) }; __ret } } else { aiur_fn_600(__args, record, io_buffer, __cu)? } }; + let __r_arr: [G; OUT_596] = { let __args: [G; IN_596] = [__v_3, __v_1]; let __cu = unconstrained; if let Some(result) = record.function_queries[596].get_mut(&__args[..]) { if !__cu && *result.multiplicity == G::ZERO { aiur_fn_596(__args, record, io_buffer, false)? } else { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_596] = unsafe { *(result.output.as_ptr() as *const [G; OUT_596]) }; __ret } } else { aiur_fn_596(__args, record, io_buffer, __cu)? } }; let __v_6: G = __r_arr[0]; match __v_6.as_canonical_u64() { 1u64 => { let __v_7: G = G::from_u64(1); - let __ret: [G; OUT_600] = [__v_7]; - if let Some(result) = record.function_queries[600].get_mut(&inp[..]) { debug_assert_eq!(result.output, &__ret[..]); if !unconstrained { *result.multiplicity += G::ONE; } } else { record.function_queries[600].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained)); }; + let __ret: [G; OUT_596] = [__v_7]; + if let Some(result) = record.function_queries[596].get_mut(&inp[..]) { debug_assert_eq!(result.output, &__ret[..]); if !unconstrained { *result.multiplicity += G::ONE; } } else { record.function_queries[596].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained)); }; return Ok(__ret); }, _ => { - let __r_arr: [G; OUT_600] = { let __args: [G; IN_600] = [__v_4, __v_1]; let __cu = unconstrained; if let Some(result) = record.function_queries[600].get_mut(&__args[..]) { if !__cu && *result.multiplicity == G::ZERO { aiur_fn_600(__args, record, io_buffer, false)? } else { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_600] = unsafe { *(result.output.as_ptr() as *const [G; OUT_600]) }; __ret } } else { aiur_fn_600(__args, record, io_buffer, __cu)? } }; + let __r_arr: [G; OUT_596] = { let __args: [G; IN_596] = [__v_4, __v_1]; let __cu = unconstrained; if let Some(result) = record.function_queries[596].get_mut(&__args[..]) { if !__cu && *result.multiplicity == G::ZERO { aiur_fn_596(__args, record, io_buffer, false)? } else { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_596] = unsafe { *(result.output.as_ptr() as *const [G; OUT_596]) }; __ret } } else { aiur_fn_596(__args, record, io_buffer, __cu)? } }; let __v_7: G = __r_arr[0]; match __v_7.as_canonical_u64() { 1u64 => { let __v_8: G = G::from_u64(1); - let __ret: [G; OUT_600] = [__v_8]; - if let Some(result) = record.function_queries[600].get_mut(&inp[..]) { debug_assert_eq!(result.output, &__ret[..]); if !unconstrained { *result.multiplicity += G::ONE; } } else { record.function_queries[600].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained)); }; + let __ret: [G; OUT_596] = [__v_8]; + if let Some(result) = record.function_queries[596].get_mut(&inp[..]) { debug_assert_eq!(result.output, &__ret[..]); if !unconstrained { *result.multiplicity += G::ONE; } } else { record.function_queries[596].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained)); }; return Ok(__ret); }, _ => { - let __r_arr: [G; OUT_600] = { let __args: [G; IN_600] = [__v_5, __v_1]; let __cu = unconstrained; if let Some(result) = record.function_queries[600].get_mut(&__args[..]) { if !__cu && *result.multiplicity == G::ZERO { aiur_fn_600(__args, record, io_buffer, false)? } else { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_600] = unsafe { *(result.output.as_ptr() as *const [G; OUT_600]) }; __ret } } else { aiur_fn_600(__args, record, io_buffer, __cu)? } }; + let __r_arr: [G; OUT_596] = { let __args: [G; IN_596] = [__v_5, __v_1]; let __cu = unconstrained; if let Some(result) = record.function_queries[596].get_mut(&__args[..]) { if !__cu && *result.multiplicity == G::ZERO { aiur_fn_596(__args, record, io_buffer, false)? } else { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_596] = unsafe { *(result.output.as_ptr() as *const [G; OUT_596]) }; __ret } } else { aiur_fn_596(__args, record, io_buffer, __cu)? } }; let __v_8: G = __r_arr[0]; - let __ret: [G; OUT_600] = [__v_8]; - if let Some(result) = record.function_queries[600].get_mut(&inp[..]) { debug_assert_eq!(result.output, &__ret[..]); if !unconstrained { *result.multiplicity += G::ONE; } } else { record.function_queries[600].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained)); }; + let __ret: [G; OUT_596] = [__v_8]; + if let Some(result) = record.function_queries[596].get_mut(&inp[..]) { debug_assert_eq!(result.output, &__ret[..]); if !unconstrained { *result.multiplicity += G::ONE; } } else { record.function_queries[596].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained)); }; return Ok(__ret); }, } @@ -51048,15 +50764,15 @@ fn aiur_fn_600( }, 7u64 => { let __v_6: G = G::from_u64(0); - let __ret: [G; OUT_600] = [__v_6]; - if let Some(result) = record.function_queries[600].get_mut(&inp[..]) { debug_assert_eq!(result.output, &__ret[..]); if !unconstrained { *result.multiplicity += G::ONE; } } else { record.function_queries[600].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained)); }; + let __ret: [G; OUT_596] = [__v_6]; + if let Some(result) = record.function_queries[596].get_mut(&inp[..]) { debug_assert_eq!(result.output, &__ret[..]); if !unconstrained { *result.multiplicity += G::ONE; } } else { record.function_queries[596].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained)); }; return Ok(__ret); }, 8u64 => { - let __r_arr: [G; OUT_600] = { let __args: [G; IN_600] = [__v_5, __v_1]; let __cu = unconstrained; if let Some(result) = record.function_queries[600].get_mut(&__args[..]) { if !__cu && *result.multiplicity == G::ZERO { aiur_fn_600(__args, record, io_buffer, false)? } else { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_600] = unsafe { *(result.output.as_ptr() as *const [G; OUT_600]) }; __ret } } else { aiur_fn_600(__args, record, io_buffer, __cu)? } }; + let __r_arr: [G; OUT_596] = { let __args: [G; IN_596] = [__v_5, __v_1]; let __cu = unconstrained; if let Some(result) = record.function_queries[596].get_mut(&__args[..]) { if !__cu && *result.multiplicity == G::ZERO { aiur_fn_596(__args, record, io_buffer, false)? } else { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_596] = unsafe { *(result.output.as_ptr() as *const [G; OUT_596]) }; __ret } } else { aiur_fn_596(__args, record, io_buffer, __cu)? } }; let __v_6: G = __r_arr[0]; - let __ret: [G; OUT_600] = [__v_6]; - if let Some(result) = record.function_queries[600].get_mut(&inp[..]) { debug_assert_eq!(result.output, &__ret[..]); if !unconstrained { *result.multiplicity += G::ONE; } } else { record.function_queries[600].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained)); }; + let __ret: [G; OUT_596] = [__v_6]; + if let Some(result) = record.function_queries[596].get_mut(&inp[..]) { debug_assert_eq!(result.output, &__ret[..]); if !unconstrained { *result.multiplicity += G::ONE; } } else { record.function_queries[596].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained)); }; return Ok(__ret); }, _ => { @@ -51066,15 +50782,15 @@ fn aiur_fn_600( }) } -const INPUT_SIZE_601: usize = 2; -const IN_601: usize = 2; -const OUT_601: usize = 1; -fn aiur_fn_601( - inp: [G; IN_601], +const INPUT_SIZE_597: usize = 2; +const IN_597: usize = 2; +const OUT_597: usize = 1; +fn aiur_fn_597( + inp: [G; IN_597], record: &mut QueryRecord, io_buffer: &mut IOBuffer, unconstrained: bool, -) -> Result<[G; OUT_601], ExecError> { +) -> Result<[G; OUT_597], ExecError> { stacker::maybe_grow(64 * 1024, 4 * 1024 * 1024, || { let __v_0: G = inp[0]; let __v_1: G = inp[1]; @@ -51085,25 +50801,25 @@ fn aiur_fn_601( match __v_2.as_canonical_u64() { 1u64 => { let __v_5: G = G::from_u64(0); - let __ret: [G; OUT_601] = [__v_5]; - if let Some(result) = record.function_queries[601].get_mut(&inp[..]) { debug_assert_eq!(result.output, &__ret[..]); if !unconstrained { *result.multiplicity += G::ONE; } } else { record.function_queries[601].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained)); }; + let __ret: [G; OUT_597] = [__v_5]; + if let Some(result) = record.function_queries[597].get_mut(&inp[..]) { debug_assert_eq!(result.output, &__ret[..]); if !unconstrained { *result.multiplicity += G::ONE; } } else { record.function_queries[597].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained)); }; return Ok(__ret); }, 0u64 => { - let __r_arr: [G; OUT_600] = { let __args: [G; IN_600] = [__v_3, __v_1]; let __cu = unconstrained; if let Some(result) = record.function_queries[600].get_mut(&__args[..]) { if !__cu && *result.multiplicity == G::ZERO { aiur_fn_600(__args, record, io_buffer, false)? } else { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_600] = unsafe { *(result.output.as_ptr() as *const [G; OUT_600]) }; __ret } } else { aiur_fn_600(__args, record, io_buffer, __cu)? } }; + let __r_arr: [G; OUT_596] = { let __args: [G; IN_596] = [__v_3, __v_1]; let __cu = unconstrained; if let Some(result) = record.function_queries[596].get_mut(&__args[..]) { if !__cu && *result.multiplicity == G::ZERO { aiur_fn_596(__args, record, io_buffer, false)? } else { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_596] = unsafe { *(result.output.as_ptr() as *const [G; OUT_596]) }; __ret } } else { aiur_fn_596(__args, record, io_buffer, __cu)? } }; let __v_5: G = __r_arr[0]; match __v_5.as_canonical_u64() { 1u64 => { let __v_6: G = G::from_u64(1); - let __ret: [G; OUT_601] = [__v_6]; - if let Some(result) = record.function_queries[601].get_mut(&inp[..]) { debug_assert_eq!(result.output, &__ret[..]); if !unconstrained { *result.multiplicity += G::ONE; } } else { record.function_queries[601].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained)); }; + let __ret: [G; OUT_597] = [__v_6]; + if let Some(result) = record.function_queries[597].get_mut(&inp[..]) { debug_assert_eq!(result.output, &__ret[..]); if !unconstrained { *result.multiplicity += G::ONE; } } else { record.function_queries[597].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained)); }; return Ok(__ret); }, _ => { - let __r_arr: [G; OUT_601] = { let __args: [G; IN_601] = [__v_4, __v_1]; let __cu = unconstrained; if let Some(result) = record.function_queries[601].get_mut(&__args[..]) { if !__cu && *result.multiplicity == G::ZERO { aiur_fn_601(__args, record, io_buffer, false)? } else { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_601] = unsafe { *(result.output.as_ptr() as *const [G; OUT_601]) }; __ret } } else { aiur_fn_601(__args, record, io_buffer, __cu)? } }; + let __r_arr: [G; OUT_597] = { let __args: [G; IN_597] = [__v_4, __v_1]; let __cu = unconstrained; if let Some(result) = record.function_queries[597].get_mut(&__args[..]) { if !__cu && *result.multiplicity == G::ZERO { aiur_fn_597(__args, record, io_buffer, false)? } else { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_597] = unsafe { *(result.output.as_ptr() as *const [G; OUT_597]) }; __ret } } else { aiur_fn_597(__args, record, io_buffer, __cu)? } }; let __v_6: G = __r_arr[0]; - let __ret: [G; OUT_601] = [__v_6]; - if let Some(result) = record.function_queries[601].get_mut(&inp[..]) { debug_assert_eq!(result.output, &__ret[..]); if !unconstrained { *result.multiplicity += G::ONE; } } else { record.function_queries[601].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained)); }; + let __ret: [G; OUT_597] = [__v_6]; + if let Some(result) = record.function_queries[597].get_mut(&inp[..]) { debug_assert_eq!(result.output, &__ret[..]); if !unconstrained { *result.multiplicity += G::ONE; } } else { record.function_queries[597].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained)); }; return Ok(__ret); }, } @@ -51115,23 +50831,23 @@ fn aiur_fn_601( }) } -const INPUT_SIZE_602: usize = 3; -const IN_602: usize = 3; -const OUT_602: usize = 2; -fn aiur_fn_602( - inp: [G; IN_602], +const INPUT_SIZE_598: usize = 3; +const IN_598: usize = 3; +const OUT_598: usize = 2; +fn aiur_fn_598( + inp: [G; IN_598], record: &mut QueryRecord, io_buffer: &mut IOBuffer, unconstrained: bool, -) -> Result<[G; OUT_602], ExecError> { +) -> Result<[G; OUT_598], ExecError> { stacker::maybe_grow(64 * 1024, 4 * 1024 * 1024, || { let __v_0: G = inp[0]; let __v_1: G = inp[1]; let __v_2: G = inp[2]; match __v_1.as_canonical_u64() { 0u64 => { - let __ret: [G; OUT_602] = [__v_0, __v_2]; - if let Some(result) = record.function_queries[602].get_mut(&inp[..]) { debug_assert_eq!(result.output, &__ret[..]); if !unconstrained { *result.multiplicity += G::ONE; } } else { record.function_queries[602].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained)); }; + let __ret: [G; OUT_598] = [__v_0, __v_2]; + if let Some(result) = record.function_queries[598].get_mut(&inp[..]) { debug_assert_eq!(result.output, &__ret[..]); if !unconstrained { *result.multiplicity += G::ONE; } } else { record.function_queries[598].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained)); }; return Ok(__ret); }, _ => { @@ -51146,16 +50862,16 @@ fn aiur_fn_602( let __v_8: G = { let __values: [G; 3] = [__v_7, __v_4, __v_2]; let __mq = record.memory_queries.get_mut(&3).ok_or(ExecError::InvalidMemorySize(3))?; if let Some(result) = __mq.get_mut(&__values[..]) { if !unconstrained { *result.multiplicity += G::ONE; } result.output[0] } else { let __ptr = G::from_usize(__mq.len()); __mq.insert(&__values[..], &[__ptr], G::from_bool(!unconstrained)); __ptr } }; let __v_9: G = G::from_u64(1); let __v_10: G = (__v_1 - __v_9); - let __r_arr: [G; OUT_602] = { let __args: [G; IN_602] = [__v_5, __v_10, __v_8]; let __cu = unconstrained; if let Some(result) = record.function_queries[602].get_mut(&__args[..]) { if !__cu && *result.multiplicity == G::ZERO { aiur_fn_602(__args, record, io_buffer, false)? } else { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_602] = unsafe { *(result.output.as_ptr() as *const [G; OUT_602]) }; __ret } } else { aiur_fn_602(__args, record, io_buffer, __cu)? } }; + let __r_arr: [G; OUT_598] = { let __args: [G; IN_598] = [__v_5, __v_10, __v_8]; let __cu = unconstrained; if let Some(result) = record.function_queries[598].get_mut(&__args[..]) { if !__cu && *result.multiplicity == G::ZERO { aiur_fn_598(__args, record, io_buffer, false)? } else { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_598] = unsafe { *(result.output.as_ptr() as *const [G; OUT_598]) }; __ret } } else { aiur_fn_598(__args, record, io_buffer, __cu)? } }; let __v_11: G = __r_arr[0]; let __v_12: G = __r_arr[1]; - let __ret: [G; OUT_602] = [__v_11, __v_12]; - if let Some(result) = record.function_queries[602].get_mut(&inp[..]) { debug_assert_eq!(result.output, &__ret[..]); if !unconstrained { *result.multiplicity += G::ONE; } } else { record.function_queries[602].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained)); }; + let __ret: [G; OUT_598] = [__v_11, __v_12]; + if let Some(result) = record.function_queries[598].get_mut(&inp[..]) { debug_assert_eq!(result.output, &__ret[..]); if !unconstrained { *result.multiplicity += G::ONE; } } else { record.function_queries[598].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained)); }; return Ok(__ret); }, _ => { - let __ret: [G; OUT_602] = [__v_0, __v_2]; - if let Some(result) = record.function_queries[602].get_mut(&inp[..]) { debug_assert_eq!(result.output, &__ret[..]); if !unconstrained { *result.multiplicity += G::ONE; } } else { record.function_queries[602].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained)); }; + let __ret: [G; OUT_598] = [__v_0, __v_2]; + if let Some(result) = record.function_queries[598].get_mut(&inp[..]) { debug_assert_eq!(result.output, &__ret[..]); if !unconstrained { *result.multiplicity += G::ONE; } } else { record.function_queries[598].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained)); }; return Ok(__ret); }, } @@ -51164,15 +50880,15 @@ fn aiur_fn_602( }) } -const INPUT_SIZE_603: usize = 4; -const IN_603: usize = 4; -const OUT_603: usize = 0; -fn aiur_fn_603( - inp: [G; IN_603], +const INPUT_SIZE_599: usize = 4; +const IN_599: usize = 4; +const OUT_599: usize = 0; +fn aiur_fn_599( + inp: [G; IN_599], record: &mut QueryRecord, io_buffer: &mut IOBuffer, unconstrained: bool, -) -> Result<[G; OUT_603], ExecError> { +) -> Result<[G; OUT_599], ExecError> { stacker::maybe_grow(64 * 1024, 4 * 1024 * 1024, || { let __v_0: G = inp[0]; let __v_1: G = inp[1]; @@ -51181,8 +50897,8 @@ fn aiur_fn_603( let __v_4: G = (__v_1 - __v_3); match __v_4.as_canonical_u64() { 0u64 => { - let __ret: [G; OUT_603] = []; - if let Some(result) = record.function_queries[603].get_mut(&inp[..]) { debug_assert_eq!(result.output, &__ret[..]); if !unconstrained { *result.multiplicity += G::ONE; } } else { record.function_queries[603].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained)); }; + let __ret: [G; OUT_599] = []; + if let Some(result) = record.function_queries[599].get_mut(&inp[..]) { debug_assert_eq!(result.output, &__ret[..]); if !unconstrained { *result.multiplicity += G::ONE; } } else { record.function_queries[599].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained)); }; return Ok(__ret); }, _ => { @@ -51207,9 +50923,9 @@ fn aiur_fn_603( } let __v_15: G = G::from_u64(1); let __v_16: G = (__v_3 + __v_15); - let __r_arr: [G; OUT_603] = { let __args: [G; IN_603] = [__v_7, __v_1, __v_2, __v_16]; let __cu = unconstrained; if let Some(result) = record.function_queries[603].get_mut(&__args[..]) { if !__cu && *result.multiplicity == G::ZERO { aiur_fn_603(__args, record, io_buffer, false)? } else { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_603] = unsafe { *(result.output.as_ptr() as *const [G; OUT_603]) }; __ret } } else { aiur_fn_603(__args, record, io_buffer, __cu)? } }; - let __ret: [G; OUT_603] = []; - if let Some(result) = record.function_queries[603].get_mut(&inp[..]) { debug_assert_eq!(result.output, &__ret[..]); if !unconstrained { *result.multiplicity += G::ONE; } } else { record.function_queries[603].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained)); }; + let __r_arr: [G; OUT_599] = { let __args: [G; IN_599] = [__v_7, __v_1, __v_2, __v_16]; let __cu = unconstrained; if let Some(result) = record.function_queries[599].get_mut(&__args[..]) { if !__cu && *result.multiplicity == G::ZERO { aiur_fn_599(__args, record, io_buffer, false)? } else { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_599] = unsafe { *(result.output.as_ptr() as *const [G; OUT_599]) }; __ret } } else { aiur_fn_599(__args, record, io_buffer, __cu)? } }; + let __ret: [G; OUT_599] = []; + if let Some(result) = record.function_queries[599].get_mut(&inp[..]) { debug_assert_eq!(result.output, &__ret[..]); if !unconstrained { *result.multiplicity += G::ONE; } } else { record.function_queries[599].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained)); }; return Ok(__ret); }, _ => { @@ -51226,22 +50942,22 @@ fn aiur_fn_603( }) } -const INPUT_SIZE_604: usize = 5; -const IN_604: usize = 5; -const OUT_604: usize = 0; -fn aiur_fn_604( - inp: [G; IN_604], +const INPUT_SIZE_600: usize = 5; +const IN_600: usize = 5; +const OUT_600: usize = 0; +fn aiur_fn_600( + inp: [G; IN_600], record: &mut QueryRecord, io_buffer: &mut IOBuffer, unconstrained: bool, -) -> Result<[G; OUT_604], ExecError> { +) -> Result<[G; OUT_600], ExecError> { stacker::maybe_grow(64 * 1024, 4 * 1024 * 1024, || { let __v_0: G = inp[0]; let __v_1: G = inp[1]; let __v_2: G = inp[2]; let __v_3: G = inp[3]; let __v_4: G = inp[4]; - let __r_arr: [G; OUT_287] = { let __args: [G; IN_287] = [__v_0]; let __cu = unconstrained; if let Some(result) = record.function_queries[287].get_mut(&__args[..]) { if !__cu && *result.multiplicity == G::ZERO { aiur_fn_287(__args, record, io_buffer, false)? } else { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_287] = unsafe { *(result.output.as_ptr() as *const [G; OUT_287]) }; __ret } } else { aiur_fn_287(__args, record, io_buffer, __cu)? } }; + let __r_arr: [G; OUT_283] = { let __args: [G; IN_283] = [__v_0]; let __cu = unconstrained; if let Some(result) = record.function_queries[283].get_mut(&__args[..]) { if !__cu && *result.multiplicity == G::ZERO { aiur_fn_283(__args, record, io_buffer, false)? } else { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_283] = unsafe { *(result.output.as_ptr() as *const [G; OUT_283]) }; __ret } } else { aiur_fn_283(__args, record, io_buffer, __cu)? } }; let __v_5: G = __r_arr[0]; let __loaded: [G; 12] = { let __mq = record.memory_queries.get_mut(&12).ok_or(ExecError::InvalidMemorySize(12))?; let __ptr_u64 = __v_5.as_canonical_u64(); let __ptr_usize = usize::try_from(__ptr_u64).ok().ok_or(ExecError::PointerTooLarge(__ptr_u64))?; let (__args, __mult) = __mq.get_index_mut(__ptr_usize).ok_or(ExecError::UnboundPointer { ptr: __ptr_u64, size: 12 })?; if !unconstrained { *__mult += G::ONE; } let __arr: [G; 12] = __args[..12].try_into().unwrap(); __arr }; let __v_6: G = __loaded[0]; @@ -51259,25 +50975,25 @@ fn aiur_fn_604( match __v_6.as_canonical_u64() { 5u64 => { let __v_18: G = G::from_u64(0); - let __r_arr: [G; OUT_587] = { let __args: [G; IN_587] = [__v_1, __v_7, __v_18]; let __cu = unconstrained; if let Some(result) = record.function_queries[587].get_mut(&__args[..]) { if !__cu && *result.multiplicity == G::ZERO { aiur_fn_587(__args, record, io_buffer, false)? } else { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_587] = unsafe { *(result.output.as_ptr() as *const [G; OUT_587]) }; __ret } } else { aiur_fn_587(__args, record, io_buffer, __cu)? } }; + let __r_arr: [G; OUT_583] = { let __args: [G; IN_583] = [__v_1, __v_7, __v_18]; let __cu = unconstrained; if let Some(result) = record.function_queries[583].get_mut(&__args[..]) { if !__cu && *result.multiplicity == G::ZERO { aiur_fn_583(__args, record, io_buffer, false)? } else { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_583] = unsafe { *(result.output.as_ptr() as *const [G; OUT_583]) }; __ret } } else { aiur_fn_583(__args, record, io_buffer, __cu)? } }; let __v_19: G = G::from_u64(0); - let __r_arr: [G; OUT_603] = { let __args: [G; IN_603] = [__v_2, __v_9, __v_4, __v_19]; let __cu = unconstrained; if let Some(result) = record.function_queries[603].get_mut(&__args[..]) { if !__cu && *result.multiplicity == G::ZERO { aiur_fn_603(__args, record, io_buffer, false)? } else { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_603] = unsafe { *(result.output.as_ptr() as *const [G; OUT_603]) }; __ret } } else { aiur_fn_603(__args, record, io_buffer, __cu)? } }; - let __r_arr: [G; OUT_764] = { let __args: [G; IN_764] = [__v_2]; let __cu = unconstrained; if let Some(result) = record.function_queries[764].get_mut(&__args[..]) { if !__cu && *result.multiplicity == G::ZERO { aiur_fn_764(__args, record, io_buffer, false)? } else { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_764] = unsafe { *(result.output.as_ptr() as *const [G; OUT_764]) }; __ret } } else { aiur_fn_764(__args, record, io_buffer, __cu)? } }; + let __r_arr: [G; OUT_599] = { let __args: [G; IN_599] = [__v_2, __v_9, __v_4, __v_19]; let __cu = unconstrained; if let Some(result) = record.function_queries[599].get_mut(&__args[..]) { if !__cu && *result.multiplicity == G::ZERO { aiur_fn_599(__args, record, io_buffer, false)? } else { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_599] = unsafe { *(result.output.as_ptr() as *const [G; OUT_599]) }; __ret } } else { aiur_fn_599(__args, record, io_buffer, __cu)? } }; + let __r_arr: [G; OUT_760] = { let __args: [G; IN_760] = [__v_2]; let __cu = unconstrained; if let Some(result) = record.function_queries[760].get_mut(&__args[..]) { if !__cu && *result.multiplicity == G::ZERO { aiur_fn_760(__args, record, io_buffer, false)? } else { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_760] = unsafe { *(result.output.as_ptr() as *const [G; OUT_760]) }; __ret } } else { aiur_fn_760(__args, record, io_buffer, __cu)? } }; let __v_20: G = __r_arr[0]; let __v_21: G = (__v_9 + __v_10); if (__v_20 != __v_21) { return Err(ExecError::AssertEqMismatch { lhs: __v_20.as_canonical_u64(), rhs: __v_21.as_canonical_u64(), msg: Some("recursive occurrence is not fully applied".to_string()) }); } - let __r_arr: [G; OUT_775] = { let __args: [G; IN_775] = [__v_2, __v_9]; let __cu = unconstrained; if let Some(result) = record.function_queries[775].get_mut(&__args[..]) { if !__cu && *result.multiplicity == G::ZERO { aiur_fn_775(__args, record, io_buffer, false)? } else { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_775] = unsafe { *(result.output.as_ptr() as *const [G; OUT_775]) }; __ret } } else { aiur_fn_775(__args, record, io_buffer, __cu)? } }; + let __r_arr: [G; OUT_771] = { let __args: [G; IN_771] = [__v_2, __v_9]; let __cu = unconstrained; if let Some(result) = record.function_queries[771].get_mut(&__args[..]) { if !__cu && *result.multiplicity == G::ZERO { aiur_fn_771(__args, record, io_buffer, false)? } else { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_771] = unsafe { *(result.output.as_ptr() as *const [G; OUT_771]) }; __ret } } else { aiur_fn_771(__args, record, io_buffer, __cu)? } }; let __v_22: G = __r_arr[0]; - let __r_arr: [G; OUT_601] = { let __args: [G; IN_601] = [__v_22, __v_3]; let __cu = unconstrained; if let Some(result) = record.function_queries[601].get_mut(&__args[..]) { if !__cu && *result.multiplicity == G::ZERO { aiur_fn_601(__args, record, io_buffer, false)? } else { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_601] = unsafe { *(result.output.as_ptr() as *const [G; OUT_601]) }; __ret } } else { aiur_fn_601(__args, record, io_buffer, __cu)? } }; + let __r_arr: [G; OUT_597] = { let __args: [G; IN_597] = [__v_22, __v_3]; let __cu = unconstrained; if let Some(result) = record.function_queries[597].get_mut(&__args[..]) { if !__cu && *result.multiplicity == G::ZERO { aiur_fn_597(__args, record, io_buffer, false)? } else { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_597] = unsafe { *(result.output.as_ptr() as *const [G; OUT_597]) }; __ret } } else { aiur_fn_597(__args, record, io_buffer, __cu)? } }; let __v_23: G = __r_arr[0]; let __v_24: G = G::from_u64(0); if (__v_23 != __v_24) { return Err(ExecError::AssertEqMismatch { lhs: __v_23.as_canonical_u64(), rhs: __v_24.as_canonical_u64(), msg: Some("recursive occurrence: index argument mentions the block".to_string()) }); } - let __ret: [G; OUT_604] = []; - if let Some(result) = record.function_queries[604].get_mut(&inp[..]) { debug_assert_eq!(result.output, &__ret[..]); if !unconstrained { *result.multiplicity += G::ONE; } } else { record.function_queries[604].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained)); }; + let __ret: [G; OUT_600] = []; + if let Some(result) = record.function_queries[600].get_mut(&inp[..]) { debug_assert_eq!(result.output, &__ret[..]); if !unconstrained { *result.multiplicity += G::ONE; } } else { record.function_queries[600].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained)); }; return Ok(__ret); }, _ => { @@ -51287,30 +51003,30 @@ fn aiur_fn_604( }) } -const INPUT_SIZE_605: usize = 4; -const IN_605: usize = 4; -const OUT_605: usize = 0; -fn aiur_fn_605( - inp: [G; IN_605], +const INPUT_SIZE_601: usize = 4; +const IN_601: usize = 4; +const OUT_601: usize = 0; +fn aiur_fn_601( + inp: [G; IN_601], record: &mut QueryRecord, io_buffer: &mut IOBuffer, unconstrained: bool, -) -> Result<[G; OUT_605], ExecError> { +) -> Result<[G; OUT_601], ExecError> { stacker::maybe_grow(64 * 1024, 4 * 1024 * 1024, || { let __v_0: G = inp[0]; let __v_1: G = inp[1]; let __v_2: G = inp[2]; let __v_3: G = inp[3]; - let __r_arr: [G; OUT_600] = { let __args: [G; IN_600] = [__v_0, __v_1]; let __cu = unconstrained; if let Some(result) = record.function_queries[600].get_mut(&__args[..]) { if !__cu && *result.multiplicity == G::ZERO { aiur_fn_600(__args, record, io_buffer, false)? } else { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_600] = unsafe { *(result.output.as_ptr() as *const [G; OUT_600]) }; __ret } } else { aiur_fn_600(__args, record, io_buffer, __cu)? } }; + let __r_arr: [G; OUT_596] = { let __args: [G; IN_596] = [__v_0, __v_1]; let __cu = unconstrained; if let Some(result) = record.function_queries[596].get_mut(&__args[..]) { if !__cu && *result.multiplicity == G::ZERO { aiur_fn_596(__args, record, io_buffer, false)? } else { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_596] = unsafe { *(result.output.as_ptr() as *const [G; OUT_596]) }; __ret } } else { aiur_fn_596(__args, record, io_buffer, __cu)? } }; let __v_4: G = __r_arr[0]; match __v_4.as_canonical_u64() { 0u64 => { - let __ret: [G; OUT_605] = []; - if let Some(result) = record.function_queries[605].get_mut(&inp[..]) { debug_assert_eq!(result.output, &__ret[..]); if !unconstrained { *result.multiplicity += G::ONE; } } else { record.function_queries[605].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained)); }; + let __ret: [G; OUT_601] = []; + if let Some(result) = record.function_queries[601].get_mut(&inp[..]) { debug_assert_eq!(result.output, &__ret[..]); if !unconstrained { *result.multiplicity += G::ONE; } } else { record.function_queries[601].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained)); }; return Ok(__ret); }, _ => { - let __r_arr: [G; OUT_418] = { let __args: [G; IN_418] = [__v_0, __v_2]; let __cu = unconstrained; if let Some(result) = record.function_queries[418].get_mut(&__args[..]) { if !__cu && *result.multiplicity == G::ZERO { aiur_fn_418(__args, record, io_buffer, false)? } else { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_418] = unsafe { *(result.output.as_ptr() as *const [G; OUT_418]) }; __ret } } else { aiur_fn_418(__args, record, io_buffer, __cu)? } }; + let __r_arr: [G; OUT_414] = { let __args: [G; IN_414] = [__v_0, __v_2]; let __cu = unconstrained; if let Some(result) = record.function_queries[414].get_mut(&__args[..]) { if !__cu && *result.multiplicity == G::ZERO { aiur_fn_414(__args, record, io_buffer, false)? } else { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_414] = unsafe { *(result.output.as_ptr() as *const [G; OUT_414]) }; __ret } } else { aiur_fn_414(__args, record, io_buffer, __cu)? } }; let __v_5: G = __r_arr[0]; let __loaded: [G; 4] = { let __mq = record.memory_queries.get_mut(&4).ok_or(ExecError::InvalidMemorySize(4))?; let __ptr_u64 = __v_5.as_canonical_u64(); let __ptr_usize = usize::try_from(__ptr_u64).ok().ok_or(ExecError::PointerTooLarge(__ptr_u64))?; let (__args, __mult) = __mq.get_index_mut(__ptr_usize).ok_or(ExecError::UnboundPointer { ptr: __ptr_u64, size: 4 })?; if !unconstrained { *__mult += G::ONE; } let __arr: [G; 4] = __args[..4].try_into().unwrap(); __arr }; let __v_6: G = __loaded[0]; @@ -51321,15 +51037,15 @@ fn aiur_fn_605( 5u64 => { let __v_10: G = G::from_u64(0); let __v_11: G = { let __values: [G; 3] = [__v_10, __v_7, __v_2]; let __mq = record.memory_queries.get_mut(&3).ok_or(ExecError::InvalidMemorySize(3))?; if let Some(result) = __mq.get_mut(&__values[..]) { if !unconstrained { *result.multiplicity += G::ONE; } result.output[0] } else { let __ptr = G::from_usize(__mq.len()); __mq.insert(&__values[..], &[__ptr], G::from_bool(!unconstrained)); __ptr } }; - let __r_arr: [G; OUT_600] = { let __args: [G; IN_600] = [__v_7, __v_1]; let __cu = unconstrained; if let Some(result) = record.function_queries[600].get_mut(&__args[..]) { if !__cu && *result.multiplicity == G::ZERO { aiur_fn_600(__args, record, io_buffer, false)? } else { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_600] = unsafe { *(result.output.as_ptr() as *const [G; OUT_600]) }; __ret } } else { aiur_fn_600(__args, record, io_buffer, __cu)? } }; + let __r_arr: [G; OUT_596] = { let __args: [G; IN_596] = [__v_7, __v_1]; let __cu = unconstrained; if let Some(result) = record.function_queries[596].get_mut(&__args[..]) { if !__cu && *result.multiplicity == G::ZERO { aiur_fn_596(__args, record, io_buffer, false)? } else { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_596] = unsafe { *(result.output.as_ptr() as *const [G; OUT_596]) }; __ret } } else { aiur_fn_596(__args, record, io_buffer, __cu)? } }; let __v_12: G = __r_arr[0]; let __v_13: G = G::from_u64(0); if (__v_12 != __v_13) { return Err(ExecError::AssertEqMismatch { lhs: __v_12.as_canonical_u64(), rhs: __v_13.as_canonical_u64(), msg: Some("strict positivity: block occurs left of an arrow".to_string()) }); } - let __r_arr: [G; OUT_605] = { let __args: [G; IN_605] = [__v_8, __v_1, __v_11, __v_3]; let __cu = unconstrained; if let Some(result) = record.function_queries[605].get_mut(&__args[..]) { if !__cu && *result.multiplicity == G::ZERO { aiur_fn_605(__args, record, io_buffer, false)? } else { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_605] = unsafe { *(result.output.as_ptr() as *const [G; OUT_605]) }; __ret } } else { aiur_fn_605(__args, record, io_buffer, __cu)? } }; - let __ret: [G; OUT_605] = []; - if let Some(result) = record.function_queries[605].get_mut(&inp[..]) { debug_assert_eq!(result.output, &__ret[..]); if !unconstrained { *result.multiplicity += G::ONE; } } else { record.function_queries[605].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained)); }; + let __r_arr: [G; OUT_601] = { let __args: [G; IN_601] = [__v_8, __v_1, __v_11, __v_3]; let __cu = unconstrained; if let Some(result) = record.function_queries[601].get_mut(&__args[..]) { if !__cu && *result.multiplicity == G::ZERO { aiur_fn_601(__args, record, io_buffer, false)? } else { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_601] = unsafe { *(result.output.as_ptr() as *const [G; OUT_601]) }; __ret } } else { aiur_fn_601(__args, record, io_buffer, __cu)? } }; + let __ret: [G; OUT_601] = []; + if let Some(result) = record.function_queries[601].get_mut(&inp[..]) { debug_assert_eq!(result.output, &__ret[..]); if !unconstrained { *result.multiplicity += G::ONE; } } else { record.function_queries[601].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained)); }; return Ok(__ret); }, _ => { @@ -51343,28 +51059,28 @@ fn aiur_fn_605( let __v_15: G = __loaded[3]; match __v_12.as_canonical_u64() { 2u64 => { - let __r_arr: [G; OUT_599] = { let __args: [G; IN_599] = [__v_13, __v_1]; let __cu = unconstrained; if let Some(result) = record.function_queries[599].get_mut(&__args[..]) { if !__cu && *result.multiplicity == G::ZERO { aiur_fn_599(__args, record, io_buffer, false)? } else { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_599] = unsafe { *(result.output.as_ptr() as *const [G; OUT_599]) }; __ret } } else { aiur_fn_599(__args, record, io_buffer, __cu)? } }; + let __r_arr: [G; OUT_595] = { let __args: [G; IN_595] = [__v_13, __v_1]; let __cu = unconstrained; if let Some(result) = record.function_queries[595].get_mut(&__args[..]) { if !__cu && *result.multiplicity == G::ZERO { aiur_fn_595(__args, record, io_buffer, false)? } else { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_595] = unsafe { *(result.output.as_ptr() as *const [G; OUT_595]) }; __ret } } else { aiur_fn_595(__args, record, io_buffer, __cu)? } }; let __v_16: G = __r_arr[0]; match __v_16.as_canonical_u64() { 1u64 => { match __v_3.as_canonical_u64() { 1u64 => { - let __r_arr: [G; OUT_764] = { let __args: [G; IN_764] = [__v_2]; let __cu = unconstrained; if let Some(result) = record.function_queries[764].get_mut(&__args[..]) { if !__cu && *result.multiplicity == G::ZERO { aiur_fn_764(__args, record, io_buffer, false)? } else { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_764] = unsafe { *(result.output.as_ptr() as *const [G; OUT_764]) }; __ret } } else { aiur_fn_764(__args, record, io_buffer, __cu)? } }; + let __r_arr: [G; OUT_760] = { let __args: [G; IN_760] = [__v_2]; let __cu = unconstrained; if let Some(result) = record.function_queries[760].get_mut(&__args[..]) { if !__cu && *result.multiplicity == G::ZERO { aiur_fn_760(__args, record, io_buffer, false)? } else { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_760] = unsafe { *(result.output.as_ptr() as *const [G; OUT_760]) }; __ret } } else { aiur_fn_760(__args, record, io_buffer, __cu)? } }; let __v_17: G = __r_arr[0]; - let __r_arr: [G; OUT_604] = { let __args: [G; IN_604] = [__v_13, __v_14, __v_11, __v_1, __v_17]; let __cu = unconstrained; if let Some(result) = record.function_queries[604].get_mut(&__args[..]) { if !__cu && *result.multiplicity == G::ZERO { aiur_fn_604(__args, record, io_buffer, false)? } else { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_604] = unsafe { *(result.output.as_ptr() as *const [G; OUT_604]) }; __ret } } else { aiur_fn_604(__args, record, io_buffer, __cu)? } }; - let __ret: [G; OUT_605] = []; - if let Some(result) = record.function_queries[605].get_mut(&inp[..]) { debug_assert_eq!(result.output, &__ret[..]); if !unconstrained { *result.multiplicity += G::ONE; } } else { record.function_queries[605].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained)); }; + let __r_arr: [G; OUT_600] = { let __args: [G; IN_600] = [__v_13, __v_14, __v_11, __v_1, __v_17]; let __cu = unconstrained; if let Some(result) = record.function_queries[600].get_mut(&__args[..]) { if !__cu && *result.multiplicity == G::ZERO { aiur_fn_600(__args, record, io_buffer, false)? } else { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_600] = unsafe { *(result.output.as_ptr() as *const [G; OUT_600]) }; __ret } } else { aiur_fn_600(__args, record, io_buffer, __cu)? } }; + let __ret: [G; OUT_601] = []; + if let Some(result) = record.function_queries[601].get_mut(&inp[..]) { debug_assert_eq!(result.output, &__ret[..]); if !unconstrained { *result.multiplicity += G::ONE; } } else { record.function_queries[601].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained)); }; return Ok(__ret); }, _ => { - let __ret: [G; OUT_605] = []; - if let Some(result) = record.function_queries[605].get_mut(&inp[..]) { debug_assert_eq!(result.output, &__ret[..]); if !unconstrained { *result.multiplicity += G::ONE; } } else { record.function_queries[605].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained)); }; + let __ret: [G; OUT_601] = []; + if let Some(result) = record.function_queries[601].get_mut(&inp[..]) { debug_assert_eq!(result.output, &__ret[..]); if !unconstrained { *result.multiplicity += G::ONE; } } else { record.function_queries[601].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained)); }; return Ok(__ret); }, } }, _ => { - let __r_arr: [G; OUT_287] = { let __args: [G; IN_287] = [__v_13]; let __cu = unconstrained; if let Some(result) = record.function_queries[287].get_mut(&__args[..]) { if !__cu && *result.multiplicity == G::ZERO { aiur_fn_287(__args, record, io_buffer, false)? } else { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_287] = unsafe { *(result.output.as_ptr() as *const [G; OUT_287]) }; __ret } } else { aiur_fn_287(__args, record, io_buffer, __cu)? } }; + let __r_arr: [G; OUT_283] = { let __args: [G; IN_283] = [__v_13]; let __cu = unconstrained; if let Some(result) = record.function_queries[283].get_mut(&__args[..]) { if !__cu && *result.multiplicity == G::ZERO { aiur_fn_283(__args, record, io_buffer, false)? } else { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_283] = unsafe { *(result.output.as_ptr() as *const [G; OUT_283]) }; __ret } } else { aiur_fn_283(__args, record, io_buffer, __cu)? } }; let __v_17: G = __r_arr[0]; let __loaded: [G; 12] = { let __mq = record.memory_queries.get_mut(&12).ok_or(ExecError::InvalidMemorySize(12))?; let __ptr_u64 = __v_17.as_canonical_u64(); let __ptr_usize = usize::try_from(__ptr_u64).ok().ok_or(ExecError::PointerTooLarge(__ptr_u64))?; let (__args, __mult) = __mq.get_index_mut(__ptr_usize).ok_or(ExecError::UnboundPointer { ptr: __ptr_u64, size: 12 })?; if !unconstrained { *__mult += G::ONE; } let __arr: [G; 12] = __args[..12].try_into().unwrap(); __arr }; let __v_18: G = __loaded[0]; @@ -51381,24 +51097,24 @@ fn aiur_fn_605( let __v_29: G = __loaded[11]; match __v_18.as_canonical_u64() { 5u64 => { - let __r_arr: [G; OUT_775] = { let __args: [G; IN_775] = [__v_11, __v_21]; let __cu = unconstrained; if let Some(result) = record.function_queries[775].get_mut(&__args[..]) { if !__cu && *result.multiplicity == G::ZERO { aiur_fn_775(__args, record, io_buffer, false)? } else { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_775] = unsafe { *(result.output.as_ptr() as *const [G; OUT_775]) }; __ret } } else { aiur_fn_775(__args, record, io_buffer, __cu)? } }; + let __r_arr: [G; OUT_771] = { let __args: [G; IN_771] = [__v_11, __v_21]; let __cu = unconstrained; if let Some(result) = record.function_queries[771].get_mut(&__args[..]) { if !__cu && *result.multiplicity == G::ZERO { aiur_fn_771(__args, record, io_buffer, false)? } else { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_771] = unsafe { *(result.output.as_ptr() as *const [G; OUT_771]) }; __ret } } else { aiur_fn_771(__args, record, io_buffer, __cu)? } }; let __v_30: G = __r_arr[0]; let __v_31: G = G::from_u64(0); let __v_32: G = { let __values: [G; 3] = [__v_31, __v_25, __v_1]; let __mq = record.memory_queries.get_mut(&3).ok_or(ExecError::InvalidMemorySize(3))?; if let Some(result) = __mq.get_mut(&__values[..]) { if !unconstrained { *result.multiplicity += G::ONE; } result.output[0] } else { let __ptr = G::from_usize(__mq.len()); __mq.insert(&__values[..], &[__ptr], G::from_bool(!unconstrained)); __ptr } }; - let __r_arr: [G; OUT_774] = { let __args: [G; IN_774] = [__v_11, __v_21]; let __cu = unconstrained; if let Some(result) = record.function_queries[774].get_mut(&__args[..]) { if !__cu && *result.multiplicity == G::ZERO { aiur_fn_774(__args, record, io_buffer, false)? } else { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_774] = unsafe { *(result.output.as_ptr() as *const [G; OUT_774]) }; __ret } } else { aiur_fn_774(__args, record, io_buffer, __cu)? } }; + let __r_arr: [G; OUT_770] = { let __args: [G; IN_770] = [__v_11, __v_21]; let __cu = unconstrained; if let Some(result) = record.function_queries[770].get_mut(&__args[..]) { if !__cu && *result.multiplicity == G::ZERO { aiur_fn_770(__args, record, io_buffer, false)? } else { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_770] = unsafe { *(result.output.as_ptr() as *const [G; OUT_770]) }; __ret } } else { aiur_fn_770(__args, record, io_buffer, __cu)? } }; let __v_33: G = __r_arr[0]; - let __r_arr: [G; OUT_762] = { let __args: [G; IN_762] = [__v_33]; let __cu = unconstrained; if let Some(result) = record.function_queries[762].get_mut(&__args[..]) { if !__cu && *result.multiplicity == G::ZERO { aiur_fn_762(__args, record, io_buffer, false)? } else { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_762] = unsafe { *(result.output.as_ptr() as *const [G; OUT_762]) }; __ret } } else { aiur_fn_762(__args, record, io_buffer, __cu)? } }; + let __r_arr: [G; OUT_758] = { let __args: [G; IN_758] = [__v_33]; let __cu = unconstrained; if let Some(result) = record.function_queries[758].get_mut(&__args[..]) { if !__cu && *result.multiplicity == G::ZERO { aiur_fn_758(__args, record, io_buffer, false)? } else { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_758] = unsafe { *(result.output.as_ptr() as *const [G; OUT_758]) }; __ret } } else { aiur_fn_758(__args, record, io_buffer, __cu)? } }; let __v_34: G = __r_arr[0]; - let __r_arr: [G; OUT_601] = { let __args: [G; IN_601] = [__v_30, __v_1]; let __cu = unconstrained; if let Some(result) = record.function_queries[601].get_mut(&__args[..]) { if !__cu && *result.multiplicity == G::ZERO { aiur_fn_601(__args, record, io_buffer, false)? } else { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_601] = unsafe { *(result.output.as_ptr() as *const [G; OUT_601]) }; __ret } } else { aiur_fn_601(__args, record, io_buffer, __cu)? } }; + let __r_arr: [G; OUT_597] = { let __args: [G; IN_597] = [__v_30, __v_1]; let __cu = unconstrained; if let Some(result) = record.function_queries[597].get_mut(&__args[..]) { if !__cu && *result.multiplicity == G::ZERO { aiur_fn_597(__args, record, io_buffer, false)? } else { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_597] = unsafe { *(result.output.as_ptr() as *const [G; OUT_597]) }; __ret } } else { aiur_fn_597(__args, record, io_buffer, __cu)? } }; let __v_35: G = __r_arr[0]; let __v_36: G = G::from_u64(0); if (__v_35 != __v_36) { return Err(ExecError::AssertEqMismatch { lhs: __v_35.as_canonical_u64(), rhs: __v_36.as_canonical_u64(), msg: Some("strict positivity: block occurs in a nested inductive's index args".to_string()) }); } let __v_37: G = G::from_u64(0); - let __r_arr: [G; OUT_606] = { let __args: [G; IN_606] = [__v_25, __v_26, __v_23, __v_32, __v_37, __v_21, __v_34]; let __cu = unconstrained; if let Some(result) = record.function_queries[606].get_mut(&__args[..]) { if !__cu && *result.multiplicity == G::ZERO { aiur_fn_606(__args, record, io_buffer, false)? } else { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_606] = unsafe { *(result.output.as_ptr() as *const [G; OUT_606]) }; __ret } } else { aiur_fn_606(__args, record, io_buffer, __cu)? } }; - let __ret: [G; OUT_605] = []; - if let Some(result) = record.function_queries[605].get_mut(&inp[..]) { debug_assert_eq!(result.output, &__ret[..]); if !unconstrained { *result.multiplicity += G::ONE; } } else { record.function_queries[605].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained)); }; + let __r_arr: [G; OUT_602] = { let __args: [G; IN_602] = [__v_25, __v_26, __v_23, __v_32, __v_37, __v_21, __v_34]; let __cu = unconstrained; if let Some(result) = record.function_queries[602].get_mut(&__args[..]) { if !__cu && *result.multiplicity == G::ZERO { aiur_fn_602(__args, record, io_buffer, false)? } else { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_602] = unsafe { *(result.output.as_ptr() as *const [G; OUT_602]) }; __ret } } else { aiur_fn_602(__args, record, io_buffer, __cu)? } }; + let __ret: [G; OUT_601] = []; + if let Some(result) = record.function_queries[601].get_mut(&inp[..]) { debug_assert_eq!(result.output, &__ret[..]); if !unconstrained { *result.multiplicity += G::ONE; } } else { record.function_queries[601].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained)); }; return Ok(__ret); }, _ => { @@ -51419,15 +51135,15 @@ fn aiur_fn_605( }) } -const INPUT_SIZE_606: usize = 7; -const IN_606: usize = 7; -const OUT_606: usize = 0; -fn aiur_fn_606( - inp: [G; IN_606], +const INPUT_SIZE_602: usize = 7; +const IN_602: usize = 7; +const OUT_602: usize = 0; +fn aiur_fn_602( + inp: [G; IN_602], record: &mut QueryRecord, io_buffer: &mut IOBuffer, unconstrained: bool, -) -> Result<[G; OUT_606], ExecError> { +) -> Result<[G; OUT_602], ExecError> { stacker::maybe_grow(64 * 1024, 4 * 1024 * 1024, || { let __v_0: G = inp[0]; let __v_1: G = inp[1]; @@ -51439,12 +51155,12 @@ fn aiur_fn_606( let __v_7: G = (__v_2 - __v_4); match __v_7.as_canonical_u64() { 0u64 => { - let __ret: [G; OUT_606] = []; - if let Some(result) = record.function_queries[606].get_mut(&inp[..]) { debug_assert_eq!(result.output, &__ret[..]); if !unconstrained { *result.multiplicity += G::ONE; } } else { record.function_queries[606].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained)); }; + let __ret: [G; OUT_602] = []; + if let Some(result) = record.function_queries[602].get_mut(&inp[..]) { debug_assert_eq!(result.output, &__ret[..]); if !unconstrained { *result.multiplicity += G::ONE; } } else { record.function_queries[602].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained)); }; return Ok(__ret); }, _ => { - let __r_arr: [G; OUT_290] = { let __args: [G; IN_290] = [__v_0, __v_1, __v_4]; let __cu = unconstrained; if let Some(result) = record.function_queries[290].get_mut(&__args[..]) { if !__cu && *result.multiplicity == G::ZERO { aiur_fn_290(__args, record, io_buffer, false)? } else { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_290] = unsafe { *(result.output.as_ptr() as *const [G; OUT_290]) }; __ret } } else { aiur_fn_290(__args, record, io_buffer, __cu)? } }; + let __r_arr: [G; OUT_286] = { let __args: [G; IN_286] = [__v_0, __v_1, __v_4]; let __cu = unconstrained; if let Some(result) = record.function_queries[286].get_mut(&__args[..]) { if !__cu && *result.multiplicity == G::ZERO { aiur_fn_286(__args, record, io_buffer, false)? } else { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_286] = unsafe { *(result.output.as_ptr() as *const [G; OUT_286]) }; __ret } } else { aiur_fn_286(__args, record, io_buffer, __cu)? } }; let __v_8: G = __r_arr[0]; let __loaded: [G; 12] = { let __mq = record.memory_queries.get_mut(&12).ok_or(ExecError::InvalidMemorySize(12))?; let __ptr_u64 = __v_8.as_canonical_u64(); let __ptr_usize = usize::try_from(__ptr_u64).ok().ok_or(ExecError::PointerTooLarge(__ptr_u64))?; let (__args, __mult) = __mq.get_index_mut(__ptr_usize).ok_or(ExecError::UnboundPointer { ptr: __ptr_u64, size: 12 })?; if !unconstrained { *__mult += G::ONE; } let __arr: [G; 12] = __args[..12].try_into().unwrap(); __arr }; let __v_9: G = __loaded[0]; @@ -51464,22 +51180,22 @@ fn aiur_fn_606( let __v_21: G = G::from_u64(1); let __v_22: G = G::from_u64(1); let __v_23: G = { let __values: [G; 3] = [__v_21, __v_22, __v_22]; let __mq = record.memory_queries.get_mut(&3).ok_or(ExecError::InvalidMemorySize(3))?; if let Some(result) = __mq.get_mut(&__values[..]) { if !unconstrained { *result.multiplicity += G::ONE; } result.output[0] } else { let __ptr = G::from_usize(__mq.len()); __mq.insert(&__values[..], &[__ptr], G::from_bool(!unconstrained)); __ptr } }; - let __r_arr: [G; OUT_602] = { let __args: [G; IN_602] = [__v_11, __v_5, __v_23]; let __cu = unconstrained; if let Some(result) = record.function_queries[602].get_mut(&__args[..]) { if !__cu && *result.multiplicity == G::ZERO { aiur_fn_602(__args, record, io_buffer, false)? } else { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_602] = unsafe { *(result.output.as_ptr() as *const [G; OUT_602]) }; __ret } } else { aiur_fn_602(__args, record, io_buffer, __cu)? } }; + let __r_arr: [G; OUT_598] = { let __args: [G; IN_598] = [__v_11, __v_5, __v_23]; let __cu = unconstrained; if let Some(result) = record.function_queries[598].get_mut(&__args[..]) { if !__cu && *result.multiplicity == G::ZERO { aiur_fn_598(__args, record, io_buffer, false)? } else { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_598] = unsafe { *(result.output.as_ptr() as *const [G; OUT_598]) }; __ret } } else { aiur_fn_598(__args, record, io_buffer, __cu)? } }; let __v_24: G = __r_arr[0]; let __v_25: G = __r_arr[1]; let __v_26: G = G::from_u64(0); - let __r_arr: [G; OUT_372] = { let __args: [G; IN_372] = [__v_24, __v_6, __v_26]; let __cu = unconstrained; if let Some(result) = record.function_queries[372].get_mut(&__args[..]) { if !__cu && *result.multiplicity == G::ZERO { aiur_fn_372(__args, record, io_buffer, false)? } else { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_372] = unsafe { *(result.output.as_ptr() as *const [G; OUT_372]) }; __ret } } else { aiur_fn_372(__args, record, io_buffer, __cu)? } }; + let __r_arr: [G; OUT_368] = { let __args: [G; IN_368] = [__v_24, __v_6, __v_26]; let __cu = unconstrained; if let Some(result) = record.function_queries[368].get_mut(&__args[..]) { if !__cu && *result.multiplicity == G::ZERO { aiur_fn_368(__args, record, io_buffer, false)? } else { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_368] = unsafe { *(result.output.as_ptr() as *const [G; OUT_368]) }; __ret } } else { aiur_fn_368(__args, record, io_buffer, __cu)? } }; let __v_27: G = __r_arr[0]; let __v_28: G = G::from_u64(1); let __v_29: G = G::from_u64(1); let __v_30: G = { let __values: [G; 3] = [__v_28, __v_29, __v_29]; let __mq = record.memory_queries.get_mut(&3).ok_or(ExecError::InvalidMemorySize(3))?; if let Some(result) = __mq.get_mut(&__values[..]) { if !unconstrained { *result.multiplicity += G::ONE; } result.output[0] } else { let __ptr = G::from_usize(__mq.len()); __mq.insert(&__values[..], &[__ptr], G::from_bool(!unconstrained)); __ptr } }; let __v_31: G = G::from_u64(0); - let __r_arr: [G; OUT_607] = { let __args: [G; IN_607] = [__v_27, __v_3, __v_30, __v_31]; let __cu = unconstrained; if let Some(result) = record.function_queries[607].get_mut(&__args[..]) { if !__cu && *result.multiplicity == G::ZERO { aiur_fn_607(__args, record, io_buffer, false)? } else { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_607] = unsafe { *(result.output.as_ptr() as *const [G; OUT_607]) }; __ret } } else { aiur_fn_607(__args, record, io_buffer, __cu)? } }; + let __r_arr: [G; OUT_603] = { let __args: [G; IN_603] = [__v_27, __v_3, __v_30, __v_31]; let __cu = unconstrained; if let Some(result) = record.function_queries[603].get_mut(&__args[..]) { if !__cu && *result.multiplicity == G::ZERO { aiur_fn_603(__args, record, io_buffer, false)? } else { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_603] = unsafe { *(result.output.as_ptr() as *const [G; OUT_603]) }; __ret } } else { aiur_fn_603(__args, record, io_buffer, __cu)? } }; let __v_32: G = G::from_u64(1); let __v_33: G = (__v_4 + __v_32); - let __r_arr: [G; OUT_606] = { let __args: [G; IN_606] = [__v_0, __v_1, __v_2, __v_3, __v_33, __v_5, __v_6]; let __cu = unconstrained; if let Some(result) = record.function_queries[606].get_mut(&__args[..]) { if !__cu && *result.multiplicity == G::ZERO { aiur_fn_606(__args, record, io_buffer, false)? } else { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_606] = unsafe { *(result.output.as_ptr() as *const [G; OUT_606]) }; __ret } } else { aiur_fn_606(__args, record, io_buffer, __cu)? } }; - let __ret: [G; OUT_606] = []; - if let Some(result) = record.function_queries[606].get_mut(&inp[..]) { debug_assert_eq!(result.output, &__ret[..]); if !unconstrained { *result.multiplicity += G::ONE; } } else { record.function_queries[606].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained)); }; + let __r_arr: [G; OUT_602] = { let __args: [G; IN_602] = [__v_0, __v_1, __v_2, __v_3, __v_33, __v_5, __v_6]; let __cu = unconstrained; if let Some(result) = record.function_queries[602].get_mut(&__args[..]) { if !__cu && *result.multiplicity == G::ZERO { aiur_fn_602(__args, record, io_buffer, false)? } else { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_602] = unsafe { *(result.output.as_ptr() as *const [G; OUT_602]) }; __ret } } else { aiur_fn_602(__args, record, io_buffer, __cu)? } }; + let __ret: [G; OUT_602] = []; + if let Some(result) = record.function_queries[602].get_mut(&inp[..]) { debug_assert_eq!(result.output, &__ret[..]); if !unconstrained { *result.multiplicity += G::ONE; } } else { record.function_queries[602].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained)); }; return Ok(__ret); }, _ => { @@ -51491,15 +51207,15 @@ fn aiur_fn_606( }) } -const INPUT_SIZE_607: usize = 4; -const IN_607: usize = 4; -const OUT_607: usize = 0; -fn aiur_fn_607( - inp: [G; IN_607], +const INPUT_SIZE_603: usize = 4; +const IN_603: usize = 4; +const OUT_603: usize = 0; +fn aiur_fn_603( + inp: [G; IN_603], record: &mut QueryRecord, io_buffer: &mut IOBuffer, unconstrained: bool, -) -> Result<[G; OUT_607], ExecError> { +) -> Result<[G; OUT_603], ExecError> { stacker::maybe_grow(64 * 1024, 4 * 1024 * 1024, || { let __v_0: G = inp[0]; let __v_1: G = inp[1]; @@ -51512,32 +51228,32 @@ fn aiur_fn_607( let __v_7: G = __loaded[3]; match __v_4.as_canonical_u64() { 5u64 => { - let __r_arr: [G; OUT_605] = { let __args: [G; IN_605] = [__v_5, __v_1, __v_2, __v_3]; let __cu = unconstrained; if let Some(result) = record.function_queries[605].get_mut(&__args[..]) { if !__cu && *result.multiplicity == G::ZERO { aiur_fn_605(__args, record, io_buffer, false)? } else { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_605] = unsafe { *(result.output.as_ptr() as *const [G; OUT_605]) }; __ret } } else { aiur_fn_605(__args, record, io_buffer, __cu)? } }; + let __r_arr: [G; OUT_601] = { let __args: [G; IN_601] = [__v_5, __v_1, __v_2, __v_3]; let __cu = unconstrained; if let Some(result) = record.function_queries[601].get_mut(&__args[..]) { if !__cu && *result.multiplicity == G::ZERO { aiur_fn_601(__args, record, io_buffer, false)? } else { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_601] = unsafe { *(result.output.as_ptr() as *const [G; OUT_601]) }; __ret } } else { aiur_fn_601(__args, record, io_buffer, __cu)? } }; let __v_8: G = G::from_u64(0); let __v_9: G = { let __values: [G; 3] = [__v_8, __v_5, __v_2]; let __mq = record.memory_queries.get_mut(&3).ok_or(ExecError::InvalidMemorySize(3))?; if let Some(result) = __mq.get_mut(&__values[..]) { if !unconstrained { *result.multiplicity += G::ONE; } result.output[0] } else { let __ptr = G::from_usize(__mq.len()); __mq.insert(&__values[..], &[__ptr], G::from_bool(!unconstrained)); __ptr } }; - let __r_arr: [G; OUT_607] = { let __args: [G; IN_607] = [__v_6, __v_1, __v_9, __v_3]; let __cu = unconstrained; if let Some(result) = record.function_queries[607].get_mut(&__args[..]) { if !__cu && *result.multiplicity == G::ZERO { aiur_fn_607(__args, record, io_buffer, false)? } else { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_607] = unsafe { *(result.output.as_ptr() as *const [G; OUT_607]) }; __ret } } else { aiur_fn_607(__args, record, io_buffer, __cu)? } }; - let __ret: [G; OUT_607] = []; - if let Some(result) = record.function_queries[607].get_mut(&inp[..]) { debug_assert_eq!(result.output, &__ret[..]); if !unconstrained { *result.multiplicity += G::ONE; } } else { record.function_queries[607].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained)); }; + let __r_arr: [G; OUT_603] = { let __args: [G; IN_603] = [__v_6, __v_1, __v_9, __v_3]; let __cu = unconstrained; if let Some(result) = record.function_queries[603].get_mut(&__args[..]) { if !__cu && *result.multiplicity == G::ZERO { aiur_fn_603(__args, record, io_buffer, false)? } else { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_603] = unsafe { *(result.output.as_ptr() as *const [G; OUT_603]) }; __ret } } else { aiur_fn_603(__args, record, io_buffer, __cu)? } }; + let __ret: [G; OUT_603] = []; + if let Some(result) = record.function_queries[603].get_mut(&inp[..]) { debug_assert_eq!(result.output, &__ret[..]); if !unconstrained { *result.multiplicity += G::ONE; } } else { record.function_queries[603].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained)); }; return Ok(__ret); }, _ => { - let __ret: [G; OUT_607] = []; - if let Some(result) = record.function_queries[607].get_mut(&inp[..]) { debug_assert_eq!(result.output, &__ret[..]); if !unconstrained { *result.multiplicity += G::ONE; } } else { record.function_queries[607].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained)); }; + let __ret: [G; OUT_603] = []; + if let Some(result) = record.function_queries[603].get_mut(&inp[..]) { debug_assert_eq!(result.output, &__ret[..]); if !unconstrained { *result.multiplicity += G::ONE; } } else { record.function_queries[603].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained)); }; return Ok(__ret); }, } }) } -const INPUT_SIZE_608: usize = 4; -const IN_608: usize = 4; -const OUT_608: usize = 0; -fn aiur_fn_608( - inp: [G; IN_608], +const INPUT_SIZE_604: usize = 4; +const IN_604: usize = 4; +const OUT_604: usize = 0; +fn aiur_fn_604( + inp: [G; IN_604], record: &mut QueryRecord, io_buffer: &mut IOBuffer, unconstrained: bool, -) -> Result<[G; OUT_608], ExecError> { +) -> Result<[G; OUT_604], ExecError> { stacker::maybe_grow(64 * 1024, 4 * 1024 * 1024, || { let __v_0: G = inp[0]; let __v_1: G = inp[1]; @@ -51548,26 +51264,26 @@ fn aiur_fn_608( let __v_6: G = G::from_u64(1); let __v_7: G = { let __values: [G; 3] = [__v_5, __v_6, __v_6]; let __mq = record.memory_queries.get_mut(&3).ok_or(ExecError::InvalidMemorySize(3))?; if let Some(result) = __mq.get_mut(&__values[..]) { if !unconstrained { *result.multiplicity += G::ONE; } result.output[0] } else { let __ptr = G::from_usize(__mq.len()); __mq.insert(&__values[..], &[__ptr], G::from_bool(!unconstrained)); __ptr } }; let __v_8: G = { let __values: [G; 3] = [__v_4, __v_2, __v_7]; let __mq = record.memory_queries.get_mut(&3).ok_or(ExecError::InvalidMemorySize(3))?; if let Some(result) = __mq.get_mut(&__values[..]) { if !unconstrained { *result.multiplicity += G::ONE; } result.output[0] } else { let __ptr = G::from_usize(__mq.len()); __mq.insert(&__values[..], &[__ptr], G::from_bool(!unconstrained)); __ptr } }; - let __r_arr: [G; OUT_602] = { let __args: [G; IN_602] = [__v_0, __v_1, __v_3]; let __cu = unconstrained; if let Some(result) = record.function_queries[602].get_mut(&__args[..]) { if !__cu && *result.multiplicity == G::ZERO { aiur_fn_602(__args, record, io_buffer, false)? } else { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_602] = unsafe { *(result.output.as_ptr() as *const [G; OUT_602]) }; __ret } } else { aiur_fn_602(__args, record, io_buffer, __cu)? } }; + let __r_arr: [G; OUT_598] = { let __args: [G; IN_598] = [__v_0, __v_1, __v_3]; let __cu = unconstrained; if let Some(result) = record.function_queries[598].get_mut(&__args[..]) { if !__cu && *result.multiplicity == G::ZERO { aiur_fn_598(__args, record, io_buffer, false)? } else { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_598] = unsafe { *(result.output.as_ptr() as *const [G; OUT_598]) }; __ret } } else { aiur_fn_598(__args, record, io_buffer, __cu)? } }; let __v_9: G = __r_arr[0]; let __v_10: G = __r_arr[1]; let __v_11: G = G::from_u64(1); - let __r_arr: [G; OUT_607] = { let __args: [G; IN_607] = [__v_9, __v_8, __v_10, __v_11]; let __cu = unconstrained; if let Some(result) = record.function_queries[607].get_mut(&__args[..]) { if !__cu && *result.multiplicity == G::ZERO { aiur_fn_607(__args, record, io_buffer, false)? } else { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_607] = unsafe { *(result.output.as_ptr() as *const [G; OUT_607]) }; __ret } } else { aiur_fn_607(__args, record, io_buffer, __cu)? } }; - let __ret: [G; OUT_608] = []; - if let Some(result) = record.function_queries[608].get_mut(&inp[..]) { debug_assert_eq!(result.output, &__ret[..]); if !unconstrained { *result.multiplicity += G::ONE; } } else { record.function_queries[608].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained)); }; + let __r_arr: [G; OUT_603] = { let __args: [G; IN_603] = [__v_9, __v_8, __v_10, __v_11]; let __cu = unconstrained; if let Some(result) = record.function_queries[603].get_mut(&__args[..]) { if !__cu && *result.multiplicity == G::ZERO { aiur_fn_603(__args, record, io_buffer, false)? } else { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_603] = unsafe { *(result.output.as_ptr() as *const [G; OUT_603]) }; __ret } } else { aiur_fn_603(__args, record, io_buffer, __cu)? } }; + let __ret: [G; OUT_604] = []; + if let Some(result) = record.function_queries[604].get_mut(&inp[..]) { debug_assert_eq!(result.output, &__ret[..]); if !unconstrained { *result.multiplicity += G::ONE; } } else { record.function_queries[604].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained)); }; return Ok(__ret); }) } -const INPUT_SIZE_609: usize = 8; -const IN_609: usize = 8; -const OUT_609: usize = 0; -fn aiur_fn_609( - inp: [G; IN_609], +const INPUT_SIZE_605: usize = 8; +const IN_605: usize = 8; +const OUT_605: usize = 0; +fn aiur_fn_605( + inp: [G; IN_605], record: &mut QueryRecord, io_buffer: &mut IOBuffer, unconstrained: bool, -) -> Result<[G; OUT_609], ExecError> { +) -> Result<[G; OUT_605], ExecError> { stacker::maybe_grow(64 * 1024, 4 * 1024 * 1024, || { let __v_0: G = inp[0]; let __v_1: G = inp[1]; @@ -51581,25 +51297,25 @@ fn aiur_fn_609( let __v_9: G = G::from_u64(1); let __v_10: G = G::from_u64(1); let __v_11: G = { let __values: [G; 3] = [__v_9, __v_10, __v_10]; let __mq = record.memory_queries.get_mut(&3).ok_or(ExecError::InvalidMemorySize(3))?; if let Some(result) = __mq.get_mut(&__values[..]) { if !unconstrained { *result.multiplicity += G::ONE; } result.output[0] } else { let __ptr = G::from_usize(__mq.len()); __mq.insert(&__values[..], &[__ptr], G::from_bool(!unconstrained)); __ptr } }; - let __r_arr: [G; OUT_593] = { let __args: [G; IN_593] = [__v_0, __v_8, __v_11]; let __cu = unconstrained; if let Some(result) = record.function_queries[593].get_mut(&__args[..]) { if !__cu && *result.multiplicity == G::ZERO { aiur_fn_593(__args, record, io_buffer, false)? } else { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_593] = unsafe { *(result.output.as_ptr() as *const [G; OUT_593]) }; __ret } } else { aiur_fn_593(__args, record, io_buffer, __cu)? } }; + let __r_arr: [G; OUT_589] = { let __args: [G; IN_589] = [__v_0, __v_8, __v_11]; let __cu = unconstrained; if let Some(result) = record.function_queries[589].get_mut(&__args[..]) { if !__cu && *result.multiplicity == G::ZERO { aiur_fn_589(__args, record, io_buffer, false)? } else { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_589] = unsafe { *(result.output.as_ptr() as *const [G; OUT_589]) }; __ret } } else { aiur_fn_589(__args, record, io_buffer, __cu)? } }; let __v_12: G = __r_arr[0]; let __v_13: G = G::from_u64(0); - let __r_arr: [G; OUT_610] = { let __args: [G; IN_610] = [__v_0, __v_1, __v_2, __v_3, __v_4, __v_5, __v_6, __v_12, __v_7, __v_13]; let __cu = unconstrained; if let Some(result) = record.function_queries[610].get_mut(&__args[..]) { if !__cu && *result.multiplicity == G::ZERO { aiur_fn_610(__args, record, io_buffer, false)? } else { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_610] = unsafe { *(result.output.as_ptr() as *const [G; OUT_610]) }; __ret } } else { aiur_fn_610(__args, record, io_buffer, __cu)? } }; - let __ret: [G; OUT_609] = []; - if let Some(result) = record.function_queries[609].get_mut(&inp[..]) { debug_assert_eq!(result.output, &__ret[..]); if !unconstrained { *result.multiplicity += G::ONE; } } else { record.function_queries[609].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained)); }; + let __r_arr: [G; OUT_606] = { let __args: [G; IN_606] = [__v_0, __v_1, __v_2, __v_3, __v_4, __v_5, __v_6, __v_12, __v_7, __v_13]; let __cu = unconstrained; if let Some(result) = record.function_queries[606].get_mut(&__args[..]) { if !__cu && *result.multiplicity == G::ZERO { aiur_fn_606(__args, record, io_buffer, false)? } else { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_606] = unsafe { *(result.output.as_ptr() as *const [G; OUT_606]) }; __ret } } else { aiur_fn_606(__args, record, io_buffer, __cu)? } }; + let __ret: [G; OUT_605] = []; + if let Some(result) = record.function_queries[605].get_mut(&inp[..]) { debug_assert_eq!(result.output, &__ret[..]); if !unconstrained { *result.multiplicity += G::ONE; } } else { record.function_queries[605].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained)); }; return Ok(__ret); }) } -const INPUT_SIZE_610: usize = 10; -const IN_610: usize = 10; -const OUT_610: usize = 0; -fn aiur_fn_610( - inp: [G; IN_610], +const INPUT_SIZE_606: usize = 10; +const IN_606: usize = 10; +const OUT_606: usize = 0; +fn aiur_fn_606( + inp: [G; IN_606], record: &mut QueryRecord, io_buffer: &mut IOBuffer, unconstrained: bool, -) -> Result<[G; OUT_610], ExecError> { +) -> Result<[G; OUT_606], ExecError> { stacker::maybe_grow(64 * 1024, 4 * 1024 * 1024, || { let __v_0: G = inp[0]; let __v_1: G = inp[1]; @@ -51614,12 +51330,12 @@ fn aiur_fn_610( let __v_10: G = (__v_3 - __v_9); match __v_10.as_canonical_u64() { 0u64 => { - let __ret: [G; OUT_610] = []; - if let Some(result) = record.function_queries[610].get_mut(&inp[..]) { debug_assert_eq!(result.output, &__ret[..]); if !unconstrained { *result.multiplicity += G::ONE; } } else { record.function_queries[610].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained)); }; + let __ret: [G; OUT_606] = []; + if let Some(result) = record.function_queries[606].get_mut(&inp[..]) { debug_assert_eq!(result.output, &__ret[..]); if !unconstrained { *result.multiplicity += G::ONE; } } else { record.function_queries[606].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained)); }; return Ok(__ret); }, _ => { - let __r_arr: [G; OUT_290] = { let __args: [G; IN_290] = [__v_5, __v_6, __v_9]; let __cu = unconstrained; if let Some(result) = record.function_queries[290].get_mut(&__args[..]) { if !__cu && *result.multiplicity == G::ZERO { aiur_fn_290(__args, record, io_buffer, false)? } else { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_290] = unsafe { *(result.output.as_ptr() as *const [G; OUT_290]) }; __ret } } else { aiur_fn_290(__args, record, io_buffer, __cu)? } }; + let __r_arr: [G; OUT_286] = { let __args: [G; IN_286] = [__v_5, __v_6, __v_9]; let __cu = unconstrained; if let Some(result) = record.function_queries[286].get_mut(&__args[..]) { if !__cu && *result.multiplicity == G::ZERO { aiur_fn_286(__args, record, io_buffer, false)? } else { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_286] = unsafe { *(result.output.as_ptr() as *const [G; OUT_286]) }; __ret } } else { aiur_fn_286(__args, record, io_buffer, __cu)? } }; let __v_11: G = __r_arr[0]; let __loaded: [G; 12] = { let __mq = record.memory_queries.get_mut(&12).ok_or(ExecError::InvalidMemorySize(12))?; let __ptr_u64 = __v_11.as_canonical_u64(); let __ptr_usize = usize::try_from(__ptr_u64).ok().ok_or(ExecError::PointerTooLarge(__ptr_u64))?; let (__args, __mult) = __mq.get_index_mut(__ptr_usize).ok_or(ExecError::UnboundPointer { ptr: __ptr_u64, size: 12 })?; if !unconstrained { *__mult += G::ONE; } let __arr: [G; 12] = __args[..12].try_into().unwrap(); __arr }; let __v_12: G = __loaded[0]; @@ -51636,15 +51352,15 @@ fn aiur_fn_610( let __v_23: G = __loaded[11]; match __v_12.as_canonical_u64() { 6u64 => { - let __r_arr: [G; OUT_592] = { let __args: [G; IN_592] = [__v_0, __v_14, __v_1]; let __cu = unconstrained; if let Some(result) = record.function_queries[592].get_mut(&__args[..]) { if !__cu && *result.multiplicity == G::ZERO { aiur_fn_592(__args, record, io_buffer, false)? } else { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_592] = unsafe { *(result.output.as_ptr() as *const [G; OUT_592]) }; __ret } } else { aiur_fn_592(__args, record, io_buffer, __cu)? } }; - let __r_arr: [G; OUT_590] = { let __args: [G; IN_590] = [__v_14, __v_18, __v_2, __v_19, __v_4, __v_5, __v_6]; let __cu = unconstrained; if let Some(result) = record.function_queries[590].get_mut(&__args[..]) { if !__cu && *result.multiplicity == G::ZERO { aiur_fn_590(__args, record, io_buffer, false)? } else { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_590] = unsafe { *(result.output.as_ptr() as *const [G; OUT_590]) }; __ret } } else { aiur_fn_590(__args, record, io_buffer, __cu)? } }; - let __r_arr: [G; OUT_596] = { let __args: [G; IN_596] = [__v_14, __v_18, __v_7]; let __cu = unconstrained; if let Some(result) = record.function_queries[596].get_mut(&__args[..]) { if !__cu && *result.multiplicity == G::ZERO { aiur_fn_596(__args, record, io_buffer, false)? } else { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_596] = unsafe { *(result.output.as_ptr() as *const [G; OUT_596]) }; __ret } } else { aiur_fn_596(__args, record, io_buffer, __cu)? } }; + let __r_arr: [G; OUT_588] = { let __args: [G; IN_588] = [__v_0, __v_14, __v_1]; let __cu = unconstrained; if let Some(result) = record.function_queries[588].get_mut(&__args[..]) { if !__cu && *result.multiplicity == G::ZERO { aiur_fn_588(__args, record, io_buffer, false)? } else { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_588] = unsafe { *(result.output.as_ptr() as *const [G; OUT_588]) }; __ret } } else { aiur_fn_588(__args, record, io_buffer, __cu)? } }; + let __r_arr: [G; OUT_586] = { let __args: [G; IN_586] = [__v_14, __v_18, __v_2, __v_19, __v_4, __v_5, __v_6]; let __cu = unconstrained; if let Some(result) = record.function_queries[586].get_mut(&__args[..]) { if !__cu && *result.multiplicity == G::ZERO { aiur_fn_586(__args, record, io_buffer, false)? } else { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_586] = unsafe { *(result.output.as_ptr() as *const [G; OUT_586]) }; __ret } } else { aiur_fn_586(__args, record, io_buffer, __cu)? } }; + let __r_arr: [G; OUT_592] = { let __args: [G; IN_592] = [__v_14, __v_18, __v_7]; let __cu = unconstrained; if let Some(result) = record.function_queries[592].get_mut(&__args[..]) { if !__cu && *result.multiplicity == G::ZERO { aiur_fn_592(__args, record, io_buffer, false)? } else { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_592] = unsafe { *(result.output.as_ptr() as *const [G; OUT_592]) }; __ret } } else { aiur_fn_592(__args, record, io_buffer, __cu)? } }; let __mc_out___mc_0: [G; 0] = '__mc_0: { match __v_8.as_canonical_u64() { 0u64 => { let __v_24: G = G::from_u64(1); let __v_25: G = G::from_u64(1); let __v_26: G = { let __values: [G; 3] = [__v_24, __v_25, __v_25]; let __mq = record.memory_queries.get_mut(&3).ok_or(ExecError::InvalidMemorySize(3))?; if let Some(result) = __mq.get_mut(&__values[..]) { if !unconstrained { *result.multiplicity += G::ONE; } result.output[0] } else { let __ptr = G::from_usize(__mq.len()); __mq.insert(&__values[..], &[__ptr], G::from_bool(!unconstrained)); __ptr } }; - let __r_arr: [G; OUT_608] = { let __args: [G; IN_608] = [__v_14, __v_18, __v_5, __v_26]; let __cu = unconstrained; if let Some(result) = record.function_queries[608].get_mut(&__args[..]) { if !__cu && *result.multiplicity == G::ZERO { aiur_fn_608(__args, record, io_buffer, false)? } else { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_608] = unsafe { *(result.output.as_ptr() as *const [G; OUT_608]) }; __ret } } else { aiur_fn_608(__args, record, io_buffer, __cu)? } }; + let __r_arr: [G; OUT_604] = { let __args: [G; IN_604] = [__v_14, __v_18, __v_5, __v_26]; let __cu = unconstrained; if let Some(result) = record.function_queries[604].get_mut(&__args[..]) { if !__cu && *result.multiplicity == G::ZERO { aiur_fn_604(__args, record, io_buffer, false)? } else { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_604] = unsafe { *(result.output.as_ptr() as *const [G; OUT_604]) }; __ret } } else { aiur_fn_604(__args, record, io_buffer, __cu)? } }; break '__mc_0 []; }, _ => { @@ -51669,9 +51385,9 @@ fn aiur_fn_610( } let __v_26: G = G::from_u64(1); let __v_27: G = (__v_9 + __v_26); - let __r_arr: [G; OUT_610] = { let __args: [G; IN_610] = [__v_0, __v_1, __v_2, __v_3, __v_4, __v_5, __v_6, __v_7, __v_8, __v_27]; let __cu = unconstrained; if let Some(result) = record.function_queries[610].get_mut(&__args[..]) { if !__cu && *result.multiplicity == G::ZERO { aiur_fn_610(__args, record, io_buffer, false)? } else { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_610] = unsafe { *(result.output.as_ptr() as *const [G; OUT_610]) }; __ret } } else { aiur_fn_610(__args, record, io_buffer, __cu)? } }; - let __ret: [G; OUT_610] = []; - if let Some(result) = record.function_queries[610].get_mut(&inp[..]) { debug_assert_eq!(result.output, &__ret[..]); if !unconstrained { *result.multiplicity += G::ONE; } } else { record.function_queries[610].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained)); }; + let __r_arr: [G; OUT_606] = { let __args: [G; IN_606] = [__v_0, __v_1, __v_2, __v_3, __v_4, __v_5, __v_6, __v_7, __v_8, __v_27]; let __cu = unconstrained; if let Some(result) = record.function_queries[606].get_mut(&__args[..]) { if !__cu && *result.multiplicity == G::ZERO { aiur_fn_606(__args, record, io_buffer, false)? } else { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_606] = unsafe { *(result.output.as_ptr() as *const [G; OUT_606]) }; __ret } } else { aiur_fn_606(__args, record, io_buffer, __cu)? } }; + let __ret: [G; OUT_606] = []; + if let Some(result) = record.function_queries[606].get_mut(&inp[..]) { debug_assert_eq!(result.output, &__ret[..]); if !unconstrained { *result.multiplicity += G::ONE; } } else { record.function_queries[606].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained)); }; return Ok(__ret); }, _ => { @@ -51683,15 +51399,15 @@ fn aiur_fn_610( }) } -const INPUT_SIZE_611: usize = 12; -const IN_611: usize = 12; -const OUT_611: usize = 0; -fn aiur_fn_611( - inp: [G; IN_611], +const INPUT_SIZE_607: usize = 12; +const IN_607: usize = 12; +const OUT_607: usize = 0; +fn aiur_fn_607( + inp: [G; IN_607], record: &mut QueryRecord, io_buffer: &mut IOBuffer, unconstrained: bool, -) -> Result<[G; OUT_611], ExecError> { +) -> Result<[G; OUT_607], ExecError> { stacker::maybe_grow(64 * 1024, 4 * 1024 * 1024, || { let __v_0: G = inp[0]; let __v_1: G = inp[1]; @@ -51707,29 +51423,29 @@ fn aiur_fn_611( let __v_11: G = inp[11]; match __v_0.as_canonical_u64() { 5u64 => { - let __r_arr: [G; OUT_609] = { let __args: [G; IN_609] = [__v_2, __v_3, __v_4, __v_5, __v_1, __v_7, __v_8, __v_6]; let __cu = unconstrained; if let Some(result) = record.function_queries[609].get_mut(&__args[..]) { if !__cu && *result.multiplicity == G::ZERO { aiur_fn_609(__args, record, io_buffer, false)? } else { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_609] = unsafe { *(result.output.as_ptr() as *const [G; OUT_609]) }; __ret } } else { aiur_fn_609(__args, record, io_buffer, __cu)? } }; - let __ret: [G; OUT_611] = []; - if let Some(result) = record.function_queries[611].get_mut(&inp[..]) { debug_assert_eq!(result.output, &__ret[..]); if !unconstrained { *result.multiplicity += G::ONE; } } else { record.function_queries[611].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained)); }; + let __r_arr: [G; OUT_605] = { let __args: [G; IN_605] = [__v_2, __v_3, __v_4, __v_5, __v_1, __v_7, __v_8, __v_6]; let __cu = unconstrained; if let Some(result) = record.function_queries[605].get_mut(&__args[..]) { if !__cu && *result.multiplicity == G::ZERO { aiur_fn_605(__args, record, io_buffer, false)? } else { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_605] = unsafe { *(result.output.as_ptr() as *const [G; OUT_605]) }; __ret } } else { aiur_fn_605(__args, record, io_buffer, __cu)? } }; + let __ret: [G; OUT_607] = []; + if let Some(result) = record.function_queries[607].get_mut(&inp[..]) { debug_assert_eq!(result.output, &__ret[..]); if !unconstrained { *result.multiplicity += G::ONE; } } else { record.function_queries[607].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained)); }; return Ok(__ret); }, _ => { - let __ret: [G; OUT_611] = []; - if let Some(result) = record.function_queries[611].get_mut(&inp[..]) { debug_assert_eq!(result.output, &__ret[..]); if !unconstrained { *result.multiplicity += G::ONE; } } else { record.function_queries[611].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained)); }; + let __ret: [G; OUT_607] = []; + if let Some(result) = record.function_queries[607].get_mut(&inp[..]) { debug_assert_eq!(result.output, &__ret[..]); if !unconstrained { *result.multiplicity += G::ONE; } } else { record.function_queries[607].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained)); }; return Ok(__ret); }, } }) } -const INPUT_SIZE_612: usize = 13; -const IN_612: usize = 13; -const OUT_612: usize = 0; -fn aiur_fn_612( - inp: [G; IN_612], +const INPUT_SIZE_608: usize = 13; +const IN_608: usize = 13; +const OUT_608: usize = 0; +fn aiur_fn_608( + inp: [G; IN_608], record: &mut QueryRecord, io_buffer: &mut IOBuffer, unconstrained: bool, -) -> Result<[G; OUT_612], ExecError> { +) -> Result<[G; OUT_608], ExecError> { stacker::maybe_grow(64 * 1024, 4 * 1024 * 1024, || { let __v_0: G = inp[0]; let __v_1: G = inp[1]; @@ -51750,12 +51466,12 @@ fn aiur_fn_612( let __v_13: G = __r_arr[0]; match __v_13.as_canonical_u64() { 1u64 => { - let __ret: [G; OUT_612] = []; - if let Some(result) = record.function_queries[612].get_mut(&inp[..]) { debug_assert_eq!(result.output, &__ret[..]); if !unconstrained { *result.multiplicity += G::ONE; } } else { record.function_queries[612].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained)); }; + let __ret: [G; OUT_608] = []; + if let Some(result) = record.function_queries[608].get_mut(&inp[..]) { debug_assert_eq!(result.output, &__ret[..]); if !unconstrained { *result.multiplicity += G::ONE; } } else { record.function_queries[608].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained)); }; return Ok(__ret); }, _ => { - let __r_arr: [G; OUT_282] = { let __args: [G; IN_282] = [__v_7]; let __cu = unconstrained; if let Some(result) = record.function_queries[282].get_mut(&__args[..]) { if !__cu && *result.multiplicity == G::ZERO { aiur_fn_282(__args, record, io_buffer, false)? } else { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_282] = unsafe { *(result.output.as_ptr() as *const [G; OUT_282]) }; __ret } } else { aiur_fn_282(__args, record, io_buffer, __cu)? } }; + let __r_arr: [G; OUT_278] = { let __args: [G; IN_278] = [__v_7]; let __cu = unconstrained; if let Some(result) = record.function_queries[278].get_mut(&__args[..]) { if !__cu && *result.multiplicity == G::ZERO { aiur_fn_278(__args, record, io_buffer, false)? } else { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_278] = unsafe { *(result.output.as_ptr() as *const [G; OUT_278]) }; __ret } } else { aiur_fn_278(__args, record, io_buffer, __cu)? } }; let __v_14: G = __r_arr[0]; let __v_15: G = __r_arr[1]; let __v_16: G = __r_arr[2]; @@ -51809,14 +51525,14 @@ fn aiur_fn_612( match __v_14.as_canonical_u64() { 8u64 => { let __v_62: G = G::from_u64(0); - let __r_arr: [G; OUT_613] = { let __args: [G; IN_613] = [__v_15, __v_2, __v_3, __v_4, __v_8, __v_62, __v_7]; let __cu = unconstrained; if let Some(result) = record.function_queries[613].get_mut(&__args[..]) { if !__cu && *result.multiplicity == G::ZERO { aiur_fn_613(__args, record, io_buffer, false)? } else { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_613] = unsafe { *(result.output.as_ptr() as *const [G; OUT_613]) }; __ret } } else { aiur_fn_613(__args, record, io_buffer, __cu)? } }; - let __ret: [G; OUT_612] = []; - if let Some(result) = record.function_queries[612].get_mut(&inp[..]) { debug_assert_eq!(result.output, &__ret[..]); if !unconstrained { *result.multiplicity += G::ONE; } } else { record.function_queries[612].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained)); }; + let __r_arr: [G; OUT_609] = { let __args: [G; IN_609] = [__v_15, __v_2, __v_3, __v_4, __v_8, __v_62, __v_7]; let __cu = unconstrained; if let Some(result) = record.function_queries[609].get_mut(&__args[..]) { if !__cu && *result.multiplicity == G::ZERO { aiur_fn_609(__args, record, io_buffer, false)? } else { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_609] = unsafe { *(result.output.as_ptr() as *const [G; OUT_609]) }; __ret } } else { aiur_fn_609(__args, record, io_buffer, __cu)? } }; + let __ret: [G; OUT_608] = []; + if let Some(result) = record.function_queries[608].get_mut(&inp[..]) { debug_assert_eq!(result.output, &__ret[..]); if !unconstrained { *result.multiplicity += G::ONE; } } else { record.function_queries[608].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained)); }; return Ok(__ret); }, _ => { - let __ret: [G; OUT_612] = []; - if let Some(result) = record.function_queries[612].get_mut(&inp[..]) { debug_assert_eq!(result.output, &__ret[..]); if !unconstrained { *result.multiplicity += G::ONE; } } else { record.function_queries[612].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained)); }; + let __ret: [G; OUT_608] = []; + if let Some(result) = record.function_queries[608].get_mut(&inp[..]) { debug_assert_eq!(result.output, &__ret[..]); if !unconstrained { *result.multiplicity += G::ONE; } } else { record.function_queries[608].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained)); }; return Ok(__ret); }, } @@ -51826,23 +51542,23 @@ fn aiur_fn_612( } }, _ => { - let __ret: [G; OUT_612] = []; - if let Some(result) = record.function_queries[612].get_mut(&inp[..]) { debug_assert_eq!(result.output, &__ret[..]); if !unconstrained { *result.multiplicity += G::ONE; } } else { record.function_queries[612].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained)); }; + let __ret: [G; OUT_608] = []; + if let Some(result) = record.function_queries[608].get_mut(&inp[..]) { debug_assert_eq!(result.output, &__ret[..]); if !unconstrained { *result.multiplicity += G::ONE; } } else { record.function_queries[608].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained)); }; return Ok(__ret); }, } }) } -const INPUT_SIZE_613: usize = 7; -const IN_613: usize = 7; -const OUT_613: usize = 0; -fn aiur_fn_613( - inp: [G; IN_613], +const INPUT_SIZE_609: usize = 7; +const IN_609: usize = 7; +const OUT_609: usize = 0; +fn aiur_fn_609( + inp: [G; IN_609], record: &mut QueryRecord, io_buffer: &mut IOBuffer, unconstrained: bool, -) -> Result<[G; OUT_613], ExecError> { +) -> Result<[G; OUT_609], ExecError> { stacker::maybe_grow(64 * 1024, 4 * 1024 * 1024, || { let __v_0: G = inp[0]; let __v_1: G = inp[1]; @@ -51901,8 +51617,8 @@ fn aiur_fn_613( let __v_53: G = __loaded[46]; match __v_7.as_canonical_u64() { 1u64 => { - let __ret: [G; OUT_613] = []; - if let Some(result) = record.function_queries[613].get_mut(&inp[..]) { debug_assert_eq!(result.output, &__ret[..]); if !unconstrained { *result.multiplicity += G::ONE; } } else { record.function_queries[613].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained)); }; + let __ret: [G; OUT_609] = []; + if let Some(result) = record.function_queries[609].get_mut(&inp[..]) { debug_assert_eq!(result.output, &__ret[..]); if !unconstrained { *result.multiplicity += G::ONE; } } else { record.function_queries[609].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained)); }; return Ok(__ret); }, 0u64 => { @@ -51914,13 +51630,13 @@ fn aiur_fn_613( 1u64 => { let __v_56: G = G::from_u64(1); let __v_57: G = (__v_5 + __v_56); - let __r_arr: [G; OUT_613] = { let __args: [G; IN_613] = [__v_53, __v_1, __v_2, __v_3, __v_4, __v_57, __v_6]; let __cu = unconstrained; if let Some(result) = record.function_queries[613].get_mut(&__args[..]) { if !__cu && *result.multiplicity == G::ZERO { aiur_fn_613(__args, record, io_buffer, false)? } else { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_613] = unsafe { *(result.output.as_ptr() as *const [G; OUT_613]) }; __ret } } else { aiur_fn_613(__args, record, io_buffer, __cu)? } }; - let __ret: [G; OUT_613] = []; - if let Some(result) = record.function_queries[613].get_mut(&inp[..]) { debug_assert_eq!(result.output, &__ret[..]); if !unconstrained { *result.multiplicity += G::ONE; } } else { record.function_queries[613].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained)); }; + let __r_arr: [G; OUT_609] = { let __args: [G; IN_609] = [__v_53, __v_1, __v_2, __v_3, __v_4, __v_57, __v_6]; let __cu = unconstrained; if let Some(result) = record.function_queries[609].get_mut(&__args[..]) { if !__cu && *result.multiplicity == G::ZERO { aiur_fn_609(__args, record, io_buffer, false)? } else { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_609] = unsafe { *(result.output.as_ptr() as *const [G; OUT_609]) }; __ret } } else { aiur_fn_609(__args, record, io_buffer, __cu)? } }; + let __ret: [G; OUT_609] = []; + if let Some(result) = record.function_queries[609].get_mut(&inp[..]) { debug_assert_eq!(result.output, &__ret[..]); if !unconstrained { *result.multiplicity += G::ONE; } } else { record.function_queries[609].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained)); }; return Ok(__ret); }, _ => { - let __r_arr: [G; OUT_289] = { let __args: [G; IN_289] = [__v_6, __v_5]; let __cu = unconstrained; if let Some(result) = record.function_queries[289].get_mut(&__args[..]) { if !__cu && *result.multiplicity == G::ZERO { aiur_fn_289(__args, record, io_buffer, false)? } else { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_289] = unsafe { *(result.output.as_ptr() as *const [G; OUT_289]) }; __ret } } else { aiur_fn_289(__args, record, io_buffer, __cu)? } }; + let __r_arr: [G; OUT_285] = { let __args: [G; IN_285] = [__v_6, __v_5]; let __cu = unconstrained; if let Some(result) = record.function_queries[285].get_mut(&__args[..]) { if !__cu && *result.multiplicity == G::ZERO { aiur_fn_285(__args, record, io_buffer, false)? } else { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_285] = unsafe { *(result.output.as_ptr() as *const [G; OUT_285]) }; __ret } } else { aiur_fn_285(__args, record, io_buffer, __cu)? } }; let __v_56: G = __r_arr[0]; let __loaded: [G; 12] = { let __mq = record.memory_queries.get_mut(&12).ok_or(ExecError::InvalidMemorySize(12))?; let __ptr_u64 = __v_56.as_canonical_u64(); let __ptr_usize = usize::try_from(__ptr_u64).ok().ok_or(ExecError::PointerTooLarge(__ptr_u64))?; let (__args, __mult) = __mq.get_index_mut(__ptr_usize).ok_or(ExecError::UnboundPointer { ptr: __ptr_u64, size: 12 })?; if !unconstrained { *__mult += G::ONE; } let __arr: [G; 12] = __args[..12].try_into().unwrap(); __arr }; let __v_57: G = __loaded[0]; @@ -51937,23 +51653,23 @@ fn aiur_fn_613( let __v_68: G = __loaded[11]; match __v_57.as_canonical_u64() { 5u64 => { - let __r_arr: [G; OUT_592] = { let __args: [G; IN_592] = [__v_1, __v_59, __v_2]; let __cu = unconstrained; if let Some(result) = record.function_queries[592].get_mut(&__args[..]) { if !__cu && *result.multiplicity == G::ZERO { aiur_fn_592(__args, record, io_buffer, false)? } else { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_592] = unsafe { *(result.output.as_ptr() as *const [G; OUT_592]) }; __ret } } else { aiur_fn_592(__args, record, io_buffer, __cu)? } }; + let __r_arr: [G; OUT_588] = { let __args: [G; IN_588] = [__v_1, __v_59, __v_2]; let __cu = unconstrained; if let Some(result) = record.function_queries[588].get_mut(&__args[..]) { if !__cu && *result.multiplicity == G::ZERO { aiur_fn_588(__args, record, io_buffer, false)? } else { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_588] = unsafe { *(result.output.as_ptr() as *const [G; OUT_588]) }; __ret } } else { aiur_fn_588(__args, record, io_buffer, __cu)? } }; let __v_69: G = (__v_2 + __v_3); let __v_70: G = G::from_u64(1); let __v_71: G = G::from_u64(1); let __v_72: G = { let __values: [G; 3] = [__v_70, __v_71, __v_71]; let __mq = record.memory_queries.get_mut(&3).ok_or(ExecError::InvalidMemorySize(3))?; if let Some(result) = __mq.get_mut(&__values[..]) { if !unconstrained { *result.multiplicity += G::ONE; } result.output[0] } else { let __ptr = G::from_usize(__mq.len()); __mq.insert(&__values[..], &[__ptr], G::from_bool(!unconstrained)); __ptr } }; - let __r_arr: [G; OUT_593] = { let __args: [G; IN_593] = [__v_1, __v_69, __v_72]; let __cu = unconstrained; if let Some(result) = record.function_queries[593].get_mut(&__args[..]) { if !__cu && *result.multiplicity == G::ZERO { aiur_fn_593(__args, record, io_buffer, false)? } else { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_593] = unsafe { *(result.output.as_ptr() as *const [G; OUT_593]) }; __ret } } else { aiur_fn_593(__args, record, io_buffer, __cu)? } }; + let __r_arr: [G; OUT_589] = { let __args: [G; IN_589] = [__v_1, __v_69, __v_72]; let __cu = unconstrained; if let Some(result) = record.function_queries[589].get_mut(&__args[..]) { if !__cu && *result.multiplicity == G::ZERO { aiur_fn_589(__args, record, io_buffer, false)? } else { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_589] = unsafe { *(result.output.as_ptr() as *const [G; OUT_589]) }; __ret } } else { aiur_fn_589(__args, record, io_buffer, __cu)? } }; let __v_73: G = __r_arr[0]; let __v_74: G = (__v_60 + __v_61); let __v_75: G = G::from_u64(1); let __v_76: G = G::from_u64(1); let __v_77: G = { let __values: [G; 3] = [__v_75, __v_76, __v_76]; let __mq = record.memory_queries.get_mut(&3).ok_or(ExecError::InvalidMemorySize(3))?; if let Some(result) = __mq.get_mut(&__values[..]) { if !unconstrained { *result.multiplicity += G::ONE; } result.output[0] } else { let __ptr = G::from_usize(__mq.len()); __mq.insert(&__values[..], &[__ptr], G::from_bool(!unconstrained)); __ptr } }; - let __r_arr: [G; OUT_593] = { let __args: [G; IN_593] = [__v_59, __v_74, __v_77]; let __cu = unconstrained; if let Some(result) = record.function_queries[593].get_mut(&__args[..]) { if !__cu && *result.multiplicity == G::ZERO { aiur_fn_593(__args, record, io_buffer, false)? } else { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_593] = unsafe { *(result.output.as_ptr() as *const [G; OUT_593]) }; __ret } } else { aiur_fn_593(__args, record, io_buffer, __cu)? } }; + let __r_arr: [G; OUT_589] = { let __args: [G; IN_589] = [__v_59, __v_74, __v_77]; let __cu = unconstrained; if let Some(result) = record.function_queries[589].get_mut(&__args[..]) { if !__cu && *result.multiplicity == G::ZERO { aiur_fn_589(__args, record, io_buffer, false)? } else { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_589] = unsafe { *(result.output.as_ptr() as *const [G; OUT_589]) }; __ret } } else { aiur_fn_589(__args, record, io_buffer, __cu)? } }; let __v_78: G = __r_arr[0]; if (__v_60 != __v_2) { return Err(ExecError::AssertEqMismatch { lhs: __v_60.as_canonical_u64(), rhs: __v_2.as_canonical_u64(), msg: Some("mutual block peers disagree on parameter count".to_string()) }); } - let __r_arr: [G; OUT_324] = { let __args: [G; IN_324] = [__v_73, __v_78]; let __cu = unconstrained; if let Some(result) = record.function_queries[324].get_mut(&__args[..]) { if !__cu && *result.multiplicity == G::ZERO { aiur_fn_324(__args, record, io_buffer, false)? } else { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_324] = unsafe { *(result.output.as_ptr() as *const [G; OUT_324]) }; __ret } } else { aiur_fn_324(__args, record, io_buffer, __cu)? } }; + let __r_arr: [G; OUT_320] = { let __args: [G; IN_320] = [__v_73, __v_78]; let __cu = unconstrained; if let Some(result) = record.function_queries[320].get_mut(&__args[..]) { if !__cu && *result.multiplicity == G::ZERO { aiur_fn_320(__args, record, io_buffer, false)? } else { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_320] = unsafe { *(result.output.as_ptr() as *const [G; OUT_320]) }; __ret } } else { aiur_fn_320(__args, record, io_buffer, __cu)? } }; let __v_79: G = __r_arr[0]; let __v_80: G = G::from_u64(1); if (__v_79 != __v_80) { @@ -51961,17 +51677,17 @@ fn aiur_fn_613( } let __v_81: G = G::from_u64(1); let __v_82: G = (__v_5 + __v_81); - let __r_arr: [G; OUT_613] = { let __args: [G; IN_613] = [__v_53, __v_1, __v_2, __v_3, __v_4, __v_82, __v_6]; let __cu = unconstrained; if let Some(result) = record.function_queries[613].get_mut(&__args[..]) { if !__cu && *result.multiplicity == G::ZERO { aiur_fn_613(__args, record, io_buffer, false)? } else { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_613] = unsafe { *(result.output.as_ptr() as *const [G; OUT_613]) }; __ret } } else { aiur_fn_613(__args, record, io_buffer, __cu)? } }; - let __ret: [G; OUT_613] = []; - if let Some(result) = record.function_queries[613].get_mut(&inp[..]) { debug_assert_eq!(result.output, &__ret[..]); if !unconstrained { *result.multiplicity += G::ONE; } } else { record.function_queries[613].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained)); }; + let __r_arr: [G; OUT_609] = { let __args: [G; IN_609] = [__v_53, __v_1, __v_2, __v_3, __v_4, __v_82, __v_6]; let __cu = unconstrained; if let Some(result) = record.function_queries[609].get_mut(&__args[..]) { if !__cu && *result.multiplicity == G::ZERO { aiur_fn_609(__args, record, io_buffer, false)? } else { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_609] = unsafe { *(result.output.as_ptr() as *const [G; OUT_609]) }; __ret } } else { aiur_fn_609(__args, record, io_buffer, __cu)? } }; + let __ret: [G; OUT_609] = []; + if let Some(result) = record.function_queries[609].get_mut(&inp[..]) { debug_assert_eq!(result.output, &__ret[..]); if !unconstrained { *result.multiplicity += G::ONE; } } else { record.function_queries[609].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained)); }; return Ok(__ret); }, _ => { let __v_69: G = G::from_u64(1); let __v_70: G = (__v_5 + __v_69); - let __r_arr: [G; OUT_613] = { let __args: [G; IN_613] = [__v_53, __v_1, __v_2, __v_3, __v_4, __v_70, __v_6]; let __cu = unconstrained; if let Some(result) = record.function_queries[613].get_mut(&__args[..]) { if !__cu && *result.multiplicity == G::ZERO { aiur_fn_613(__args, record, io_buffer, false)? } else { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_613] = unsafe { *(result.output.as_ptr() as *const [G; OUT_613]) }; __ret } } else { aiur_fn_613(__args, record, io_buffer, __cu)? } }; - let __ret: [G; OUT_613] = []; - if let Some(result) = record.function_queries[613].get_mut(&inp[..]) { debug_assert_eq!(result.output, &__ret[..]); if !unconstrained { *result.multiplicity += G::ONE; } } else { record.function_queries[613].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained)); }; + let __r_arr: [G; OUT_609] = { let __args: [G; IN_609] = [__v_53, __v_1, __v_2, __v_3, __v_4, __v_70, __v_6]; let __cu = unconstrained; if let Some(result) = record.function_queries[609].get_mut(&__args[..]) { if !__cu && *result.multiplicity == G::ZERO { aiur_fn_609(__args, record, io_buffer, false)? } else { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_609] = unsafe { *(result.output.as_ptr() as *const [G; OUT_609]) }; __ret } } else { aiur_fn_609(__args, record, io_buffer, __cu)? } }; + let __ret: [G; OUT_609] = []; + if let Some(result) = record.function_queries[609].get_mut(&inp[..]) { debug_assert_eq!(result.output, &__ret[..]); if !unconstrained { *result.multiplicity += G::ONE; } } else { record.function_queries[609].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained)); }; return Ok(__ret); }, } @@ -51981,9 +51697,9 @@ fn aiur_fn_613( _ => { let __v_54: G = G::from_u64(1); let __v_55: G = (__v_5 + __v_54); - let __r_arr: [G; OUT_613] = { let __args: [G; IN_613] = [__v_53, __v_1, __v_2, __v_3, __v_4, __v_55, __v_6]; let __cu = unconstrained; if let Some(result) = record.function_queries[613].get_mut(&__args[..]) { if !__cu && *result.multiplicity == G::ZERO { aiur_fn_613(__args, record, io_buffer, false)? } else { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_613] = unsafe { *(result.output.as_ptr() as *const [G; OUT_613]) }; __ret } } else { aiur_fn_613(__args, record, io_buffer, __cu)? } }; - let __ret: [G; OUT_613] = []; - if let Some(result) = record.function_queries[613].get_mut(&inp[..]) { debug_assert_eq!(result.output, &__ret[..]); if !unconstrained { *result.multiplicity += G::ONE; } } else { record.function_queries[613].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained)); }; + let __r_arr: [G; OUT_609] = { let __args: [G; IN_609] = [__v_53, __v_1, __v_2, __v_3, __v_4, __v_55, __v_6]; let __cu = unconstrained; if let Some(result) = record.function_queries[609].get_mut(&__args[..]) { if !__cu && *result.multiplicity == G::ZERO { aiur_fn_609(__args, record, io_buffer, false)? } else { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_609] = unsafe { *(result.output.as_ptr() as *const [G; OUT_609]) }; __ret } } else { aiur_fn_609(__args, record, io_buffer, __cu)? } }; + let __ret: [G; OUT_609] = []; + if let Some(result) = record.function_queries[609].get_mut(&inp[..]) { debug_assert_eq!(result.output, &__ret[..]); if !unconstrained { *result.multiplicity += G::ONE; } } else { record.function_queries[609].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained)); }; return Ok(__ret); }, } @@ -51995,15 +51711,15 @@ fn aiur_fn_613( }) } -const INPUT_SIZE_614: usize = 16; -const IN_614: usize = 16; -const OUT_614: usize = 1; -fn aiur_fn_614( - inp: [G; IN_614], +const INPUT_SIZE_610: usize = 16; +const IN_610: usize = 16; +const OUT_610: usize = 1; +fn aiur_fn_610( + inp: [G; IN_610], record: &mut QueryRecord, io_buffer: &mut IOBuffer, unconstrained: bool, -) -> Result<[G; OUT_614], ExecError> { +) -> Result<[G; OUT_610], ExecError> { stacker::maybe_grow(64 * 1024, 4 * 1024 * 1024, || { let __v_0: G = inp[0]; let __v_1: G = inp[1]; @@ -52021,37 +51737,37 @@ fn aiur_fn_614( let __v_13: G = inp[13]; let __v_14: G = inp[14]; let __v_15: G = inp[15]; - let __r_arr: [G; OUT_297] = { let __args: [G; IN_297] = [__v_0]; let __cu = unconstrained; if let Some(result) = record.function_queries[297].get_mut(&__args[..]) { if !__cu && *result.multiplicity == G::ZERO { aiur_fn_297(__args, record, io_buffer, false)? } else { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_297] = unsafe { *(result.output.as_ptr() as *const [G; OUT_297]) }; __ret } } else { aiur_fn_297(__args, record, io_buffer, __cu)? } }; + let __r_arr: [G; OUT_293] = { let __args: [G; IN_293] = [__v_0]; let __cu = unconstrained; if let Some(result) = record.function_queries[293].get_mut(&__args[..]) { if !__cu && *result.multiplicity == G::ZERO { aiur_fn_293(__args, record, io_buffer, false)? } else { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_293] = unsafe { *(result.output.as_ptr() as *const [G; OUT_293]) }; __ret } } else { aiur_fn_293(__args, record, io_buffer, __cu)? } }; let __v_16: G = __r_arr[0]; match __v_16.as_canonical_u64() { 1u64 => { let __v_17: G = G::from_u64(1); - let __ret: [G; OUT_614] = [__v_17]; - if let Some(result) = record.function_queries[614].get_mut(&inp[..]) { debug_assert_eq!(result.output, &__ret[..]); if !unconstrained { *result.multiplicity += G::ONE; } } else { record.function_queries[614].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained)); }; + let __ret: [G; OUT_610] = [__v_17]; + if let Some(result) = record.function_queries[610].get_mut(&inp[..]) { debug_assert_eq!(result.output, &__ret[..]); if !unconstrained { *result.multiplicity += G::ONE; } } else { record.function_queries[610].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained)); }; return Ok(__ret); }, _ => { match __v_15.as_canonical_u64() { 0u64 => { let __v_17: G = G::from_u64(0); - let __ret: [G; OUT_614] = [__v_17]; - if let Some(result) = record.function_queries[614].get_mut(&inp[..]) { debug_assert_eq!(result.output, &__ret[..]); if !unconstrained { *result.multiplicity += G::ONE; } } else { record.function_queries[614].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained)); }; + let __ret: [G; OUT_610] = [__v_17]; + if let Some(result) = record.function_queries[610].get_mut(&inp[..]) { debug_assert_eq!(result.output, &__ret[..]); if !unconstrained { *result.multiplicity += G::ONE; } } else { record.function_queries[610].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained)); }; return Ok(__ret); }, _ => { match __v_1.as_canonical_u64() { 0u64 => { let __v_17: G = G::from_u64(1); - let __ret: [G; OUT_614] = [__v_17]; - if let Some(result) = record.function_queries[614].get_mut(&inp[..]) { debug_assert_eq!(result.output, &__ret[..]); if !unconstrained { *result.multiplicity += G::ONE; } } else { record.function_queries[614].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained)); }; + let __ret: [G; OUT_610] = [__v_17]; + if let Some(result) = record.function_queries[610].get_mut(&inp[..]) { debug_assert_eq!(result.output, &__ret[..]); if !unconstrained { *result.multiplicity += G::ONE; } } else { record.function_queries[610].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained)); }; return Ok(__ret); }, 1u64 => { match __v_2.as_canonical_u64() { 0u64 => { let __v_17: G = G::from_u64(0); - let __ret: [G; OUT_614] = [__v_17]; - if let Some(result) = record.function_queries[614].get_mut(&inp[..]) { debug_assert_eq!(result.output, &__ret[..]); if !unconstrained { *result.multiplicity += G::ONE; } } else { record.function_queries[614].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained)); }; + let __ret: [G; OUT_610] = [__v_17]; + if let Some(result) = record.function_queries[610].get_mut(&inp[..]) { debug_assert_eq!(result.output, &__ret[..]); if !unconstrained { *result.multiplicity += G::ONE; } } else { record.function_queries[610].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained)); }; return Ok(__ret); }, _ => { @@ -52060,26 +51776,26 @@ fn aiur_fn_614( match __v_10.as_canonical_u64() { 0u64 => { let __v_17: G = G::from_u64(1); - let __ret: [G; OUT_614] = [__v_17]; - if let Some(result) = record.function_queries[614].get_mut(&inp[..]) { debug_assert_eq!(result.output, &__ret[..]); if !unconstrained { *result.multiplicity += G::ONE; } } else { record.function_queries[614].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained)); }; + let __ret: [G; OUT_610] = [__v_17]; + if let Some(result) = record.function_queries[610].get_mut(&inp[..]) { debug_assert_eq!(result.output, &__ret[..]); if !unconstrained { *result.multiplicity += G::ONE; } } else { record.function_queries[610].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained)); }; return Ok(__ret); }, _ => { let __v_17: G = G::from_u64(1); let __v_18: G = G::from_u64(1); let __v_19: G = { let __values: [G; 3] = [__v_17, __v_18, __v_18]; let __mq = record.memory_queries.get_mut(&3).ok_or(ExecError::InvalidMemorySize(3))?; if let Some(result) = __mq.get_mut(&__values[..]) { if !unconstrained { *result.multiplicity += G::ONE; } result.output[0] } else { let __ptr = G::from_usize(__mq.len()); __mq.insert(&__values[..], &[__ptr], G::from_bool(!unconstrained)); __ptr } }; - let __r_arr: [G; OUT_615] = { let __args: [G; IN_615] = [__v_5, __v_9, __v_10, __v_19]; let __cu = unconstrained; if let Some(result) = record.function_queries[615].get_mut(&__args[..]) { if !__cu && *result.multiplicity == G::ZERO { aiur_fn_615(__args, record, io_buffer, false)? } else { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_615] = unsafe { *(result.output.as_ptr() as *const [G; OUT_615]) }; __ret } } else { aiur_fn_615(__args, record, io_buffer, __cu)? } }; + let __r_arr: [G; OUT_611] = { let __args: [G; IN_611] = [__v_5, __v_9, __v_10, __v_19]; let __cu = unconstrained; if let Some(result) = record.function_queries[611].get_mut(&__args[..]) { if !__cu && *result.multiplicity == G::ZERO { aiur_fn_611(__args, record, io_buffer, false)? } else { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_611] = unsafe { *(result.output.as_ptr() as *const [G; OUT_611]) }; __ret } } else { aiur_fn_611(__args, record, io_buffer, __cu)? } }; let __v_20: G = __r_arr[0]; - let __ret: [G; OUT_614] = [__v_20]; - if let Some(result) = record.function_queries[614].get_mut(&inp[..]) { debug_assert_eq!(result.output, &__ret[..]); if !unconstrained { *result.multiplicity += G::ONE; } } else { record.function_queries[614].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained)); }; + let __ret: [G; OUT_610] = [__v_20]; + if let Some(result) = record.function_queries[610].get_mut(&inp[..]) { debug_assert_eq!(result.output, &__ret[..]); if !unconstrained { *result.multiplicity += G::ONE; } } else { record.function_queries[610].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained)); }; return Ok(__ret); }, } }, _ => { let __v_17: G = G::from_u64(0); - let __ret: [G; OUT_614] = [__v_17]; - if let Some(result) = record.function_queries[614].get_mut(&inp[..]) { debug_assert_eq!(result.output, &__ret[..]); if !unconstrained { *result.multiplicity += G::ONE; } } else { record.function_queries[614].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained)); }; + let __ret: [G; OUT_610] = [__v_17]; + if let Some(result) = record.function_queries[610].get_mut(&inp[..]) { debug_assert_eq!(result.output, &__ret[..]); if !unconstrained { *result.multiplicity += G::ONE; } } else { record.function_queries[610].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained)); }; return Ok(__ret); }, } @@ -52088,8 +51804,8 @@ fn aiur_fn_614( }, _ => { let __v_17: G = G::from_u64(0); - let __ret: [G; OUT_614] = [__v_17]; - if let Some(result) = record.function_queries[614].get_mut(&inp[..]) { debug_assert_eq!(result.output, &__ret[..]); if !unconstrained { *result.multiplicity += G::ONE; } } else { record.function_queries[614].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained)); }; + let __ret: [G; OUT_610] = [__v_17]; + if let Some(result) = record.function_queries[610].get_mut(&inp[..]) { debug_assert_eq!(result.output, &__ret[..]); if !unconstrained { *result.multiplicity += G::ONE; } } else { record.function_queries[610].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained)); }; return Ok(__ret); }, } @@ -52100,15 +51816,15 @@ fn aiur_fn_614( }) } -const INPUT_SIZE_615: usize = 4; -const IN_615: usize = 4; -const OUT_615: usize = 1; -fn aiur_fn_615( - inp: [G; IN_615], +const INPUT_SIZE_611: usize = 4; +const IN_611: usize = 4; +const OUT_611: usize = 1; +fn aiur_fn_611( + inp: [G; IN_611], record: &mut QueryRecord, io_buffer: &mut IOBuffer, unconstrained: bool, -) -> Result<[G; OUT_615], ExecError> { +) -> Result<[G; OUT_611], ExecError> { stacker::maybe_grow(64 * 1024, 4 * 1024 * 1024, || { let __v_0: G = inp[0]; let __v_1: G = inp[1]; @@ -52120,10 +51836,10 @@ fn aiur_fn_615( let __v_5: G = G::from_u64(1); let __v_6: G = G::from_u64(1); let __v_7: G = { let __values: [G; 3] = [__v_5, __v_6, __v_6]; let __mq = record.memory_queries.get_mut(&3).ok_or(ExecError::InvalidMemorySize(3))?; if let Some(result) = __mq.get_mut(&__values[..]) { if !unconstrained { *result.multiplicity += G::ONE; } result.output[0] } else { let __ptr = G::from_usize(__mq.len()); __mq.insert(&__values[..], &[__ptr], G::from_bool(!unconstrained)); __ptr } }; - let __r_arr: [G; OUT_616] = { let __args: [G; IN_616] = [__v_0, __v_2, __v_4, __v_3, __v_7]; let __cu = unconstrained; if let Some(result) = record.function_queries[616].get_mut(&__args[..]) { if !__cu && *result.multiplicity == G::ZERO { aiur_fn_616(__args, record, io_buffer, false)? } else { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_616] = unsafe { *(result.output.as_ptr() as *const [G; OUT_616]) }; __ret } } else { aiur_fn_616(__args, record, io_buffer, __cu)? } }; + let __r_arr: [G; OUT_612] = { let __args: [G; IN_612] = [__v_0, __v_2, __v_4, __v_3, __v_7]; let __cu = unconstrained; if let Some(result) = record.function_queries[612].get_mut(&__args[..]) { if !__cu && *result.multiplicity == G::ZERO { aiur_fn_612(__args, record, io_buffer, false)? } else { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_612] = unsafe { *(result.output.as_ptr() as *const [G; OUT_612]) }; __ret } } else { aiur_fn_612(__args, record, io_buffer, __cu)? } }; let __v_8: G = __r_arr[0]; - let __ret: [G; OUT_615] = [__v_8]; - if let Some(result) = record.function_queries[615].get_mut(&inp[..]) { debug_assert_eq!(result.output, &__ret[..]); if !unconstrained { *result.multiplicity += G::ONE; } } else { record.function_queries[615].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained)); }; + let __ret: [G; OUT_611] = [__v_8]; + if let Some(result) = record.function_queries[611].get_mut(&inp[..]) { debug_assert_eq!(result.output, &__ret[..]); if !unconstrained { *result.multiplicity += G::ONE; } } else { record.function_queries[611].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained)); }; return Ok(__ret); }, _ => { @@ -52138,16 +51854,16 @@ fn aiur_fn_615( let __v_9: G = { let __values: [G; 3] = [__v_8, __v_5, __v_3]; let __mq = record.memory_queries.get_mut(&3).ok_or(ExecError::InvalidMemorySize(3))?; if let Some(result) = __mq.get_mut(&__values[..]) { if !unconstrained { *result.multiplicity += G::ONE; } result.output[0] } else { let __ptr = G::from_usize(__mq.len()); __mq.insert(&__values[..], &[__ptr], G::from_bool(!unconstrained)); __ptr } }; let __v_10: G = G::from_u64(1); let __v_11: G = (__v_1 - __v_10); - let __r_arr: [G; OUT_615] = { let __args: [G; IN_615] = [__v_6, __v_11, __v_2, __v_9]; let __cu = unconstrained; if let Some(result) = record.function_queries[615].get_mut(&__args[..]) { if !__cu && *result.multiplicity == G::ZERO { aiur_fn_615(__args, record, io_buffer, false)? } else { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_615] = unsafe { *(result.output.as_ptr() as *const [G; OUT_615]) }; __ret } } else { aiur_fn_615(__args, record, io_buffer, __cu)? } }; + let __r_arr: [G; OUT_611] = { let __args: [G; IN_611] = [__v_6, __v_11, __v_2, __v_9]; let __cu = unconstrained; if let Some(result) = record.function_queries[611].get_mut(&__args[..]) { if !__cu && *result.multiplicity == G::ZERO { aiur_fn_611(__args, record, io_buffer, false)? } else { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_611] = unsafe { *(result.output.as_ptr() as *const [G; OUT_611]) }; __ret } } else { aiur_fn_611(__args, record, io_buffer, __cu)? } }; let __v_12: G = __r_arr[0]; - let __ret: [G; OUT_615] = [__v_12]; - if let Some(result) = record.function_queries[615].get_mut(&inp[..]) { debug_assert_eq!(result.output, &__ret[..]); if !unconstrained { *result.multiplicity += G::ONE; } } else { record.function_queries[615].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained)); }; + let __ret: [G; OUT_611] = [__v_12]; + if let Some(result) = record.function_queries[611].get_mut(&inp[..]) { debug_assert_eq!(result.output, &__ret[..]); if !unconstrained { *result.multiplicity += G::ONE; } } else { record.function_queries[611].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained)); }; return Ok(__ret); }, _ => { let __v_8: G = G::from_u64(0); - let __ret: [G; OUT_615] = [__v_8]; - if let Some(result) = record.function_queries[615].get_mut(&inp[..]) { debug_assert_eq!(result.output, &__ret[..]); if !unconstrained { *result.multiplicity += G::ONE; } } else { record.function_queries[615].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained)); }; + let __ret: [G; OUT_611] = [__v_8]; + if let Some(result) = record.function_queries[611].get_mut(&inp[..]) { debug_assert_eq!(result.output, &__ret[..]); if !unconstrained { *result.multiplicity += G::ONE; } } else { record.function_queries[611].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained)); }; return Ok(__ret); }, } @@ -52156,15 +51872,15 @@ fn aiur_fn_615( }) } -const INPUT_SIZE_616: usize = 5; -const IN_616: usize = 5; -const OUT_616: usize = 1; -fn aiur_fn_616( - inp: [G; IN_616], +const INPUT_SIZE_612: usize = 5; +const IN_612: usize = 5; +const OUT_612: usize = 1; +fn aiur_fn_612( + inp: [G; IN_612], record: &mut QueryRecord, io_buffer: &mut IOBuffer, unconstrained: bool, -) -> Result<[G; OUT_616], ExecError> { +) -> Result<[G; OUT_612], ExecError> { stacker::maybe_grow(64 * 1024, 4 * 1024 * 1024, || { let __v_0: G = inp[0]; let __v_1: G = inp[1]; @@ -52177,10 +51893,10 @@ fn aiur_fn_616( let __r_arr: [G; OUT_111] = { let __args: [G; IN_111] = [__v_0]; let __cu = unconstrained; if let Some(result) = record.function_queries[111].get_mut(&__args[..]) { if !__cu && *result.multiplicity == G::ZERO { aiur_fn_111(__args, record, io_buffer, false)? } else { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_111] = unsafe { *(result.output.as_ptr() as *const [G; OUT_111]) }; __ret } } else { aiur_fn_111(__args, record, io_buffer, __cu)? } }; let __v_6: G = __r_arr[0]; let __v_7: G = __r_arr[1]; - let __r_arr: [G; OUT_617] = { let __args: [G; IN_617] = [__v_4, __v_7]; let __cu = unconstrained; if let Some(result) = record.function_queries[617].get_mut(&__args[..]) { if !__cu && *result.multiplicity == G::ZERO { aiur_fn_617(__args, record, io_buffer, false)? } else { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_617] = unsafe { *(result.output.as_ptr() as *const [G; OUT_617]) }; __ret } } else { aiur_fn_617(__args, record, io_buffer, __cu)? } }; + let __r_arr: [G; OUT_613] = { let __args: [G; IN_613] = [__v_4, __v_7]; let __cu = unconstrained; if let Some(result) = record.function_queries[613].get_mut(&__args[..]) { if !__cu && *result.multiplicity == G::ZERO { aiur_fn_613(__args, record, io_buffer, false)? } else { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_613] = unsafe { *(result.output.as_ptr() as *const [G; OUT_613]) }; __ret } } else { aiur_fn_613(__args, record, io_buffer, __cu)? } }; let __v_8: G = __r_arr[0]; - let __ret: [G; OUT_616] = [__v_8]; - if let Some(result) = record.function_queries[616].get_mut(&inp[..]) { debug_assert_eq!(result.output, &__ret[..]); if !unconstrained { *result.multiplicity += G::ONE; } } else { record.function_queries[616].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained)); }; + let __ret: [G; OUT_612] = [__v_8]; + if let Some(result) = record.function_queries[612].get_mut(&inp[..]) { debug_assert_eq!(result.output, &__ret[..]); if !unconstrained { *result.multiplicity += G::ONE; } } else { record.function_queries[612].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained)); }; return Ok(__ret); }, _ => { @@ -52191,13 +51907,13 @@ fn aiur_fn_616( let __v_9: G = __loaded[3]; match __v_6.as_canonical_u64() { 5u64 => { - let __r_arr: [G; OUT_499] = { let __args: [G; IN_499] = [__v_7, __v_3]; let __cu = unconstrained; if let Some(result) = record.function_queries[499].get_mut(&__args[..]) { if !__cu && *result.multiplicity == G::ZERO { aiur_fn_499(__args, record, io_buffer, false)? } else { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_499] = unsafe { *(result.output.as_ptr() as *const [G; OUT_499]) }; __ret } } else { aiur_fn_499(__args, record, io_buffer, __cu)? } }; + let __r_arr: [G; OUT_495] = { let __args: [G; IN_495] = [__v_7, __v_3]; let __cu = unconstrained; if let Some(result) = record.function_queries[495].get_mut(&__args[..]) { if !__cu && *result.multiplicity == G::ZERO { aiur_fn_495(__args, record, io_buffer, false)? } else { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_495] = unsafe { *(result.output.as_ptr() as *const [G; OUT_495]) }; __ret } } else { aiur_fn_495(__args, record, io_buffer, __cu)? } }; let __v_10: G = __r_arr[0]; let __v_11: G = G::from_u64(1); let __v_12: G = G::from_u64(0); let __v_13: G = G::from_u64(0); let __v_14: G = { let __values: [G; 3] = [__v_12, __v_13, __v_13]; let __mq = record.memory_queries.get_mut(&3).ok_or(ExecError::InvalidMemorySize(3))?; if let Some(result) = __mq.get_mut(&__values[..]) { if !unconstrained { *result.multiplicity += G::ONE; } result.output[0] } else { let __ptr = G::from_usize(__mq.len()); __mq.insert(&__values[..], &[__ptr], G::from_bool(!unconstrained)); __ptr } }; - let __r_arr: [G; OUT_324] = { let __args: [G; IN_324] = [__v_10, __v_14]; let __cu = unconstrained; if let Some(result) = record.function_queries[324].get_mut(&__args[..]) { if !__cu && *result.multiplicity == G::ZERO { aiur_fn_324(__args, record, io_buffer, false)? } else { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_324] = unsafe { *(result.output.as_ptr() as *const [G; OUT_324]) }; __ret } } else { aiur_fn_324(__args, record, io_buffer, __cu)? } }; + let __r_arr: [G; OUT_320] = { let __args: [G; IN_320] = [__v_10, __v_14]; let __cu = unconstrained; if let Some(result) = record.function_queries[320].get_mut(&__args[..]) { if !__cu && *result.multiplicity == G::ZERO { aiur_fn_320(__args, record, io_buffer, false)? } else { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_320] = unsafe { *(result.output.as_ptr() as *const [G; OUT_320]) }; __ret } } else { aiur_fn_320(__args, record, io_buffer, __cu)? } }; let __v_15: G = __r_arr[0]; let __v_16: G = (__v_11 - __v_15); let __v_17: G = G::from_u64(1); @@ -52219,16 +51935,16 @@ fn aiur_fn_616( let __v_22: G = { let __values: [G; 3] = [__v_21, __v_7, __v_3]; let __mq = record.memory_queries.get_mut(&3).ok_or(ExecError::InvalidMemorySize(3))?; if let Some(result) = __mq.get_mut(&__values[..]) { if !unconstrained { *result.multiplicity += G::ONE; } result.output[0] } else { let __ptr = G::from_usize(__mq.len()); __mq.insert(&__values[..], &[__ptr], G::from_bool(!unconstrained)); __ptr } }; let __v_23: G = G::from_u64(1); let __v_24: G = (__v_2 + __v_23); - let __r_arr: [G; OUT_616] = { let __args: [G; IN_616] = [__v_8, __v_1, __v_24, __v_22, __v_20]; let __cu = unconstrained; if let Some(result) = record.function_queries[616].get_mut(&__args[..]) { if !__cu && *result.multiplicity == G::ZERO { aiur_fn_616(__args, record, io_buffer, false)? } else { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_616] = unsafe { *(result.output.as_ptr() as *const [G; OUT_616]) }; __ret } } else { aiur_fn_616(__args, record, io_buffer, __cu)? } }; + let __r_arr: [G; OUT_612] = { let __args: [G; IN_612] = [__v_8, __v_1, __v_24, __v_22, __v_20]; let __cu = unconstrained; if let Some(result) = record.function_queries[612].get_mut(&__args[..]) { if !__cu && *result.multiplicity == G::ZERO { aiur_fn_612(__args, record, io_buffer, false)? } else { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_612] = unsafe { *(result.output.as_ptr() as *const [G; OUT_612]) }; __ret } } else { aiur_fn_612(__args, record, io_buffer, __cu)? } }; let __v_25: G = __r_arr[0]; - let __ret: [G; OUT_616] = [__v_25]; - if let Some(result) = record.function_queries[616].get_mut(&inp[..]) { debug_assert_eq!(result.output, &__ret[..]); if !unconstrained { *result.multiplicity += G::ONE; } } else { record.function_queries[616].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained)); }; + let __ret: [G; OUT_612] = [__v_25]; + if let Some(result) = record.function_queries[612].get_mut(&inp[..]) { debug_assert_eq!(result.output, &__ret[..]); if !unconstrained { *result.multiplicity += G::ONE; } } else { record.function_queries[612].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained)); }; return Ok(__ret); }, _ => { let __v_10: G = G::from_u64(0); - let __ret: [G; OUT_616] = [__v_10]; - if let Some(result) = record.function_queries[616].get_mut(&inp[..]) { debug_assert_eq!(result.output, &__ret[..]); if !unconstrained { *result.multiplicity += G::ONE; } } else { record.function_queries[616].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained)); }; + let __ret: [G; OUT_612] = [__v_10]; + if let Some(result) = record.function_queries[612].get_mut(&inp[..]) { debug_assert_eq!(result.output, &__ret[..]); if !unconstrained { *result.multiplicity += G::ONE; } } else { record.function_queries[612].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained)); }; return Ok(__ret); }, } @@ -52237,15 +51953,15 @@ fn aiur_fn_616( }) } -const INPUT_SIZE_617: usize = 2; -const IN_617: usize = 2; -const OUT_617: usize = 1; -fn aiur_fn_617( - inp: [G; IN_617], +const INPUT_SIZE_613: usize = 2; +const IN_613: usize = 2; +const OUT_613: usize = 1; +fn aiur_fn_613( + inp: [G; IN_613], record: &mut QueryRecord, io_buffer: &mut IOBuffer, unconstrained: bool, -) -> Result<[G; OUT_617], ExecError> { +) -> Result<[G; OUT_613], ExecError> { stacker::maybe_grow(64 * 1024, 4 * 1024 * 1024, || { let __v_0: G = inp[0]; let __v_1: G = inp[1]; @@ -52256,25 +51972,25 @@ fn aiur_fn_617( match __v_2.as_canonical_u64() { 1u64 => { let __v_5: G = G::from_u64(1); - let __ret: [G; OUT_617] = [__v_5]; - if let Some(result) = record.function_queries[617].get_mut(&inp[..]) { debug_assert_eq!(result.output, &__ret[..]); if !unconstrained { *result.multiplicity += G::ONE; } } else { record.function_queries[617].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained)); }; + let __ret: [G; OUT_613] = [__v_5]; + if let Some(result) = record.function_queries[613].get_mut(&inp[..]) { debug_assert_eq!(result.output, &__ret[..]); if !unconstrained { *result.multiplicity += G::ONE; } } else { record.function_queries[613].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained)); }; return Ok(__ret); }, 0u64 => { - let __r_arr: [G; OUT_618] = { let __args: [G; IN_618] = [__v_1, __v_3]; let __cu = unconstrained; if let Some(result) = record.function_queries[618].get_mut(&__args[..]) { if !__cu && *result.multiplicity == G::ZERO { aiur_fn_618(__args, record, io_buffer, false)? } else { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_618] = unsafe { *(result.output.as_ptr() as *const [G; OUT_618]) }; __ret } } else { aiur_fn_618(__args, record, io_buffer, __cu)? } }; + let __r_arr: [G; OUT_614] = { let __args: [G; IN_614] = [__v_1, __v_3]; let __cu = unconstrained; if let Some(result) = record.function_queries[614].get_mut(&__args[..]) { if !__cu && *result.multiplicity == G::ZERO { aiur_fn_614(__args, record, io_buffer, false)? } else { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_614] = unsafe { *(result.output.as_ptr() as *const [G; OUT_614]) }; __ret } } else { aiur_fn_614(__args, record, io_buffer, __cu)? } }; let __v_5: G = __r_arr[0]; match __v_5.as_canonical_u64() { 0u64 => { let __v_6: G = G::from_u64(0); - let __ret: [G; OUT_617] = [__v_6]; - if let Some(result) = record.function_queries[617].get_mut(&inp[..]) { debug_assert_eq!(result.output, &__ret[..]); if !unconstrained { *result.multiplicity += G::ONE; } } else { record.function_queries[617].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained)); }; + let __ret: [G; OUT_613] = [__v_6]; + if let Some(result) = record.function_queries[613].get_mut(&inp[..]) { debug_assert_eq!(result.output, &__ret[..]); if !unconstrained { *result.multiplicity += G::ONE; } } else { record.function_queries[613].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained)); }; return Ok(__ret); }, _ => { - let __r_arr: [G; OUT_617] = { let __args: [G; IN_617] = [__v_4, __v_1]; let __cu = unconstrained; if let Some(result) = record.function_queries[617].get_mut(&__args[..]) { if !__cu && *result.multiplicity == G::ZERO { aiur_fn_617(__args, record, io_buffer, false)? } else { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_617] = unsafe { *(result.output.as_ptr() as *const [G; OUT_617]) }; __ret } } else { aiur_fn_617(__args, record, io_buffer, __cu)? } }; + let __r_arr: [G; OUT_613] = { let __args: [G; IN_613] = [__v_4, __v_1]; let __cu = unconstrained; if let Some(result) = record.function_queries[613].get_mut(&__args[..]) { if !__cu && *result.multiplicity == G::ZERO { aiur_fn_613(__args, record, io_buffer, false)? } else { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_613] = unsafe { *(result.output.as_ptr() as *const [G; OUT_613]) }; __ret } } else { aiur_fn_613(__args, record, io_buffer, __cu)? } }; let __v_6: G = __r_arr[0]; - let __ret: [G; OUT_617] = [__v_6]; - if let Some(result) = record.function_queries[617].get_mut(&inp[..]) { debug_assert_eq!(result.output, &__ret[..]); if !unconstrained { *result.multiplicity += G::ONE; } } else { record.function_queries[617].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained)); }; + let __ret: [G; OUT_613] = [__v_6]; + if let Some(result) = record.function_queries[613].get_mut(&inp[..]) { debug_assert_eq!(result.output, &__ret[..]); if !unconstrained { *result.multiplicity += G::ONE; } } else { record.function_queries[613].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained)); }; return Ok(__ret); }, } @@ -52286,15 +52002,15 @@ fn aiur_fn_617( }) } -const INPUT_SIZE_618: usize = 2; -const IN_618: usize = 2; -const OUT_618: usize = 1; -fn aiur_fn_618( - inp: [G; IN_618], +const INPUT_SIZE_614: usize = 2; +const IN_614: usize = 2; +const OUT_614: usize = 1; +fn aiur_fn_614( + inp: [G; IN_614], record: &mut QueryRecord, io_buffer: &mut IOBuffer, unconstrained: bool, -) -> Result<[G; OUT_618], ExecError> { +) -> Result<[G; OUT_614], ExecError> { stacker::maybe_grow(64 * 1024, 4 * 1024 * 1024, || { let __v_0: G = inp[0]; let __v_1: G = inp[1]; @@ -52305,8 +52021,8 @@ fn aiur_fn_618( match __v_2.as_canonical_u64() { 1u64 => { let __v_5: G = G::from_u64(0); - let __ret: [G; OUT_618] = [__v_5]; - if let Some(result) = record.function_queries[618].get_mut(&inp[..]) { debug_assert_eq!(result.output, &__ret[..]); if !unconstrained { *result.multiplicity += G::ONE; } } else { record.function_queries[618].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained)); }; + let __ret: [G; OUT_614] = [__v_5]; + if let Some(result) = record.function_queries[614].get_mut(&inp[..]) { debug_assert_eq!(result.output, &__ret[..]); if !unconstrained { *result.multiplicity += G::ONE; } } else { record.function_queries[614].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained)); }; return Ok(__ret); }, 0u64 => { @@ -52321,24 +52037,24 @@ fn aiur_fn_618( match __v_9.as_canonical_u64() { 0u64 => { let __v_10: G = G::from_u64(1); - let __ret: [G; OUT_618] = [__v_10]; - if let Some(result) = record.function_queries[618].get_mut(&inp[..]) { debug_assert_eq!(result.output, &__ret[..]); if !unconstrained { *result.multiplicity += G::ONE; } } else { record.function_queries[618].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained)); }; + let __ret: [G; OUT_614] = [__v_10]; + if let Some(result) = record.function_queries[614].get_mut(&inp[..]) { debug_assert_eq!(result.output, &__ret[..]); if !unconstrained { *result.multiplicity += G::ONE; } } else { record.function_queries[614].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained)); }; return Ok(__ret); }, _ => { - let __r_arr: [G; OUT_618] = { let __args: [G; IN_618] = [__v_4, __v_1]; let __cu = unconstrained; if let Some(result) = record.function_queries[618].get_mut(&__args[..]) { if !__cu && *result.multiplicity == G::ZERO { aiur_fn_618(__args, record, io_buffer, false)? } else { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_618] = unsafe { *(result.output.as_ptr() as *const [G; OUT_618]) }; __ret } } else { aiur_fn_618(__args, record, io_buffer, __cu)? } }; + let __r_arr: [G; OUT_614] = { let __args: [G; IN_614] = [__v_4, __v_1]; let __cu = unconstrained; if let Some(result) = record.function_queries[614].get_mut(&__args[..]) { if !__cu && *result.multiplicity == G::ZERO { aiur_fn_614(__args, record, io_buffer, false)? } else { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_614] = unsafe { *(result.output.as_ptr() as *const [G; OUT_614]) }; __ret } } else { aiur_fn_614(__args, record, io_buffer, __cu)? } }; let __v_10: G = __r_arr[0]; - let __ret: [G; OUT_618] = [__v_10]; - if let Some(result) = record.function_queries[618].get_mut(&inp[..]) { debug_assert_eq!(result.output, &__ret[..]); if !unconstrained { *result.multiplicity += G::ONE; } } else { record.function_queries[618].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained)); }; + let __ret: [G; OUT_614] = [__v_10]; + if let Some(result) = record.function_queries[614].get_mut(&inp[..]) { debug_assert_eq!(result.output, &__ret[..]); if !unconstrained { *result.multiplicity += G::ONE; } } else { record.function_queries[614].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained)); }; return Ok(__ret); }, } }, _ => { - let __r_arr: [G; OUT_618] = { let __args: [G; IN_618] = [__v_4, __v_1]; let __cu = unconstrained; if let Some(result) = record.function_queries[618].get_mut(&__args[..]) { if !__cu && *result.multiplicity == G::ZERO { aiur_fn_618(__args, record, io_buffer, false)? } else { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_618] = unsafe { *(result.output.as_ptr() as *const [G; OUT_618]) }; __ret } } else { aiur_fn_618(__args, record, io_buffer, __cu)? } }; + let __r_arr: [G; OUT_614] = { let __args: [G; IN_614] = [__v_4, __v_1]; let __cu = unconstrained; if let Some(result) = record.function_queries[614].get_mut(&__args[..]) { if !__cu && *result.multiplicity == G::ZERO { aiur_fn_614(__args, record, io_buffer, false)? } else { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_614] = unsafe { *(result.output.as_ptr() as *const [G; OUT_614]) }; __ret } } else { aiur_fn_614(__args, record, io_buffer, __cu)? } }; let __v_9: G = __r_arr[0]; - let __ret: [G; OUT_618] = [__v_9]; - if let Some(result) = record.function_queries[618].get_mut(&inp[..]) { debug_assert_eq!(result.output, &__ret[..]); if !unconstrained { *result.multiplicity += G::ONE; } } else { record.function_queries[618].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained)); }; + let __ret: [G; OUT_614] = [__v_9]; + if let Some(result) = record.function_queries[614].get_mut(&inp[..]) { debug_assert_eq!(result.output, &__ret[..]); if !unconstrained { *result.multiplicity += G::ONE; } } else { record.function_queries[614].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained)); }; return Ok(__ret); }, } @@ -52350,15 +52066,15 @@ fn aiur_fn_618( }) } -const INPUT_SIZE_619: usize = 13; -const IN_619: usize = 13; -const OUT_619: usize = 1; -fn aiur_fn_619( - inp: [G; IN_619], +const INPUT_SIZE_615: usize = 13; +const IN_615: usize = 13; +const OUT_615: usize = 1; +fn aiur_fn_615( + inp: [G; IN_615], record: &mut QueryRecord, io_buffer: &mut IOBuffer, unconstrained: bool, -) -> Result<[G; OUT_619], ExecError> { +) -> Result<[G; OUT_615], ExecError> { stacker::maybe_grow(64 * 1024, 4 * 1024 * 1024, || { let __v_0: G = inp[0]; let __v_1: G = inp[1]; @@ -52375,13 +52091,13 @@ fn aiur_fn_619( let __v_12: G = inp[12]; match __v_0.as_canonical_u64() { 5u64 => { - let __r_arr: [G; OUT_620] = { let __args: [G; IN_620] = [__v_7, __v_12]; let __cu = unconstrained; if let Some(result) = record.function_queries[620].get_mut(&__args[..]) { if !__cu && *result.multiplicity == G::ZERO { aiur_fn_620(__args, record, io_buffer, false)? } else { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_620] = unsafe { *(result.output.as_ptr() as *const [G; OUT_620]) }; __ret } } else { aiur_fn_620(__args, record, io_buffer, __cu)? } }; + let __r_arr: [G; OUT_616] = { let __args: [G; IN_616] = [__v_7, __v_12]; let __cu = unconstrained; if let Some(result) = record.function_queries[616].get_mut(&__args[..]) { if !__cu && *result.multiplicity == G::ZERO { aiur_fn_616(__args, record, io_buffer, false)? } else { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_616] = unsafe { *(result.output.as_ptr() as *const [G; OUT_616]) }; __ret } } else { aiur_fn_616(__args, record, io_buffer, __cu)? } }; let __v_13: G = __r_arr[0]; match __v_13.as_canonical_u64() { 0u64 => { let __v_14: G = G::from_u64(0); - let __ret: [G; OUT_619] = [__v_14]; - if let Some(result) = record.function_queries[619].get_mut(&inp[..]) { debug_assert_eq!(result.output, &__ret[..]); if !unconstrained { *result.multiplicity += G::ONE; } } else { record.function_queries[619].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained)); }; + let __ret: [G; OUT_615] = [__v_14]; + if let Some(result) = record.function_queries[615].get_mut(&inp[..]) { debug_assert_eq!(result.output, &__ret[..]); if !unconstrained { *result.multiplicity += G::ONE; } } else { record.function_queries[615].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained)); }; return Ok(__ret); }, _ => { @@ -52389,25 +52105,25 @@ fn aiur_fn_619( let __v_15: G = G::from_u64(1); let __v_16: G = G::from_u64(1); let __v_17: G = { let __values: [G; 3] = [__v_15, __v_16, __v_16]; let __mq = record.memory_queries.get_mut(&3).ok_or(ExecError::InvalidMemorySize(3))?; if let Some(result) = __mq.get_mut(&__values[..]) { if !unconstrained { *result.multiplicity += G::ONE; } result.output[0] } else { let __ptr = G::from_usize(__mq.len()); __mq.insert(&__values[..], &[__ptr], G::from_bool(!unconstrained)); __ptr } }; - let __r_arr: [G; OUT_593] = { let __args: [G; IN_593] = [__v_2, __v_14, __v_17]; let __cu = unconstrained; if let Some(result) = record.function_queries[593].get_mut(&__args[..]) { if !__cu && *result.multiplicity == G::ZERO { aiur_fn_593(__args, record, io_buffer, false)? } else { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_593] = unsafe { *(result.output.as_ptr() as *const [G; OUT_593]) }; __ret } } else { aiur_fn_593(__args, record, io_buffer, __cu)? } }; + let __r_arr: [G; OUT_589] = { let __args: [G; IN_589] = [__v_2, __v_14, __v_17]; let __cu = unconstrained; if let Some(result) = record.function_queries[589].get_mut(&__args[..]) { if !__cu && *result.multiplicity == G::ZERO { aiur_fn_589(__args, record, io_buffer, false)? } else { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_589] = unsafe { *(result.output.as_ptr() as *const [G; OUT_589]) }; __ret } } else { aiur_fn_589(__args, record, io_buffer, __cu)? } }; let __v_18: G = __r_arr[0]; let __v_19: G = G::from_u64(0); let __v_20: G = G::from_u64(0); let __v_21: G = { let __values: [G; 3] = [__v_19, __v_20, __v_20]; let __mq = record.memory_queries.get_mut(&3).ok_or(ExecError::InvalidMemorySize(3))?; if let Some(result) = __mq.get_mut(&__values[..]) { if !unconstrained { *result.multiplicity += G::ONE; } result.output[0] } else { let __ptr = G::from_usize(__mq.len()); __mq.insert(&__values[..], &[__ptr], G::from_bool(!unconstrained)); __ptr } }; - let __r_arr: [G; OUT_324] = { let __args: [G; IN_324] = [__v_18, __v_21]; let __cu = unconstrained; if let Some(result) = record.function_queries[324].get_mut(&__args[..]) { if !__cu && *result.multiplicity == G::ZERO { aiur_fn_324(__args, record, io_buffer, false)? } else { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_324] = unsafe { *(result.output.as_ptr() as *const [G; OUT_324]) }; __ret } } else { aiur_fn_324(__args, record, io_buffer, __cu)? } }; + let __r_arr: [G; OUT_320] = { let __args: [G; IN_320] = [__v_18, __v_21]; let __cu = unconstrained; if let Some(result) = record.function_queries[320].get_mut(&__args[..]) { if !__cu && *result.multiplicity == G::ZERO { aiur_fn_320(__args, record, io_buffer, false)? } else { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_320] = unsafe { *(result.output.as_ptr() as *const [G; OUT_320]) }; __ret } } else { aiur_fn_320(__args, record, io_buffer, __cu)? } }; let __v_22: G = __r_arr[0]; match __v_22.as_canonical_u64() { 0u64 => { let __v_23: G = G::from_u64(0); - let __ret: [G; OUT_619] = [__v_23]; - if let Some(result) = record.function_queries[619].get_mut(&inp[..]) { debug_assert_eq!(result.output, &__ret[..]); if !unconstrained { *result.multiplicity += G::ONE; } } else { record.function_queries[619].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained)); }; + let __ret: [G; OUT_615] = [__v_23]; + if let Some(result) = record.function_queries[615].get_mut(&inp[..]) { debug_assert_eq!(result.output, &__ret[..]); if !unconstrained { *result.multiplicity += G::ONE; } } else { record.function_queries[615].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained)); }; return Ok(__ret); }, _ => { match __v_5.as_canonical_u64() { 1u64 => { let __v_23: G = G::from_u64(0); - let __r_arr: [G; OUT_290] = { let __args: [G; IN_290] = [__v_7, __v_8, __v_23]; let __cu = unconstrained; if let Some(result) = record.function_queries[290].get_mut(&__args[..]) { if !__cu && *result.multiplicity == G::ZERO { aiur_fn_290(__args, record, io_buffer, false)? } else { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_290] = unsafe { *(result.output.as_ptr() as *const [G; OUT_290]) }; __ret } } else { aiur_fn_290(__args, record, io_buffer, __cu)? } }; + let __r_arr: [G; OUT_286] = { let __args: [G; IN_286] = [__v_7, __v_8, __v_23]; let __cu = unconstrained; if let Some(result) = record.function_queries[286].get_mut(&__args[..]) { if !__cu && *result.multiplicity == G::ZERO { aiur_fn_286(__args, record, io_buffer, false)? } else { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_286] = unsafe { *(result.output.as_ptr() as *const [G; OUT_286]) }; __ret } } else { aiur_fn_286(__args, record, io_buffer, __cu)? } }; let __v_24: G = __r_arr[0]; let __loaded: [G; 12] = { let __mq = record.memory_queries.get_mut(&12).ok_or(ExecError::InvalidMemorySize(12))?; let __ptr_u64 = __v_24.as_canonical_u64(); let __ptr_usize = usize::try_from(__ptr_u64).ok().ok_or(ExecError::PointerTooLarge(__ptr_u64))?; let (__args, __mult) = __mq.get_index_mut(__ptr_usize).ok_or(ExecError::UnboundPointer { ptr: __ptr_u64, size: 12 })?; if !unconstrained { *__mult += G::ONE; } let __arr: [G; 12] = __args[..12].try_into().unwrap(); __arr }; let __v_25: G = __loaded[0]; @@ -52425,22 +52141,22 @@ fn aiur_fn_619( match __v_25.as_canonical_u64() { 6u64 => { let __v_37: G = G::from_bool((__v_32 == G::ZERO)); - let __ret: [G; OUT_619] = [__v_37]; - if let Some(result) = record.function_queries[619].get_mut(&inp[..]) { debug_assert_eq!(result.output, &__ret[..]); if !unconstrained { *result.multiplicity += G::ONE; } } else { record.function_queries[619].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained)); }; + let __ret: [G; OUT_615] = [__v_37]; + if let Some(result) = record.function_queries[615].get_mut(&inp[..]) { debug_assert_eq!(result.output, &__ret[..]); if !unconstrained { *result.multiplicity += G::ONE; } } else { record.function_queries[615].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained)); }; return Ok(__ret); }, _ => { let __v_37: G = G::from_u64(0); - let __ret: [G; OUT_619] = [__v_37]; - if let Some(result) = record.function_queries[619].get_mut(&inp[..]) { debug_assert_eq!(result.output, &__ret[..]); if !unconstrained { *result.multiplicity += G::ONE; } } else { record.function_queries[619].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained)); }; + let __ret: [G; OUT_615] = [__v_37]; + if let Some(result) = record.function_queries[615].get_mut(&inp[..]) { debug_assert_eq!(result.output, &__ret[..]); if !unconstrained { *result.multiplicity += G::ONE; } } else { record.function_queries[615].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained)); }; return Ok(__ret); }, } }, _ => { let __v_23: G = G::from_u64(0); - let __ret: [G; OUT_619] = [__v_23]; - if let Some(result) = record.function_queries[619].get_mut(&inp[..]) { debug_assert_eq!(result.output, &__ret[..]); if !unconstrained { *result.multiplicity += G::ONE; } } else { record.function_queries[619].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained)); }; + let __ret: [G; OUT_615] = [__v_23]; + if let Some(result) = record.function_queries[615].get_mut(&inp[..]) { debug_assert_eq!(result.output, &__ret[..]); if !unconstrained { *result.multiplicity += G::ONE; } } else { record.function_queries[615].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained)); }; return Ok(__ret); }, } @@ -52451,23 +52167,23 @@ fn aiur_fn_619( }, _ => { let __v_13: G = G::from_u64(0); - let __ret: [G; OUT_619] = [__v_13]; - if let Some(result) = record.function_queries[619].get_mut(&inp[..]) { debug_assert_eq!(result.output, &__ret[..]); if !unconstrained { *result.multiplicity += G::ONE; } } else { record.function_queries[619].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained)); }; + let __ret: [G; OUT_615] = [__v_13]; + if let Some(result) = record.function_queries[615].get_mut(&inp[..]) { debug_assert_eq!(result.output, &__ret[..]); if !unconstrained { *result.multiplicity += G::ONE; } } else { record.function_queries[615].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained)); }; return Ok(__ret); }, } }) } -const INPUT_SIZE_620: usize = 2; -const IN_620: usize = 2; -const OUT_620: usize = 1; -fn aiur_fn_620( - inp: [G; IN_620], +const INPUT_SIZE_616: usize = 2; +const IN_616: usize = 2; +const OUT_616: usize = 1; +fn aiur_fn_616( + inp: [G; IN_616], record: &mut QueryRecord, io_buffer: &mut IOBuffer, unconstrained: bool, -) -> Result<[G; OUT_620], ExecError> { +) -> Result<[G; OUT_616], ExecError> { stacker::maybe_grow(64 * 1024, 4 * 1024 * 1024, || { let __v_0: G = inp[0]; let __v_1: G = inp[1]; @@ -52476,12 +52192,12 @@ fn aiur_fn_620( match __v_2.as_canonical_u64() { 1u64 => { let __v_3: G = G::from_u64(1); - let __ret: [G; OUT_620] = [__v_3]; - if let Some(result) = record.function_queries[620].get_mut(&inp[..]) { debug_assert_eq!(result.output, &__ret[..]); if !unconstrained { *result.multiplicity += G::ONE; } } else { record.function_queries[620].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained)); }; + let __ret: [G; OUT_616] = [__v_3]; + if let Some(result) = record.function_queries[616].get_mut(&inp[..]) { debug_assert_eq!(result.output, &__ret[..]); if !unconstrained { *result.multiplicity += G::ONE; } } else { record.function_queries[616].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained)); }; return Ok(__ret); }, _ => { - let __r_arr: [G; OUT_282] = { let __args: [G; IN_282] = [__v_0]; let __cu = unconstrained; if let Some(result) = record.function_queries[282].get_mut(&__args[..]) { if !__cu && *result.multiplicity == G::ZERO { aiur_fn_282(__args, record, io_buffer, false)? } else { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_282] = unsafe { *(result.output.as_ptr() as *const [G; OUT_282]) }; __ret } } else { aiur_fn_282(__args, record, io_buffer, __cu)? } }; + let __r_arr: [G; OUT_278] = { let __args: [G; IN_278] = [__v_0]; let __cu = unconstrained; if let Some(result) = record.function_queries[278].get_mut(&__args[..]) { if !__cu && *result.multiplicity == G::ZERO { aiur_fn_278(__args, record, io_buffer, false)? } else { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_278] = unsafe { *(result.output.as_ptr() as *const [G; OUT_278]) }; __ret } } else { aiur_fn_278(__args, record, io_buffer, __cu)? } }; let __v_3: G = __r_arr[0]; let __v_4: G = __r_arr[1]; let __v_5: G = __r_arr[2]; @@ -52535,16 +52251,16 @@ fn aiur_fn_620( match __v_3.as_canonical_u64() { 8u64 => { let __v_51: G = G::from_u64(0); - let __r_arr: [G; OUT_622] = { let __args: [G; IN_622] = [__v_4, __v_51]; let __cu = unconstrained; if let Some(result) = record.function_queries[622].get_mut(&__args[..]) { if !__cu && *result.multiplicity == G::ZERO { aiur_fn_622(__args, record, io_buffer, false)? } else { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_622] = unsafe { *(result.output.as_ptr() as *const [G; OUT_622]) }; __ret } } else { aiur_fn_622(__args, record, io_buffer, __cu)? } }; + let __r_arr: [G; OUT_618] = { let __args: [G; IN_618] = [__v_4, __v_51]; let __cu = unconstrained; if let Some(result) = record.function_queries[618].get_mut(&__args[..]) { if !__cu && *result.multiplicity == G::ZERO { aiur_fn_618(__args, record, io_buffer, false)? } else { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_618] = unsafe { *(result.output.as_ptr() as *const [G; OUT_618]) }; __ret } } else { aiur_fn_618(__args, record, io_buffer, __cu)? } }; let __v_52: G = __r_arr[0]; - let __ret: [G; OUT_620] = [__v_52]; - if let Some(result) = record.function_queries[620].get_mut(&inp[..]) { debug_assert_eq!(result.output, &__ret[..]); if !unconstrained { *result.multiplicity += G::ONE; } } else { record.function_queries[620].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained)); }; + let __ret: [G; OUT_616] = [__v_52]; + if let Some(result) = record.function_queries[616].get_mut(&inp[..]) { debug_assert_eq!(result.output, &__ret[..]); if !unconstrained { *result.multiplicity += G::ONE; } } else { record.function_queries[616].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained)); }; return Ok(__ret); }, _ => { let __v_51: G = G::from_u64(0); - let __ret: [G; OUT_620] = [__v_51]; - if let Some(result) = record.function_queries[620].get_mut(&inp[..]) { debug_assert_eq!(result.output, &__ret[..]); if !unconstrained { *result.multiplicity += G::ONE; } } else { record.function_queries[620].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained)); }; + let __ret: [G; OUT_616] = [__v_51]; + if let Some(result) = record.function_queries[616].get_mut(&inp[..]) { debug_assert_eq!(result.output, &__ret[..]); if !unconstrained { *result.multiplicity += G::ONE; } } else { record.function_queries[616].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained)); }; return Ok(__ret); }, } @@ -52555,18 +52271,18 @@ fn aiur_fn_620( }) } -const INPUT_SIZE_621: usize = 1; -const IN_621: usize = 1; -const OUT_621: usize = 1; -fn aiur_fn_621( - inp: [G; IN_621], +const INPUT_SIZE_617: usize = 1; +const IN_617: usize = 1; +const OUT_617: usize = 1; +fn aiur_fn_617( + inp: [G; IN_617], record: &mut QueryRecord, io_buffer: &mut IOBuffer, unconstrained: bool, -) -> Result<[G; OUT_621], ExecError> { +) -> Result<[G; OUT_617], ExecError> { stacker::maybe_grow(64 * 1024, 4 * 1024 * 1024, || { let __v_0: G = inp[0]; - let __r_arr: [G; OUT_282] = { let __args: [G; IN_282] = [__v_0]; let __cu = unconstrained; if let Some(result) = record.function_queries[282].get_mut(&__args[..]) { if !__cu && *result.multiplicity == G::ZERO { aiur_fn_282(__args, record, io_buffer, false)? } else { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_282] = unsafe { *(result.output.as_ptr() as *const [G; OUT_282]) }; __ret } } else { aiur_fn_282(__args, record, io_buffer, __cu)? } }; + let __r_arr: [G; OUT_278] = { let __args: [G; IN_278] = [__v_0]; let __cu = unconstrained; if let Some(result) = record.function_queries[278].get_mut(&__args[..]) { if !__cu && *result.multiplicity == G::ZERO { aiur_fn_278(__args, record, io_buffer, false)? } else { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_278] = unsafe { *(result.output.as_ptr() as *const [G; OUT_278]) }; __ret } } else { aiur_fn_278(__args, record, io_buffer, __cu)? } }; let __v_1: G = __r_arr[0]; let __v_2: G = __r_arr[1]; let __v_3: G = __r_arr[2]; @@ -52620,14 +52336,14 @@ fn aiur_fn_621( match __v_1.as_canonical_u64() { 8u64 => { let __v_49: G = G::from_u64(1); - let __ret: [G; OUT_621] = [__v_49]; - if let Some(result) = record.function_queries[621].get_mut(&inp[..]) { debug_assert_eq!(result.output, &__ret[..]); if !unconstrained { *result.multiplicity += G::ONE; } } else { record.function_queries[621].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained)); }; + let __ret: [G; OUT_617] = [__v_49]; + if let Some(result) = record.function_queries[617].get_mut(&inp[..]) { debug_assert_eq!(result.output, &__ret[..]); if !unconstrained { *result.multiplicity += G::ONE; } } else { record.function_queries[617].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained)); }; return Ok(__ret); }, _ => { let __v_49: G = G::from_u64(0); - let __ret: [G; OUT_621] = [__v_49]; - if let Some(result) = record.function_queries[621].get_mut(&inp[..]) { debug_assert_eq!(result.output, &__ret[..]); if !unconstrained { *result.multiplicity += G::ONE; } } else { record.function_queries[621].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained)); }; + let __ret: [G; OUT_617] = [__v_49]; + if let Some(result) = record.function_queries[617].get_mut(&inp[..]) { debug_assert_eq!(result.output, &__ret[..]); if !unconstrained { *result.multiplicity += G::ONE; } } else { record.function_queries[617].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained)); }; return Ok(__ret); }, } @@ -52636,15 +52352,15 @@ fn aiur_fn_621( }) } -const INPUT_SIZE_622: usize = 2; -const IN_622: usize = 2; -const OUT_622: usize = 1; -fn aiur_fn_622( - inp: [G; IN_622], +const INPUT_SIZE_618: usize = 2; +const IN_618: usize = 2; +const OUT_618: usize = 1; +fn aiur_fn_618( + inp: [G; IN_618], record: &mut QueryRecord, io_buffer: &mut IOBuffer, unconstrained: bool, -) -> Result<[G; OUT_622], ExecError> { +) -> Result<[G; OUT_618], ExecError> { stacker::maybe_grow(64 * 1024, 4 * 1024 * 1024, || { let __v_0: G = inp[0]; let __v_1: G = inp[1]; @@ -52701,14 +52417,14 @@ fn aiur_fn_622( match __v_1.as_canonical_u64() { 1u64 => { let __v_49: G = G::from_u64(1); - let __ret: [G; OUT_622] = [__v_49]; - if let Some(result) = record.function_queries[622].get_mut(&inp[..]) { debug_assert_eq!(result.output, &__ret[..]); if !unconstrained { *result.multiplicity += G::ONE; } } else { record.function_queries[622].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained)); }; + let __ret: [G; OUT_618] = [__v_49]; + if let Some(result) = record.function_queries[618].get_mut(&inp[..]) { debug_assert_eq!(result.output, &__ret[..]); if !unconstrained { *result.multiplicity += G::ONE; } } else { record.function_queries[618].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained)); }; return Ok(__ret); }, _ => { let __v_49: G = G::from_u64(0); - let __ret: [G; OUT_622] = [__v_49]; - if let Some(result) = record.function_queries[622].get_mut(&inp[..]) { debug_assert_eq!(result.output, &__ret[..]); if !unconstrained { *result.multiplicity += G::ONE; } } else { record.function_queries[622].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained)); }; + let __ret: [G; OUT_618] = [__v_49]; + if let Some(result) = record.function_queries[618].get_mut(&inp[..]) { debug_assert_eq!(result.output, &__ret[..]); if !unconstrained { *result.multiplicity += G::ONE; } } else { record.function_queries[618].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained)); }; return Ok(__ret); }, } @@ -52718,17 +52434,17 @@ fn aiur_fn_622( 1u64 => { let __v_49: G = G::from_u64(1); let __v_50: G = (__v_1 + __v_49); - let __r_arr: [G; OUT_622] = { let __args: [G; IN_622] = [__v_48, __v_50]; let __cu = unconstrained; if let Some(result) = record.function_queries[622].get_mut(&__args[..]) { if !__cu && *result.multiplicity == G::ZERO { aiur_fn_622(__args, record, io_buffer, false)? } else { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_622] = unsafe { *(result.output.as_ptr() as *const [G; OUT_622]) }; __ret } } else { aiur_fn_622(__args, record, io_buffer, __cu)? } }; + let __r_arr: [G; OUT_618] = { let __args: [G; IN_618] = [__v_48, __v_50]; let __cu = unconstrained; if let Some(result) = record.function_queries[618].get_mut(&__args[..]) { if !__cu && *result.multiplicity == G::ZERO { aiur_fn_618(__args, record, io_buffer, false)? } else { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_618] = unsafe { *(result.output.as_ptr() as *const [G; OUT_618]) }; __ret } } else { aiur_fn_618(__args, record, io_buffer, __cu)? } }; let __v_51: G = __r_arr[0]; - let __ret: [G; OUT_622] = [__v_51]; - if let Some(result) = record.function_queries[622].get_mut(&inp[..]) { debug_assert_eq!(result.output, &__ret[..]); if !unconstrained { *result.multiplicity += G::ONE; } } else { record.function_queries[622].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained)); }; + let __ret: [G; OUT_618] = [__v_51]; + if let Some(result) = record.function_queries[618].get_mut(&inp[..]) { debug_assert_eq!(result.output, &__ret[..]); if !unconstrained { *result.multiplicity += G::ONE; } } else { record.function_queries[618].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained)); }; return Ok(__ret); }, _ => { - let __r_arr: [G; OUT_622] = { let __args: [G; IN_622] = [__v_48, __v_1]; let __cu = unconstrained; if let Some(result) = record.function_queries[622].get_mut(&__args[..]) { if !__cu && *result.multiplicity == G::ZERO { aiur_fn_622(__args, record, io_buffer, false)? } else { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_622] = unsafe { *(result.output.as_ptr() as *const [G; OUT_622]) }; __ret } } else { aiur_fn_622(__args, record, io_buffer, __cu)? } }; + let __r_arr: [G; OUT_618] = { let __args: [G; IN_618] = [__v_48, __v_1]; let __cu = unconstrained; if let Some(result) = record.function_queries[618].get_mut(&__args[..]) { if !__cu && *result.multiplicity == G::ZERO { aiur_fn_618(__args, record, io_buffer, false)? } else { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_618] = unsafe { *(result.output.as_ptr() as *const [G; OUT_618]) }; __ret } } else { aiur_fn_618(__args, record, io_buffer, __cu)? } }; let __v_49: G = __r_arr[0]; - let __ret: [G; OUT_622] = [__v_49]; - if let Some(result) = record.function_queries[622].get_mut(&inp[..]) { debug_assert_eq!(result.output, &__ret[..]); if !unconstrained { *result.multiplicity += G::ONE; } } else { record.function_queries[622].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained)); }; + let __ret: [G; OUT_618] = [__v_49]; + if let Some(result) = record.function_queries[618].get_mut(&inp[..]) { debug_assert_eq!(result.output, &__ret[..]); if !unconstrained { *result.multiplicity += G::ONE; } } else { record.function_queries[618].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained)); }; return Ok(__ret); }, } @@ -52740,15 +52456,15 @@ fn aiur_fn_622( }) } -const INPUT_SIZE_623: usize = 5; -const IN_623: usize = 5; -const OUT_623: usize = 1; -fn aiur_fn_623( - inp: [G; IN_623], +const INPUT_SIZE_619: usize = 5; +const IN_619: usize = 5; +const OUT_619: usize = 1; +fn aiur_fn_619( + inp: [G; IN_619], record: &mut QueryRecord, io_buffer: &mut IOBuffer, unconstrained: bool, -) -> Result<[G; OUT_623], ExecError> { +) -> Result<[G; OUT_619], ExecError> { stacker::maybe_grow(64 * 1024, 4 * 1024 * 1024, || { let __v_0: G = inp[0]; let __v_1: G = inp[1]; @@ -52758,7 +52474,7 @@ fn aiur_fn_623( let __v_5: G = (__v_3 + __v_4); let __v_6: G = (__v_2 + __v_5); let __v_7: G = (__v_1 + __v_6); - let __r_arr: [G; OUT_586] = { let __args: [G; IN_586] = [__v_0, __v_7]; let __cu = unconstrained; if let Some(result) = record.function_queries[586].get_mut(&__args[..]) { if !__cu && *result.multiplicity == G::ZERO { aiur_fn_586(__args, record, io_buffer, false)? } else { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_586] = unsafe { *(result.output.as_ptr() as *const [G; OUT_586]) }; __ret } } else { aiur_fn_586(__args, record, io_buffer, __cu)? } }; + let __r_arr: [G; OUT_582] = { let __args: [G; IN_582] = [__v_0, __v_7]; let __cu = unconstrained; if let Some(result) = record.function_queries[582].get_mut(&__args[..]) { if !__cu && *result.multiplicity == G::ZERO { aiur_fn_582(__args, record, io_buffer, false)? } else { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_582] = unsafe { *(result.output.as_ptr() as *const [G; OUT_582]) }; __ret } } else { aiur_fn_582(__args, record, io_buffer, __cu)? } }; let __v_8: G = __r_arr[0]; let __loaded: [G; 4] = { let __mq = record.memory_queries.get_mut(&4).ok_or(ExecError::InvalidMemorySize(4))?; let __ptr_u64 = __v_8.as_canonical_u64(); let __ptr_usize = usize::try_from(__ptr_u64).ok().ok_or(ExecError::PointerTooLarge(__ptr_u64))?; let (__args, __mult) = __mq.get_index_mut(__ptr_usize).ok_or(ExecError::UnboundPointer { ptr: __ptr_u64, size: 4 })?; if !unconstrained { *__mult += G::ONE; } let __arr: [G; 4] = __args[..4].try_into().unwrap(); __arr }; let __v_9: G = __loaded[0]; @@ -52777,8 +52493,8 @@ fn aiur_fn_623( let __v_18: G = __loaded[3]; match __v_15.as_canonical_u64() { 2u64 => { - let __ret: [G; OUT_623] = [__v_16]; - if let Some(result) = record.function_queries[623].get_mut(&inp[..]) { debug_assert_eq!(result.output, &__ret[..]); if !unconstrained { *result.multiplicity += G::ONE; } } else { record.function_queries[623].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained)); }; + let __ret: [G; OUT_619] = [__v_16]; + if let Some(result) = record.function_queries[619].get_mut(&inp[..]) { debug_assert_eq!(result.output, &__ret[..]); if !unconstrained { *result.multiplicity += G::ONE; } } else { record.function_queries[619].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained)); }; return Ok(__ret); }, _ => { @@ -52793,15 +52509,15 @@ fn aiur_fn_623( }) } -const INPUT_SIZE_624: usize = 12; -const IN_624: usize = 12; -const OUT_624: usize = 1; -fn aiur_fn_624( - inp: [G; IN_624], +const INPUT_SIZE_620: usize = 12; +const IN_620: usize = 12; +const OUT_620: usize = 1; +fn aiur_fn_620( + inp: [G; IN_620], record: &mut QueryRecord, io_buffer: &mut IOBuffer, unconstrained: bool, -) -> Result<[G; OUT_624], ExecError> { +) -> Result<[G; OUT_620], ExecError> { stacker::maybe_grow(64 * 1024, 4 * 1024 * 1024, || { let __v_0: G = inp[0]; let __v_1: G = inp[1]; @@ -52820,7 +52536,7 @@ fn aiur_fn_624( let __v_12: G = (__v_3 + __v_5); let __v_13: G = (__v_12 + __v_6); let __v_14: G = (__v_13 + __v_4); - let __r_arr: [G; OUT_586] = { let __args: [G; IN_586] = [__v_2, __v_14]; let __cu = unconstrained; if let Some(result) = record.function_queries[586].get_mut(&__args[..]) { if !__cu && *result.multiplicity == G::ZERO { aiur_fn_586(__args, record, io_buffer, false)? } else { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_586] = unsafe { *(result.output.as_ptr() as *const [G; OUT_586]) }; __ret } } else { aiur_fn_586(__args, record, io_buffer, __cu)? } }; + let __r_arr: [G; OUT_582] = { let __args: [G; IN_582] = [__v_2, __v_14]; let __cu = unconstrained; if let Some(result) = record.function_queries[582].get_mut(&__args[..]) { if !__cu && *result.multiplicity == G::ZERO { aiur_fn_582(__args, record, io_buffer, false)? } else { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_582] = unsafe { *(result.output.as_ptr() as *const [G; OUT_582]) }; __ret } } else { aiur_fn_582(__args, record, io_buffer, __cu)? } }; let __v_15: G = __r_arr[0]; let __loaded: [G; 4] = { let __mq = record.memory_queries.get_mut(&4).ok_or(ExecError::InvalidMemorySize(4))?; let __ptr_u64 = __v_15.as_canonical_u64(); let __ptr_usize = usize::try_from(__ptr_u64).ok().ok_or(ExecError::PointerTooLarge(__ptr_u64))?; let (__args, __mult) = __mq.get_index_mut(__ptr_usize).ok_or(ExecError::UnboundPointer { ptr: __ptr_u64, size: 4 })?; if !unconstrained { *__mult += G::ONE; } let __arr: [G; 4] = __args[..4].try_into().unwrap(); __arr }; let __v_16: G = __loaded[0]; @@ -52839,16 +52555,16 @@ fn aiur_fn_624( let __v_25: G = __loaded[3]; match __v_22.as_canonical_u64() { 2u64 => { - let __ret: [G; OUT_624] = [__v_24]; - if let Some(result) = record.function_queries[624].get_mut(&inp[..]) { debug_assert_eq!(result.output, &__ret[..]); if !unconstrained { *result.multiplicity += G::ONE; } } else { record.function_queries[624].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained)); }; + let __ret: [G; OUT_620] = [__v_24]; + if let Some(result) = record.function_queries[620].get_mut(&inp[..]) { debug_assert_eq!(result.output, &__ret[..]); if !unconstrained { *result.multiplicity += G::ONE; } } else { record.function_queries[620].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained)); }; return Ok(__ret); }, _ => { let __v_26: G = G::from_u64(1); let __v_27: G = G::from_u64(1); let __v_28: G = { let __values: [G; 3] = [__v_26, __v_27, __v_27]; let __mq = record.memory_queries.get_mut(&3).ok_or(ExecError::InvalidMemorySize(3))?; if let Some(result) = __mq.get_mut(&__values[..]) { if !unconstrained { *result.multiplicity += G::ONE; } result.output[0] } else { let __ptr = G::from_usize(__mq.len()); __mq.insert(&__values[..], &[__ptr], G::from_bool(!unconstrained)); __ptr } }; - let __ret: [G; OUT_624] = [__v_28]; - if let Some(result) = record.function_queries[624].get_mut(&inp[..]) { debug_assert_eq!(result.output, &__ret[..]); if !unconstrained { *result.multiplicity += G::ONE; } } else { record.function_queries[624].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained)); }; + let __ret: [G; OUT_620] = [__v_28]; + if let Some(result) = record.function_queries[620].get_mut(&inp[..]) { debug_assert_eq!(result.output, &__ret[..]); if !unconstrained { *result.multiplicity += G::ONE; } } else { record.function_queries[620].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained)); }; return Ok(__ret); }, } @@ -52857,8 +52573,8 @@ fn aiur_fn_624( let __v_20: G = G::from_u64(1); let __v_21: G = G::from_u64(1); let __v_22: G = { let __values: [G; 3] = [__v_20, __v_21, __v_21]; let __mq = record.memory_queries.get_mut(&3).ok_or(ExecError::InvalidMemorySize(3))?; if let Some(result) = __mq.get_mut(&__values[..]) { if !unconstrained { *result.multiplicity += G::ONE; } result.output[0] } else { let __ptr = G::from_usize(__mq.len()); __mq.insert(&__values[..], &[__ptr], G::from_bool(!unconstrained)); __ptr } }; - let __ret: [G; OUT_624] = [__v_22]; - if let Some(result) = record.function_queries[624].get_mut(&inp[..]) { debug_assert_eq!(result.output, &__ret[..]); if !unconstrained { *result.multiplicity += G::ONE; } } else { record.function_queries[624].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained)); }; + let __ret: [G; OUT_620] = [__v_22]; + if let Some(result) = record.function_queries[620].get_mut(&inp[..]) { debug_assert_eq!(result.output, &__ret[..]); if !unconstrained { *result.multiplicity += G::ONE; } } else { record.function_queries[620].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained)); }; return Ok(__ret); }, } @@ -52867,23 +52583,23 @@ fn aiur_fn_624( let __v_12: G = G::from_u64(1); let __v_13: G = G::from_u64(1); let __v_14: G = { let __values: [G; 3] = [__v_12, __v_13, __v_13]; let __mq = record.memory_queries.get_mut(&3).ok_or(ExecError::InvalidMemorySize(3))?; if let Some(result) = __mq.get_mut(&__values[..]) { if !unconstrained { *result.multiplicity += G::ONE; } result.output[0] } else { let __ptr = G::from_usize(__mq.len()); __mq.insert(&__values[..], &[__ptr], G::from_bool(!unconstrained)); __ptr } }; - let __ret: [G; OUT_624] = [__v_14]; - if let Some(result) = record.function_queries[624].get_mut(&inp[..]) { debug_assert_eq!(result.output, &__ret[..]); if !unconstrained { *result.multiplicity += G::ONE; } } else { record.function_queries[624].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained)); }; + let __ret: [G; OUT_620] = [__v_14]; + if let Some(result) = record.function_queries[620].get_mut(&inp[..]) { debug_assert_eq!(result.output, &__ret[..]); if !unconstrained { *result.multiplicity += G::ONE; } } else { record.function_queries[620].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained)); }; return Ok(__ret); }, } }) } -const INPUT_SIZE_625: usize = 6; -const IN_625: usize = 6; -const OUT_625: usize = 1; -fn aiur_fn_625( - inp: [G; IN_625], +const INPUT_SIZE_621: usize = 6; +const IN_621: usize = 6; +const OUT_621: usize = 1; +fn aiur_fn_621( + inp: [G; IN_621], record: &mut QueryRecord, io_buffer: &mut IOBuffer, unconstrained: bool, -) -> Result<[G; OUT_625], ExecError> { +) -> Result<[G; OUT_621], ExecError> { stacker::maybe_grow(64 * 1024, 4 * 1024 * 1024, || { let __v_0: G = inp[0]; let __v_1: G = inp[1]; @@ -52894,7 +52610,7 @@ fn aiur_fn_625( let __v_6: G = (__v_3 + __v_4); let __v_7: G = (__v_2 + __v_6); let __v_8: G = (__v_1 + __v_7); - let __r_arr: [G; OUT_586] = { let __args: [G; IN_586] = [__v_0, __v_8]; let __cu = unconstrained; if let Some(result) = record.function_queries[586].get_mut(&__args[..]) { if !__cu && *result.multiplicity == G::ZERO { aiur_fn_586(__args, record, io_buffer, false)? } else { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_586] = unsafe { *(result.output.as_ptr() as *const [G; OUT_586]) }; __ret } } else { aiur_fn_586(__args, record, io_buffer, __cu)? } }; + let __r_arr: [G; OUT_582] = { let __args: [G; IN_582] = [__v_0, __v_8]; let __cu = unconstrained; if let Some(result) = record.function_queries[582].get_mut(&__args[..]) { if !__cu && *result.multiplicity == G::ZERO { aiur_fn_582(__args, record, io_buffer, false)? } else { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_582] = unsafe { *(result.output.as_ptr() as *const [G; OUT_582]) }; __ret } } else { aiur_fn_582(__args, record, io_buffer, __cu)? } }; let __v_9: G = __r_arr[0]; let __loaded: [G; 4] = { let __mq = record.memory_queries.get_mut(&4).ok_or(ExecError::InvalidMemorySize(4))?; let __ptr_u64 = __v_9.as_canonical_u64(); let __ptr_usize = usize::try_from(__ptr_u64).ok().ok_or(ExecError::PointerTooLarge(__ptr_u64))?; let (__args, __mult) = __mq.get_index_mut(__ptr_usize).ok_or(ExecError::UnboundPointer { ptr: __ptr_u64, size: 4 })?; if !unconstrained { *__mult += G::ONE; } let __arr: [G; 4] = __args[..4].try_into().unwrap(); __arr }; let __v_10: G = __loaded[0]; @@ -52906,14 +52622,14 @@ fn aiur_fn_625( let __r_arr: [G; OUT_111] = { let __args: [G; IN_111] = [__v_11]; let __cu = unconstrained; if let Some(result) = record.function_queries[111].get_mut(&__args[..]) { if !__cu && *result.multiplicity == G::ZERO { aiur_fn_111(__args, record, io_buffer, false)? } else { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_111] = unsafe { *(result.output.as_ptr() as *const [G; OUT_111]) }; __ret } } else { aiur_fn_111(__args, record, io_buffer, __cu)? } }; let __v_14: G = __r_arr[0]; let __v_15: G = __r_arr[1]; - let __r_arr: [G; OUT_774] = { let __args: [G; IN_774] = [__v_15, __v_5]; let __cu = unconstrained; if let Some(result) = record.function_queries[774].get_mut(&__args[..]) { if !__cu && *result.multiplicity == G::ZERO { aiur_fn_774(__args, record, io_buffer, false)? } else { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_774] = unsafe { *(result.output.as_ptr() as *const [G; OUT_774]) }; __ret } } else { aiur_fn_774(__args, record, io_buffer, __cu)? } }; + let __r_arr: [G; OUT_770] = { let __args: [G; IN_770] = [__v_15, __v_5]; let __cu = unconstrained; if let Some(result) = record.function_queries[770].get_mut(&__args[..]) { if !__cu && *result.multiplicity == G::ZERO { aiur_fn_770(__args, record, io_buffer, false)? } else { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_770] = unsafe { *(result.output.as_ptr() as *const [G; OUT_770]) }; __ret } } else { aiur_fn_770(__args, record, io_buffer, __cu)? } }; let __v_16: G = __r_arr[0]; let __v_17: G = (__v_2 + __v_3); let __v_18: G = (__v_17 + __v_4); - let __r_arr: [G; OUT_626] = { let __args: [G; IN_626] = [__v_16, __v_18]; let __cu = unconstrained; if let Some(result) = record.function_queries[626].get_mut(&__args[..]) { if !__cu && *result.multiplicity == G::ZERO { aiur_fn_626(__args, record, io_buffer, false)? } else { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_626] = unsafe { *(result.output.as_ptr() as *const [G; OUT_626]) }; __ret } } else { aiur_fn_626(__args, record, io_buffer, __cu)? } }; + let __r_arr: [G; OUT_622] = { let __args: [G; IN_622] = [__v_16, __v_18]; let __cu = unconstrained; if let Some(result) = record.function_queries[622].get_mut(&__args[..]) { if !__cu && *result.multiplicity == G::ZERO { aiur_fn_622(__args, record, io_buffer, false)? } else { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_622] = unsafe { *(result.output.as_ptr() as *const [G; OUT_622]) }; __ret } } else { aiur_fn_622(__args, record, io_buffer, __cu)? } }; let __v_19: G = __r_arr[0]; - let __ret: [G; OUT_625] = [__v_19]; - if let Some(result) = record.function_queries[625].get_mut(&inp[..]) { debug_assert_eq!(result.output, &__ret[..]); if !unconstrained { *result.multiplicity += G::ONE; } } else { record.function_queries[625].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained)); }; + let __ret: [G; OUT_621] = [__v_19]; + if let Some(result) = record.function_queries[621].get_mut(&inp[..]) { debug_assert_eq!(result.output, &__ret[..]); if !unconstrained { *result.multiplicity += G::ONE; } } else { record.function_queries[621].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained)); }; return Ok(__ret); }, _ => { @@ -52923,15 +52639,15 @@ fn aiur_fn_625( }) } -const INPUT_SIZE_626: usize = 2; -const IN_626: usize = 2; -const OUT_626: usize = 1; -fn aiur_fn_626( - inp: [G; IN_626], +const INPUT_SIZE_622: usize = 2; +const IN_622: usize = 2; +const OUT_622: usize = 1; +fn aiur_fn_622( + inp: [G; IN_622], record: &mut QueryRecord, io_buffer: &mut IOBuffer, unconstrained: bool, -) -> Result<[G; OUT_626], ExecError> { +) -> Result<[G; OUT_622], ExecError> { stacker::maybe_grow(64 * 1024, 4 * 1024 * 1024, || { let __v_0: G = inp[0]; let __v_1: G = inp[1]; @@ -52944,13 +52660,13 @@ fn aiur_fn_626( let __v_5: G = G::from_u64(1); let __v_6: G = G::from_u64(1); let __v_7: G = { let __values: [G; 3] = [__v_5, __v_6, __v_6]; let __mq = record.memory_queries.get_mut(&3).ok_or(ExecError::InvalidMemorySize(3))?; if let Some(result) = __mq.get_mut(&__values[..]) { if !unconstrained { *result.multiplicity += G::ONE; } result.output[0] } else { let __ptr = G::from_usize(__mq.len()); __mq.insert(&__values[..], &[__ptr], G::from_bool(!unconstrained)); __ptr } }; - let __ret: [G; OUT_626] = [__v_7]; - if let Some(result) = record.function_queries[626].get_mut(&inp[..]) { debug_assert_eq!(result.output, &__ret[..]); if !unconstrained { *result.multiplicity += G::ONE; } } else { record.function_queries[626].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained)); }; + let __ret: [G; OUT_622] = [__v_7]; + if let Some(result) = record.function_queries[622].get_mut(&inp[..]) { debug_assert_eq!(result.output, &__ret[..]); if !unconstrained { *result.multiplicity += G::ONE; } } else { record.function_queries[622].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained)); }; return Ok(__ret); }, 0u64 => { let __v_5: G = G::from_u64(0); - let __r_arr: [G; OUT_347] = { let __args: [G; IN_347] = [__v_3, __v_5, __v_1]; let __cu = unconstrained; if let Some(result) = record.function_queries[347].get_mut(&__args[..]) { if !__cu && *result.multiplicity == G::ZERO { aiur_fn_347(__args, record, io_buffer, false)? } else { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_347] = unsafe { *(result.output.as_ptr() as *const [G; OUT_347]) }; __ret } } else { aiur_fn_347(__args, record, io_buffer, __cu)? } }; + let __r_arr: [G; OUT_343] = { let __args: [G; IN_343] = [__v_3, __v_5, __v_1]; let __cu = unconstrained; if let Some(result) = record.function_queries[343].get_mut(&__args[..]) { if !__cu && *result.multiplicity == G::ZERO { aiur_fn_343(__args, record, io_buffer, false)? } else { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_343] = unsafe { *(result.output.as_ptr() as *const [G; OUT_343]) }; __ret } } else { aiur_fn_343(__args, record, io_buffer, __cu)? } }; let __v_6: G = __r_arr[0]; let __v_7: G = G::from_u64(0); if (__v_6 != __v_7) { @@ -52958,13 +52674,13 @@ fn aiur_fn_626( } let __v_8: G = G::from_u64(0); let __v_9: G = G::from_u64(0); - let __r_arr: [G; OUT_363] = { let __args: [G; IN_363] = [__v_3, __v_1, __v_9]; let __cu = unconstrained; if let Some(result) = record.function_queries[363].get_mut(&__args[..]) { if !__cu && *result.multiplicity == G::ZERO { aiur_fn_363(__args, record, io_buffer, false)? } else { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_363] = unsafe { *(result.output.as_ptr() as *const [G; OUT_363]) }; __ret } } else { aiur_fn_363(__args, record, io_buffer, __cu)? } }; + let __r_arr: [G; OUT_359] = { let __args: [G; IN_359] = [__v_3, __v_1, __v_9]; let __cu = unconstrained; if let Some(result) = record.function_queries[359].get_mut(&__args[..]) { if !__cu && *result.multiplicity == G::ZERO { aiur_fn_359(__args, record, io_buffer, false)? } else { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_359] = unsafe { *(result.output.as_ptr() as *const [G; OUT_359]) }; __ret } } else { aiur_fn_359(__args, record, io_buffer, __cu)? } }; let __v_10: G = __r_arr[0]; - let __r_arr: [G; OUT_626] = { let __args: [G; IN_626] = [__v_4, __v_1]; let __cu = unconstrained; if let Some(result) = record.function_queries[626].get_mut(&__args[..]) { if !__cu && *result.multiplicity == G::ZERO { aiur_fn_626(__args, record, io_buffer, false)? } else { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_626] = unsafe { *(result.output.as_ptr() as *const [G; OUT_626]) }; __ret } } else { aiur_fn_626(__args, record, io_buffer, __cu)? } }; + let __r_arr: [G; OUT_622] = { let __args: [G; IN_622] = [__v_4, __v_1]; let __cu = unconstrained; if let Some(result) = record.function_queries[622].get_mut(&__args[..]) { if !__cu && *result.multiplicity == G::ZERO { aiur_fn_622(__args, record, io_buffer, false)? } else { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_622] = unsafe { *(result.output.as_ptr() as *const [G; OUT_622]) }; __ret } } else { aiur_fn_622(__args, record, io_buffer, __cu)? } }; let __v_11: G = __r_arr[0]; let __v_12: G = { let __values: [G; 3] = [__v_8, __v_10, __v_11]; let __mq = record.memory_queries.get_mut(&3).ok_or(ExecError::InvalidMemorySize(3))?; if let Some(result) = __mq.get_mut(&__values[..]) { if !unconstrained { *result.multiplicity += G::ONE; } result.output[0] } else { let __ptr = G::from_usize(__mq.len()); __mq.insert(&__values[..], &[__ptr], G::from_bool(!unconstrained)); __ptr } }; - let __ret: [G; OUT_626] = [__v_12]; - if let Some(result) = record.function_queries[626].get_mut(&inp[..]) { debug_assert_eq!(result.output, &__ret[..]); if !unconstrained { *result.multiplicity += G::ONE; } } else { record.function_queries[626].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained)); }; + let __ret: [G; OUT_622] = [__v_12]; + if let Some(result) = record.function_queries[622].get_mut(&inp[..]) { debug_assert_eq!(result.output, &__ret[..]); if !unconstrained { *result.multiplicity += G::ONE; } } else { record.function_queries[622].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained)); }; return Ok(__ret); }, _ => { @@ -52974,15 +52690,15 @@ fn aiur_fn_626( }) } -const INPUT_SIZE_627: usize = 3; -const IN_627: usize = 3; -const OUT_627: usize = 1; -fn aiur_fn_627( - inp: [G; IN_627], +const INPUT_SIZE_623: usize = 3; +const IN_623: usize = 3; +const OUT_623: usize = 1; +fn aiur_fn_623( + inp: [G; IN_623], record: &mut QueryRecord, io_buffer: &mut IOBuffer, unconstrained: bool, -) -> Result<[G; OUT_627], ExecError> { +) -> Result<[G; OUT_623], ExecError> { stacker::maybe_grow(64 * 1024, 4 * 1024 * 1024, || { let __v_0: G = inp[0]; let __v_1: G = inp[1]; @@ -52993,8 +52709,8 @@ fn aiur_fn_627( let __v_4: G = G::from_u64(1); let __v_5: G = G::from_u64(1); let __v_6: G = { let __values: [G; 3] = [__v_4, __v_5, __v_5]; let __mq = record.memory_queries.get_mut(&3).ok_or(ExecError::InvalidMemorySize(3))?; if let Some(result) = __mq.get_mut(&__values[..]) { if !unconstrained { *result.multiplicity += G::ONE; } result.output[0] } else { let __ptr = G::from_usize(__mq.len()); __mq.insert(&__values[..], &[__ptr], G::from_bool(!unconstrained)); __ptr } }; - let __ret: [G; OUT_627] = [__v_6]; - if let Some(result) = record.function_queries[627].get_mut(&inp[..]) { debug_assert_eq!(result.output, &__ret[..]); if !unconstrained { *result.multiplicity += G::ONE; } } else { record.function_queries[627].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained)); }; + let __ret: [G; OUT_623] = [__v_6]; + if let Some(result) = record.function_queries[623].get_mut(&inp[..]) { debug_assert_eq!(result.output, &__ret[..]); if !unconstrained { *result.multiplicity += G::ONE; } } else { record.function_queries[623].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained)); }; return Ok(__ret); }, _ => { @@ -53005,30 +52721,30 @@ fn aiur_fn_627( let __v_8: G = { let __values: [G; 3] = [__v_5, __v_6, __v_7]; let __mq = record.memory_queries.get_mut(&3).ok_or(ExecError::InvalidMemorySize(3))?; if let Some(result) = __mq.get_mut(&__values[..]) { if !unconstrained { *result.multiplicity += G::ONE; } result.output[0] } else { let __ptr = G::from_usize(__mq.len()); __mq.insert(&__values[..], &[__ptr], G::from_bool(!unconstrained)); __ptr } }; let __v_9: G = G::from_u64(1); let __v_10: G = (__v_2 + __v_9); - let __r_arr: [G; OUT_627] = { let __args: [G; IN_627] = [__v_0, __v_1, __v_10]; let __cu = unconstrained; if let Some(result) = record.function_queries[627].get_mut(&__args[..]) { if !__cu && *result.multiplicity == G::ZERO { aiur_fn_627(__args, record, io_buffer, false)? } else { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_627] = unsafe { *(result.output.as_ptr() as *const [G; OUT_627]) }; __ret } } else { aiur_fn_627(__args, record, io_buffer, __cu)? } }; + let __r_arr: [G; OUT_623] = { let __args: [G; IN_623] = [__v_0, __v_1, __v_10]; let __cu = unconstrained; if let Some(result) = record.function_queries[623].get_mut(&__args[..]) { if !__cu && *result.multiplicity == G::ZERO { aiur_fn_623(__args, record, io_buffer, false)? } else { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_623] = unsafe { *(result.output.as_ptr() as *const [G; OUT_623]) }; __ret } } else { aiur_fn_623(__args, record, io_buffer, __cu)? } }; let __v_11: G = __r_arr[0]; let __v_12: G = { let __values: [G; 3] = [__v_4, __v_8, __v_11]; let __mq = record.memory_queries.get_mut(&3).ok_or(ExecError::InvalidMemorySize(3))?; if let Some(result) = __mq.get_mut(&__values[..]) { if !unconstrained { *result.multiplicity += G::ONE; } result.output[0] } else { let __ptr = G::from_usize(__mq.len()); __mq.insert(&__values[..], &[__ptr], G::from_bool(!unconstrained)); __ptr } }; - let __ret: [G; OUT_627] = [__v_12]; - if let Some(result) = record.function_queries[627].get_mut(&inp[..]) { debug_assert_eq!(result.output, &__ret[..]); if !unconstrained { *result.multiplicity += G::ONE; } } else { record.function_queries[627].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained)); }; + let __ret: [G; OUT_623] = [__v_12]; + if let Some(result) = record.function_queries[623].get_mut(&inp[..]) { debug_assert_eq!(result.output, &__ret[..]); if !unconstrained { *result.multiplicity += G::ONE; } } else { record.function_queries[623].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained)); }; return Ok(__ret); }, } }) } -const INPUT_SIZE_628: usize = 2; -const IN_628: usize = 2; -const OUT_628: usize = 1; -fn aiur_fn_628( - inp: [G; IN_628], +const INPUT_SIZE_624: usize = 2; +const IN_624: usize = 2; +const OUT_624: usize = 1; +fn aiur_fn_624( + inp: [G; IN_624], record: &mut QueryRecord, io_buffer: &mut IOBuffer, unconstrained: bool, -) -> Result<[G; OUT_628], ExecError> { +) -> Result<[G; OUT_624], ExecError> { stacker::maybe_grow(64 * 1024, 4 * 1024 * 1024, || { let __v_0: G = inp[0]; let __v_1: G = inp[1]; - let __r_arr: [G; OUT_282] = { let __args: [G; IN_282] = [__v_0]; let __cu = unconstrained; if let Some(result) = record.function_queries[282].get_mut(&__args[..]) { if !__cu && *result.multiplicity == G::ZERO { aiur_fn_282(__args, record, io_buffer, false)? } else { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_282] = unsafe { *(result.output.as_ptr() as *const [G; OUT_282]) }; __ret } } else { aiur_fn_282(__args, record, io_buffer, __cu)? } }; + let __r_arr: [G; OUT_278] = { let __args: [G; IN_278] = [__v_0]; let __cu = unconstrained; if let Some(result) = record.function_queries[278].get_mut(&__args[..]) { if !__cu && *result.multiplicity == G::ZERO { aiur_fn_278(__args, record, io_buffer, false)? } else { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_278] = unsafe { *(result.output.as_ptr() as *const [G; OUT_278]) }; __ret } } else { aiur_fn_278(__args, record, io_buffer, __cu)? } }; let __v_2: G = __r_arr[0]; let __v_3: G = __r_arr[1]; let __v_4: G = __r_arr[2]; @@ -53082,14 +52798,14 @@ fn aiur_fn_628( match __v_2.as_canonical_u64() { 8u64 => { let __v_50: G = G::from_u64(0); - let __r_arr: [G; OUT_629] = { let __args: [G; IN_629] = [__v_3, __v_3, __v_0, __v_1, __v_50]; let __cu = unconstrained; if let Some(result) = record.function_queries[629].get_mut(&__args[..]) { if !__cu && *result.multiplicity == G::ZERO { aiur_fn_629(__args, record, io_buffer, false)? } else { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_629] = unsafe { *(result.output.as_ptr() as *const [G; OUT_629]) }; __ret } } else { aiur_fn_629(__args, record, io_buffer, __cu)? } }; + let __r_arr: [G; OUT_625] = { let __args: [G; IN_625] = [__v_3, __v_3, __v_0, __v_1, __v_50]; let __cu = unconstrained; if let Some(result) = record.function_queries[625].get_mut(&__args[..]) { if !__cu && *result.multiplicity == G::ZERO { aiur_fn_625(__args, record, io_buffer, false)? } else { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_625] = unsafe { *(result.output.as_ptr() as *const [G; OUT_625]) }; __ret } } else { aiur_fn_625(__args, record, io_buffer, __cu)? } }; let __v_51: G = __r_arr[0]; - let __ret: [G; OUT_628] = [__v_51]; - if let Some(result) = record.function_queries[628].get_mut(&inp[..]) { debug_assert_eq!(result.output, &__ret[..]); if !unconstrained { *result.multiplicity += G::ONE; } } else { record.function_queries[628].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained)); }; + let __ret: [G; OUT_624] = [__v_51]; + if let Some(result) = record.function_queries[624].get_mut(&inp[..]) { debug_assert_eq!(result.output, &__ret[..]); if !unconstrained { *result.multiplicity += G::ONE; } } else { record.function_queries[624].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained)); }; return Ok(__ret); }, _ => { - let __r_arr: [G; OUT_287] = { let __args: [G; IN_287] = [__v_0]; let __cu = unconstrained; if let Some(result) = record.function_queries[287].get_mut(&__args[..]) { if !__cu && *result.multiplicity == G::ZERO { aiur_fn_287(__args, record, io_buffer, false)? } else { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_287] = unsafe { *(result.output.as_ptr() as *const [G; OUT_287]) }; __ret } } else { aiur_fn_287(__args, record, io_buffer, __cu)? } }; + let __r_arr: [G; OUT_283] = { let __args: [G; IN_283] = [__v_0]; let __cu = unconstrained; if let Some(result) = record.function_queries[283].get_mut(&__args[..]) { if !__cu && *result.multiplicity == G::ZERO { aiur_fn_283(__args, record, io_buffer, false)? } else { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_283] = unsafe { *(result.output.as_ptr() as *const [G; OUT_283]) }; __ret } } else { aiur_fn_283(__args, record, io_buffer, __cu)? } }; let __v_50: G = __r_arr[0]; let __loaded: [G; 12] = { let __mq = record.memory_queries.get_mut(&12).ok_or(ExecError::InvalidMemorySize(12))?; let __ptr_u64 = __v_50.as_canonical_u64(); let __ptr_usize = usize::try_from(__ptr_u64).ok().ok_or(ExecError::PointerTooLarge(__ptr_u64))?; let (__args, __mult) = __mq.get_index_mut(__ptr_usize).ok_or(ExecError::UnboundPointer { ptr: __ptr_u64, size: 12 })?; if !unconstrained { *__mult += G::ONE; } let __arr: [G; 12] = __args[..12].try_into().unwrap(); __arr }; let __v_51: G = __loaded[0]; @@ -53107,7 +52823,7 @@ fn aiur_fn_628( match __v_51.as_canonical_u64() { 5u64 => { let __v_63: G = G::from_u64(0); - let __r_arr: [G; OUT_627] = { let __args: [G; IN_627] = [__v_1, __v_52, __v_63]; let __cu = unconstrained; if let Some(result) = record.function_queries[627].get_mut(&__args[..]) { if !__cu && *result.multiplicity == G::ZERO { aiur_fn_627(__args, record, io_buffer, false)? } else { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_627] = unsafe { *(result.output.as_ptr() as *const [G; OUT_627]) }; __ret } } else { aiur_fn_627(__args, record, io_buffer, __cu)? } }; + let __r_arr: [G; OUT_623] = { let __args: [G; IN_623] = [__v_1, __v_52, __v_63]; let __cu = unconstrained; if let Some(result) = record.function_queries[623].get_mut(&__args[..]) { if !__cu && *result.multiplicity == G::ZERO { aiur_fn_623(__args, record, io_buffer, false)? } else { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_623] = unsafe { *(result.output.as_ptr() as *const [G; OUT_623]) }; __ret } } else { aiur_fn_623(__args, record, io_buffer, __cu)? } }; let __v_64: G = __r_arr[0]; let __v_65: G = G::from_u64(0); let __v_66: G = G::from_u64(0); @@ -53118,16 +52834,16 @@ fn aiur_fn_628( let __v_71: G = G::from_u64(1); let __v_72: G = { let __values: [G; 6] = [__v_70, __v_71, __v_71, __v_71, __v_71, __v_71]; let __mq = record.memory_queries.get_mut(&6).ok_or(ExecError::InvalidMemorySize(6))?; if let Some(result) = __mq.get_mut(&__values[..]) { if !unconstrained { *result.multiplicity += G::ONE; } result.output[0] } else { let __ptr = G::from_usize(__mq.len()); __mq.insert(&__values[..], &[__ptr], G::from_bool(!unconstrained)); __ptr } }; let __v_73: G = { let __values: [G; 6] = [__v_65, __v_0, __v_66, __v_69, __v_64, __v_72]; let __mq = record.memory_queries.get_mut(&6).ok_or(ExecError::InvalidMemorySize(6))?; if let Some(result) = __mq.get_mut(&__values[..]) { if !unconstrained { *result.multiplicity += G::ONE; } result.output[0] } else { let __ptr = G::from_usize(__mq.len()); __mq.insert(&__values[..], &[__ptr], G::from_bool(!unconstrained)); __ptr } }; - let __ret: [G; OUT_628] = [__v_73]; - if let Some(result) = record.function_queries[628].get_mut(&inp[..]) { debug_assert_eq!(result.output, &__ret[..]); if !unconstrained { *result.multiplicity += G::ONE; } } else { record.function_queries[628].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained)); }; + let __ret: [G; OUT_624] = [__v_73]; + if let Some(result) = record.function_queries[624].get_mut(&inp[..]) { debug_assert_eq!(result.output, &__ret[..]); if !unconstrained { *result.multiplicity += G::ONE; } } else { record.function_queries[624].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained)); }; return Ok(__ret); }, _ => { let __v_63: G = G::from_u64(1); let __v_64: G = G::from_u64(1); let __v_65: G = { let __values: [G; 6] = [__v_63, __v_64, __v_64, __v_64, __v_64, __v_64]; let __mq = record.memory_queries.get_mut(&6).ok_or(ExecError::InvalidMemorySize(6))?; if let Some(result) = __mq.get_mut(&__values[..]) { if !unconstrained { *result.multiplicity += G::ONE; } result.output[0] } else { let __ptr = G::from_usize(__mq.len()); __mq.insert(&__values[..], &[__ptr], G::from_bool(!unconstrained)); __ptr } }; - let __ret: [G; OUT_628] = [__v_65]; - if let Some(result) = record.function_queries[628].get_mut(&inp[..]) { debug_assert_eq!(result.output, &__ret[..]); if !unconstrained { *result.multiplicity += G::ONE; } } else { record.function_queries[628].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained)); }; + let __ret: [G; OUT_624] = [__v_65]; + if let Some(result) = record.function_queries[624].get_mut(&inp[..]) { debug_assert_eq!(result.output, &__ret[..]); if !unconstrained { *result.multiplicity += G::ONE; } } else { record.function_queries[624].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained)); }; return Ok(__ret); }, } @@ -53138,15 +52854,15 @@ fn aiur_fn_628( }) } -const INPUT_SIZE_629: usize = 5; -const IN_629: usize = 5; -const OUT_629: usize = 1; -fn aiur_fn_629( - inp: [G; IN_629], +const INPUT_SIZE_625: usize = 5; +const IN_625: usize = 5; +const OUT_625: usize = 1; +fn aiur_fn_625( + inp: [G; IN_625], record: &mut QueryRecord, io_buffer: &mut IOBuffer, unconstrained: bool, -) -> Result<[G; OUT_629], ExecError> { +) -> Result<[G; OUT_625], ExecError> { stacker::maybe_grow(64 * 1024, 4 * 1024 * 1024, || { let __v_0: G = inp[0]; let __v_1: G = inp[1]; @@ -53206,16 +52922,16 @@ fn aiur_fn_629( let __v_52: G = G::from_u64(1); let __v_53: G = G::from_u64(1); let __v_54: G = { let __values: [G; 6] = [__v_52, __v_53, __v_53, __v_53, __v_53, __v_53]; let __mq = record.memory_queries.get_mut(&6).ok_or(ExecError::InvalidMemorySize(6))?; if let Some(result) = __mq.get_mut(&__values[..]) { if !unconstrained { *result.multiplicity += G::ONE; } result.output[0] } else { let __ptr = G::from_usize(__mq.len()); __mq.insert(&__values[..], &[__ptr], G::from_bool(!unconstrained)); __ptr } }; - let __ret: [G; OUT_629] = [__v_54]; - if let Some(result) = record.function_queries[629].get_mut(&inp[..]) { debug_assert_eq!(result.output, &__ret[..]); if !unconstrained { *result.multiplicity += G::ONE; } } else { record.function_queries[629].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained)); }; + let __ret: [G; OUT_625] = [__v_54]; + if let Some(result) = record.function_queries[625].get_mut(&inp[..]) { debug_assert_eq!(result.output, &__ret[..]); if !unconstrained { *result.multiplicity += G::ONE; } } else { record.function_queries[625].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained)); }; return Ok(__ret); }, 0u64 => { match __v_6.as_canonical_u64() { 1u64 => { - let __r_arr: [G; OUT_294] = { let __args: [G; IN_294] = [__v_0, __v_2, __v_4]; let __cu = unconstrained; if let Some(result) = record.function_queries[294].get_mut(&__args[..]) { if !__cu && *result.multiplicity == G::ZERO { aiur_fn_294(__args, record, io_buffer, false)? } else { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_294] = unsafe { *(result.output.as_ptr() as *const [G; OUT_294]) }; __ret } } else { aiur_fn_294(__args, record, io_buffer, __cu)? } }; + let __r_arr: [G; OUT_290] = { let __args: [G; IN_290] = [__v_0, __v_2, __v_4]; let __cu = unconstrained; if let Some(result) = record.function_queries[290].get_mut(&__args[..]) { if !__cu && *result.multiplicity == G::ZERO { aiur_fn_290(__args, record, io_buffer, false)? } else { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_290] = unsafe { *(result.output.as_ptr() as *const [G; OUT_290]) }; __ret } } else { aiur_fn_290(__args, record, io_buffer, __cu)? } }; let __v_52: G = __r_arr[0]; - let __r_arr: [G; OUT_289] = { let __args: [G; IN_289] = [__v_2, __v_4]; let __cu = unconstrained; if let Some(result) = record.function_queries[289].get_mut(&__args[..]) { if !__cu && *result.multiplicity == G::ZERO { aiur_fn_289(__args, record, io_buffer, false)? } else { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_289] = unsafe { *(result.output.as_ptr() as *const [G; OUT_289]) }; __ret } } else { aiur_fn_289(__args, record, io_buffer, __cu)? } }; + let __r_arr: [G; OUT_285] = { let __args: [G; IN_285] = [__v_2, __v_4]; let __cu = unconstrained; if let Some(result) = record.function_queries[285].get_mut(&__args[..]) { if !__cu && *result.multiplicity == G::ZERO { aiur_fn_285(__args, record, io_buffer, false)? } else { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_285] = unsafe { *(result.output.as_ptr() as *const [G; OUT_285]) }; __ret } } else { aiur_fn_285(__args, record, io_buffer, __cu)? } }; let __v_53: G = __r_arr[0]; let __loaded: [G; 12] = { let __mq = record.memory_queries.get_mut(&12).ok_or(ExecError::InvalidMemorySize(12))?; let __ptr_u64 = __v_53.as_canonical_u64(); let __ptr_usize = usize::try_from(__ptr_u64).ok().ok_or(ExecError::PointerTooLarge(__ptr_u64))?; let (__args, __mult) = __mq.get_index_mut(__ptr_usize).ok_or(ExecError::UnboundPointer { ptr: __ptr_u64, size: 12 })?; if !unconstrained { *__mult += G::ONE; } let __arr: [G; 12] = __args[..12].try_into().unwrap(); __arr }; let __v_54: G = __loaded[0]; @@ -53242,7 +52958,7 @@ fn aiur_fn_629( }; let __v_66: G = __mc_out___mc_0[0]; let __v_67: G = G::from_u64(0); - let __r_arr: [G; OUT_627] = { let __args: [G; IN_627] = [__v_3, __v_66, __v_67]; let __cu = unconstrained; if let Some(result) = record.function_queries[627].get_mut(&__args[..]) { if !__cu && *result.multiplicity == G::ZERO { aiur_fn_627(__args, record, io_buffer, false)? } else { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_627] = unsafe { *(result.output.as_ptr() as *const [G; OUT_627]) }; __ret } } else { aiur_fn_627(__args, record, io_buffer, __cu)? } }; + let __r_arr: [G; OUT_623] = { let __args: [G; IN_623] = [__v_3, __v_66, __v_67]; let __cu = unconstrained; if let Some(result) = record.function_queries[623].get_mut(&__args[..]) { if !__cu && *result.multiplicity == G::ZERO { aiur_fn_623(__args, record, io_buffer, false)? } else { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_623] = unsafe { *(result.output.as_ptr() as *const [G; OUT_623]) }; __ret } } else { aiur_fn_623(__args, record, io_buffer, __cu)? } }; let __v_68: G = __r_arr[0]; let __v_69: G = G::from_u64(0); let __v_70: G = G::from_u64(0); @@ -53251,20 +52967,20 @@ fn aiur_fn_629( let __v_73: G = { let __values: [G; 3] = [__v_71, __v_72, __v_72]; let __mq = record.memory_queries.get_mut(&3).ok_or(ExecError::InvalidMemorySize(3))?; if let Some(result) = __mq.get_mut(&__values[..]) { if !unconstrained { *result.multiplicity += G::ONE; } result.output[0] } else { let __ptr = G::from_usize(__mq.len()); __mq.insert(&__values[..], &[__ptr], G::from_bool(!unconstrained)); __ptr } }; let __v_74: G = G::from_u64(1); let __v_75: G = (__v_4 + __v_74); - let __r_arr: [G; OUT_629] = { let __args: [G; IN_629] = [__v_0, __v_51, __v_2, __v_3, __v_75]; let __cu = unconstrained; if let Some(result) = record.function_queries[629].get_mut(&__args[..]) { if !__cu && *result.multiplicity == G::ZERO { aiur_fn_629(__args, record, io_buffer, false)? } else { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_629] = unsafe { *(result.output.as_ptr() as *const [G; OUT_629]) }; __ret } } else { aiur_fn_629(__args, record, io_buffer, __cu)? } }; + let __r_arr: [G; OUT_625] = { let __args: [G; IN_625] = [__v_0, __v_51, __v_2, __v_3, __v_75]; let __cu = unconstrained; if let Some(result) = record.function_queries[625].get_mut(&__args[..]) { if !__cu && *result.multiplicity == G::ZERO { aiur_fn_625(__args, record, io_buffer, false)? } else { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_625] = unsafe { *(result.output.as_ptr() as *const [G; OUT_625]) }; __ret } } else { aiur_fn_625(__args, record, io_buffer, __cu)? } }; let __v_76: G = __r_arr[0]; let __v_77: G = { let __values: [G; 6] = [__v_69, __v_52, __v_70, __v_73, __v_68, __v_76]; let __mq = record.memory_queries.get_mut(&6).ok_or(ExecError::InvalidMemorySize(6))?; if let Some(result) = __mq.get_mut(&__values[..]) { if !unconstrained { *result.multiplicity += G::ONE; } result.output[0] } else { let __ptr = G::from_usize(__mq.len()); __mq.insert(&__values[..], &[__ptr], G::from_bool(!unconstrained)); __ptr } }; - let __ret: [G; OUT_629] = [__v_77]; - if let Some(result) = record.function_queries[629].get_mut(&inp[..]) { debug_assert_eq!(result.output, &__ret[..]); if !unconstrained { *result.multiplicity += G::ONE; } } else { record.function_queries[629].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained)); }; + let __ret: [G; OUT_625] = [__v_77]; + if let Some(result) = record.function_queries[625].get_mut(&inp[..]) { debug_assert_eq!(result.output, &__ret[..]); if !unconstrained { *result.multiplicity += G::ONE; } } else { record.function_queries[625].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained)); }; return Ok(__ret); }, _ => { let __v_52: G = G::from_u64(1); let __v_53: G = (__v_4 + __v_52); - let __r_arr: [G; OUT_629] = { let __args: [G; IN_629] = [__v_0, __v_51, __v_2, __v_3, __v_53]; let __cu = unconstrained; if let Some(result) = record.function_queries[629].get_mut(&__args[..]) { if !__cu && *result.multiplicity == G::ZERO { aiur_fn_629(__args, record, io_buffer, false)? } else { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_629] = unsafe { *(result.output.as_ptr() as *const [G; OUT_629]) }; __ret } } else { aiur_fn_629(__args, record, io_buffer, __cu)? } }; + let __r_arr: [G; OUT_625] = { let __args: [G; IN_625] = [__v_0, __v_51, __v_2, __v_3, __v_53]; let __cu = unconstrained; if let Some(result) = record.function_queries[625].get_mut(&__args[..]) { if !__cu && *result.multiplicity == G::ZERO { aiur_fn_625(__args, record, io_buffer, false)? } else { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_625] = unsafe { *(result.output.as_ptr() as *const [G; OUT_625]) }; __ret } } else { aiur_fn_625(__args, record, io_buffer, __cu)? } }; let __v_54: G = __r_arr[0]; - let __ret: [G; OUT_629] = [__v_54]; - if let Some(result) = record.function_queries[629].get_mut(&inp[..]) { debug_assert_eq!(result.output, &__ret[..]); if !unconstrained { *result.multiplicity += G::ONE; } } else { record.function_queries[629].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained)); }; + let __ret: [G; OUT_625] = [__v_54]; + if let Some(result) = record.function_queries[625].get_mut(&inp[..]) { debug_assert_eq!(result.output, &__ret[..]); if !unconstrained { *result.multiplicity += G::ONE; } } else { record.function_queries[625].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained)); }; return Ok(__ret); }, } @@ -53276,15 +52992,15 @@ fn aiur_fn_629( }) } -const INPUT_SIZE_630: usize = 3; -const IN_630: usize = 3; -const OUT_630: usize = 1; -fn aiur_fn_630( - inp: [G; IN_630], +const INPUT_SIZE_626: usize = 3; +const IN_626: usize = 3; +const OUT_626: usize = 1; +fn aiur_fn_626( + inp: [G; IN_626], record: &mut QueryRecord, io_buffer: &mut IOBuffer, unconstrained: bool, -) -> Result<[G; OUT_630], ExecError> { +) -> Result<[G; OUT_626], ExecError> { stacker::maybe_grow(64 * 1024, 4 * 1024 * 1024, || { let __v_0: G = inp[0]; let __v_1: G = inp[1]; @@ -53299,8 +53015,8 @@ fn aiur_fn_630( match __v_3.as_canonical_u64() { 1u64 => { let __v_9: G = G::from_u64(0); - let __ret: [G; OUT_630] = [__v_9]; - if let Some(result) = record.function_queries[630].get_mut(&inp[..]) { debug_assert_eq!(result.output, &__ret[..]); if !unconstrained { *result.multiplicity += G::ONE; } } else { record.function_queries[630].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained)); }; + let __ret: [G; OUT_626] = [__v_9]; + if let Some(result) = record.function_queries[626].get_mut(&inp[..]) { debug_assert_eq!(result.output, &__ret[..]); if !unconstrained { *result.multiplicity += G::ONE; } } else { record.function_queries[626].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained)); }; return Ok(__ret); }, 0u64 => { @@ -53310,38 +53026,38 @@ fn aiur_fn_630( let __v_9: G = __r_arr[0]; match __v_9.as_canonical_u64() { 1u64 => { - let __r_arr: [G; OUT_633] = { let __args: [G; IN_633] = [__v_6, __v_2]; let __cu = unconstrained; if let Some(result) = record.function_queries[633].get_mut(&__args[..]) { if !__cu && *result.multiplicity == G::ZERO { aiur_fn_633(__args, record, io_buffer, false)? } else { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_633] = unsafe { *(result.output.as_ptr() as *const [G; OUT_633]) }; __ret } } else { aiur_fn_633(__args, record, io_buffer, __cu)? } }; + let __r_arr: [G; OUT_629] = { let __args: [G; IN_629] = [__v_6, __v_2]; let __cu = unconstrained; if let Some(result) = record.function_queries[629].get_mut(&__args[..]) { if !__cu && *result.multiplicity == G::ZERO { aiur_fn_629(__args, record, io_buffer, false)? } else { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_629] = unsafe { *(result.output.as_ptr() as *const [G; OUT_629]) }; __ret } } else { aiur_fn_629(__args, record, io_buffer, __cu)? } }; let __v_10: G = __r_arr[0]; match __v_10.as_canonical_u64() { 1u64 => { let __v_11: G = G::from_u64(1); - let __ret: [G; OUT_630] = [__v_11]; - if let Some(result) = record.function_queries[630].get_mut(&inp[..]) { debug_assert_eq!(result.output, &__ret[..]); if !unconstrained { *result.multiplicity += G::ONE; } } else { record.function_queries[630].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained)); }; + let __ret: [G; OUT_626] = [__v_11]; + if let Some(result) = record.function_queries[626].get_mut(&inp[..]) { debug_assert_eq!(result.output, &__ret[..]); if !unconstrained { *result.multiplicity += G::ONE; } } else { record.function_queries[626].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained)); }; return Ok(__ret); }, _ => { - let __r_arr: [G; OUT_630] = { let __args: [G; IN_630] = [__v_8, __v_1, __v_2]; let __cu = unconstrained; if let Some(result) = record.function_queries[630].get_mut(&__args[..]) { if !__cu && *result.multiplicity == G::ZERO { aiur_fn_630(__args, record, io_buffer, false)? } else { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_630] = unsafe { *(result.output.as_ptr() as *const [G; OUT_630]) }; __ret } } else { aiur_fn_630(__args, record, io_buffer, __cu)? } }; + let __r_arr: [G; OUT_626] = { let __args: [G; IN_626] = [__v_8, __v_1, __v_2]; let __cu = unconstrained; if let Some(result) = record.function_queries[626].get_mut(&__args[..]) { if !__cu && *result.multiplicity == G::ZERO { aiur_fn_626(__args, record, io_buffer, false)? } else { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_626] = unsafe { *(result.output.as_ptr() as *const [G; OUT_626]) }; __ret } } else { aiur_fn_626(__args, record, io_buffer, __cu)? } }; let __v_11: G = __r_arr[0]; - let __ret: [G; OUT_630] = [__v_11]; - if let Some(result) = record.function_queries[630].get_mut(&inp[..]) { debug_assert_eq!(result.output, &__ret[..]); if !unconstrained { *result.multiplicity += G::ONE; } } else { record.function_queries[630].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained)); }; + let __ret: [G; OUT_626] = [__v_11]; + if let Some(result) = record.function_queries[626].get_mut(&inp[..]) { debug_assert_eq!(result.output, &__ret[..]); if !unconstrained { *result.multiplicity += G::ONE; } } else { record.function_queries[626].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained)); }; return Ok(__ret); }, } }, _ => { - let __r_arr: [G; OUT_630] = { let __args: [G; IN_630] = [__v_8, __v_1, __v_2]; let __cu = unconstrained; if let Some(result) = record.function_queries[630].get_mut(&__args[..]) { if !__cu && *result.multiplicity == G::ZERO { aiur_fn_630(__args, record, io_buffer, false)? } else { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_630] = unsafe { *(result.output.as_ptr() as *const [G; OUT_630]) }; __ret } } else { aiur_fn_630(__args, record, io_buffer, __cu)? } }; + let __r_arr: [G; OUT_626] = { let __args: [G; IN_626] = [__v_8, __v_1, __v_2]; let __cu = unconstrained; if let Some(result) = record.function_queries[626].get_mut(&__args[..]) { if !__cu && *result.multiplicity == G::ZERO { aiur_fn_626(__args, record, io_buffer, false)? } else { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_626] = unsafe { *(result.output.as_ptr() as *const [G; OUT_626]) }; __ret } } else { aiur_fn_626(__args, record, io_buffer, __cu)? } }; let __v_10: G = __r_arr[0]; - let __ret: [G; OUT_630] = [__v_10]; - if let Some(result) = record.function_queries[630].get_mut(&inp[..]) { debug_assert_eq!(result.output, &__ret[..]); if !unconstrained { *result.multiplicity += G::ONE; } } else { record.function_queries[630].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained)); }; + let __ret: [G; OUT_626] = [__v_10]; + if let Some(result) = record.function_queries[626].get_mut(&inp[..]) { debug_assert_eq!(result.output, &__ret[..]); if !unconstrained { *result.multiplicity += G::ONE; } } else { record.function_queries[626].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained)); }; return Ok(__ret); }, } }, _ => { - let __r_arr: [G; OUT_630] = { let __args: [G; IN_630] = [__v_8, __v_1, __v_2]; let __cu = unconstrained; if let Some(result) = record.function_queries[630].get_mut(&__args[..]) { if !__cu && *result.multiplicity == G::ZERO { aiur_fn_630(__args, record, io_buffer, false)? } else { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_630] = unsafe { *(result.output.as_ptr() as *const [G; OUT_630]) }; __ret } } else { aiur_fn_630(__args, record, io_buffer, __cu)? } }; + let __r_arr: [G; OUT_626] = { let __args: [G; IN_626] = [__v_8, __v_1, __v_2]; let __cu = unconstrained; if let Some(result) = record.function_queries[626].get_mut(&__args[..]) { if !__cu && *result.multiplicity == G::ZERO { aiur_fn_626(__args, record, io_buffer, false)? } else { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_626] = unsafe { *(result.output.as_ptr() as *const [G; OUT_626]) }; __ret } } else { aiur_fn_626(__args, record, io_buffer, __cu)? } }; let __v_9: G = __r_arr[0]; - let __ret: [G; OUT_630] = [__v_9]; - if let Some(result) = record.function_queries[630].get_mut(&inp[..]) { debug_assert_eq!(result.output, &__ret[..]); if !unconstrained { *result.multiplicity += G::ONE; } } else { record.function_queries[630].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained)); }; + let __ret: [G; OUT_626] = [__v_9]; + if let Some(result) = record.function_queries[626].get_mut(&inp[..]) { debug_assert_eq!(result.output, &__ret[..]); if !unconstrained { *result.multiplicity += G::ONE; } } else { record.function_queries[626].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained)); }; return Ok(__ret); }, } @@ -53353,15 +53069,15 @@ fn aiur_fn_630( }) } -const INPUT_SIZE_631: usize = 2; -const IN_631: usize = 2; -const OUT_631: usize = 1; -fn aiur_fn_631( - inp: [G; IN_631], +const INPUT_SIZE_627: usize = 2; +const IN_627: usize = 2; +const OUT_627: usize = 1; +fn aiur_fn_627( + inp: [G; IN_627], record: &mut QueryRecord, io_buffer: &mut IOBuffer, unconstrained: bool, -) -> Result<[G; OUT_631], ExecError> { +) -> Result<[G; OUT_627], ExecError> { stacker::maybe_grow(64 * 1024, 4 * 1024 * 1024, || { let __v_0: G = inp[0]; let __v_1: G = inp[1]; @@ -53369,8 +53085,8 @@ fn aiur_fn_631( match __v_2.as_canonical_u64() { 0u64 => { let __v_3: G = G::from_u64(1); - let __ret: [G; OUT_631] = [__v_3]; - if let Some(result) = record.function_queries[631].get_mut(&inp[..]) { debug_assert_eq!(result.output, &__ret[..]); if !unconstrained { *result.multiplicity += G::ONE; } } else { record.function_queries[631].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained)); }; + let __ret: [G; OUT_627] = [__v_3]; + if let Some(result) = record.function_queries[627].get_mut(&inp[..]) { debug_assert_eq!(result.output, &__ret[..]); if !unconstrained { *result.multiplicity += G::ONE; } } else { record.function_queries[627].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained)); }; return Ok(__ret); }, _ => { @@ -53392,22 +53108,22 @@ fn aiur_fn_631( match __v_11.as_canonical_u64() { 0u64 => { let __v_12: G = G::from_u64(1); - let __ret: [G; OUT_631] = [__v_12]; - if let Some(result) = record.function_queries[631].get_mut(&inp[..]) { debug_assert_eq!(result.output, &__ret[..]); if !unconstrained { *result.multiplicity += G::ONE; } } else { record.function_queries[631].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained)); }; + let __ret: [G; OUT_627] = [__v_12]; + if let Some(result) = record.function_queries[627].get_mut(&inp[..]) { debug_assert_eq!(result.output, &__ret[..]); if !unconstrained { *result.multiplicity += G::ONE; } } else { record.function_queries[627].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained)); }; return Ok(__ret); }, _ => { let __v_12: G = G::from_u64(0); - let __ret: [G; OUT_631] = [__v_12]; - if let Some(result) = record.function_queries[631].get_mut(&inp[..]) { debug_assert_eq!(result.output, &__ret[..]); if !unconstrained { *result.multiplicity += G::ONE; } } else { record.function_queries[631].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained)); }; + let __ret: [G; OUT_627] = [__v_12]; + if let Some(result) = record.function_queries[627].get_mut(&inp[..]) { debug_assert_eq!(result.output, &__ret[..]); if !unconstrained { *result.multiplicity += G::ONE; } } else { record.function_queries[627].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained)); }; return Ok(__ret); }, } }, _ => { let __v_11: G = G::from_u64(0); - let __ret: [G; OUT_631] = [__v_11]; - if let Some(result) = record.function_queries[631].get_mut(&inp[..]) { debug_assert_eq!(result.output, &__ret[..]); if !unconstrained { *result.multiplicity += G::ONE; } } else { record.function_queries[631].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained)); }; + let __ret: [G; OUT_627] = [__v_11]; + if let Some(result) = record.function_queries[627].get_mut(&inp[..]) { debug_assert_eq!(result.output, &__ret[..]); if !unconstrained { *result.multiplicity += G::ONE; } } else { record.function_queries[627].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained)); }; return Ok(__ret); }, } @@ -53420,16 +53136,16 @@ fn aiur_fn_631( let __v_10: G = __loaded[3]; match __v_7.as_canonical_u64() { 1u64 => { - let __r_arr: [G; OUT_327] = { let __args: [G; IN_327] = [__v_4, __v_8]; let __cu = unconstrained; if let Some(result) = record.function_queries[327].get_mut(&__args[..]) { if !__cu && *result.multiplicity == G::ZERO { aiur_fn_327(__args, record, io_buffer, false)? } else { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_327] = unsafe { *(result.output.as_ptr() as *const [G; OUT_327]) }; __ret } } else { aiur_fn_327(__args, record, io_buffer, __cu)? } }; + let __r_arr: [G; OUT_323] = { let __args: [G; IN_323] = [__v_4, __v_8]; let __cu = unconstrained; if let Some(result) = record.function_queries[323].get_mut(&__args[..]) { if !__cu && *result.multiplicity == G::ZERO { aiur_fn_323(__args, record, io_buffer, false)? } else { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_323] = unsafe { *(result.output.as_ptr() as *const [G; OUT_323]) }; __ret } } else { aiur_fn_323(__args, record, io_buffer, __cu)? } }; let __v_11: G = __r_arr[0]; - let __ret: [G; OUT_631] = [__v_11]; - if let Some(result) = record.function_queries[631].get_mut(&inp[..]) { debug_assert_eq!(result.output, &__ret[..]); if !unconstrained { *result.multiplicity += G::ONE; } } else { record.function_queries[631].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained)); }; + let __ret: [G; OUT_627] = [__v_11]; + if let Some(result) = record.function_queries[627].get_mut(&inp[..]) { debug_assert_eq!(result.output, &__ret[..]); if !unconstrained { *result.multiplicity += G::ONE; } } else { record.function_queries[627].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained)); }; return Ok(__ret); }, _ => { let __v_11: G = G::from_u64(0); - let __ret: [G; OUT_631] = [__v_11]; - if let Some(result) = record.function_queries[631].get_mut(&inp[..]) { debug_assert_eq!(result.output, &__ret[..]); if !unconstrained { *result.multiplicity += G::ONE; } } else { record.function_queries[631].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained)); }; + let __ret: [G; OUT_627] = [__v_11]; + if let Some(result) = record.function_queries[627].get_mut(&inp[..]) { debug_assert_eq!(result.output, &__ret[..]); if !unconstrained { *result.multiplicity += G::ONE; } } else { record.function_queries[627].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained)); }; return Ok(__ret); }, } @@ -53446,24 +53162,24 @@ fn aiur_fn_631( let __v_11: G = __r_arr[0]; match __v_11.as_canonical_u64() { 1u64 => { - let __r_arr: [G; OUT_632] = { let __args: [G; IN_632] = [__v_5, __v_9]; let __cu = unconstrained; if let Some(result) = record.function_queries[632].get_mut(&__args[..]) { if !__cu && *result.multiplicity == G::ZERO { aiur_fn_632(__args, record, io_buffer, false)? } else { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_632] = unsafe { *(result.output.as_ptr() as *const [G; OUT_632]) }; __ret } } else { aiur_fn_632(__args, record, io_buffer, __cu)? } }; + let __r_arr: [G; OUT_628] = { let __args: [G; IN_628] = [__v_5, __v_9]; let __cu = unconstrained; if let Some(result) = record.function_queries[628].get_mut(&__args[..]) { if !__cu && *result.multiplicity == G::ZERO { aiur_fn_628(__args, record, io_buffer, false)? } else { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_628] = unsafe { *(result.output.as_ptr() as *const [G; OUT_628]) }; __ret } } else { aiur_fn_628(__args, record, io_buffer, __cu)? } }; let __v_12: G = __r_arr[0]; - let __ret: [G; OUT_631] = [__v_12]; - if let Some(result) = record.function_queries[631].get_mut(&inp[..]) { debug_assert_eq!(result.output, &__ret[..]); if !unconstrained { *result.multiplicity += G::ONE; } } else { record.function_queries[631].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained)); }; + let __ret: [G; OUT_627] = [__v_12]; + if let Some(result) = record.function_queries[627].get_mut(&inp[..]) { debug_assert_eq!(result.output, &__ret[..]); if !unconstrained { *result.multiplicity += G::ONE; } } else { record.function_queries[627].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained)); }; return Ok(__ret); }, _ => { let __v_12: G = G::from_u64(0); - let __ret: [G; OUT_631] = [__v_12]; - if let Some(result) = record.function_queries[631].get_mut(&inp[..]) { debug_assert_eq!(result.output, &__ret[..]); if !unconstrained { *result.multiplicity += G::ONE; } } else { record.function_queries[631].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained)); }; + let __ret: [G; OUT_627] = [__v_12]; + if let Some(result) = record.function_queries[627].get_mut(&inp[..]) { debug_assert_eq!(result.output, &__ret[..]); if !unconstrained { *result.multiplicity += G::ONE; } } else { record.function_queries[627].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained)); }; return Ok(__ret); }, } }, _ => { let __v_11: G = G::from_u64(0); - let __ret: [G; OUT_631] = [__v_11]; - if let Some(result) = record.function_queries[631].get_mut(&inp[..]) { debug_assert_eq!(result.output, &__ret[..]); if !unconstrained { *result.multiplicity += G::ONE; } } else { record.function_queries[631].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained)); }; + let __ret: [G; OUT_627] = [__v_11]; + if let Some(result) = record.function_queries[627].get_mut(&inp[..]) { debug_assert_eq!(result.output, &__ret[..]); if !unconstrained { *result.multiplicity += G::ONE; } } else { record.function_queries[627].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained)); }; return Ok(__ret); }, } @@ -53476,28 +53192,28 @@ fn aiur_fn_631( let __v_10: G = __loaded[3]; match __v_7.as_canonical_u64() { 3u64 => { - let __r_arr: [G; OUT_631] = { let __args: [G; IN_631] = [__v_4, __v_8]; let __cu = unconstrained; if let Some(result) = record.function_queries[631].get_mut(&__args[..]) { if !__cu && *result.multiplicity == G::ZERO { aiur_fn_631(__args, record, io_buffer, false)? } else { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_631] = unsafe { *(result.output.as_ptr() as *const [G; OUT_631]) }; __ret } } else { aiur_fn_631(__args, record, io_buffer, __cu)? } }; + let __r_arr: [G; OUT_627] = { let __args: [G; IN_627] = [__v_4, __v_8]; let __cu = unconstrained; if let Some(result) = record.function_queries[627].get_mut(&__args[..]) { if !__cu && *result.multiplicity == G::ZERO { aiur_fn_627(__args, record, io_buffer, false)? } else { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_627] = unsafe { *(result.output.as_ptr() as *const [G; OUT_627]) }; __ret } } else { aiur_fn_627(__args, record, io_buffer, __cu)? } }; let __v_11: G = __r_arr[0]; match __v_11.as_canonical_u64() { 1u64 => { - let __r_arr: [G; OUT_631] = { let __args: [G; IN_631] = [__v_5, __v_9]; let __cu = unconstrained; if let Some(result) = record.function_queries[631].get_mut(&__args[..]) { if !__cu && *result.multiplicity == G::ZERO { aiur_fn_631(__args, record, io_buffer, false)? } else { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_631] = unsafe { *(result.output.as_ptr() as *const [G; OUT_631]) }; __ret } } else { aiur_fn_631(__args, record, io_buffer, __cu)? } }; + let __r_arr: [G; OUT_627] = { let __args: [G; IN_627] = [__v_5, __v_9]; let __cu = unconstrained; if let Some(result) = record.function_queries[627].get_mut(&__args[..]) { if !__cu && *result.multiplicity == G::ZERO { aiur_fn_627(__args, record, io_buffer, false)? } else { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_627] = unsafe { *(result.output.as_ptr() as *const [G; OUT_627]) }; __ret } } else { aiur_fn_627(__args, record, io_buffer, __cu)? } }; let __v_12: G = __r_arr[0]; - let __ret: [G; OUT_631] = [__v_12]; - if let Some(result) = record.function_queries[631].get_mut(&inp[..]) { debug_assert_eq!(result.output, &__ret[..]); if !unconstrained { *result.multiplicity += G::ONE; } } else { record.function_queries[631].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained)); }; + let __ret: [G; OUT_627] = [__v_12]; + if let Some(result) = record.function_queries[627].get_mut(&inp[..]) { debug_assert_eq!(result.output, &__ret[..]); if !unconstrained { *result.multiplicity += G::ONE; } } else { record.function_queries[627].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained)); }; return Ok(__ret); }, _ => { let __v_12: G = G::from_u64(0); - let __ret: [G; OUT_631] = [__v_12]; - if let Some(result) = record.function_queries[631].get_mut(&inp[..]) { debug_assert_eq!(result.output, &__ret[..]); if !unconstrained { *result.multiplicity += G::ONE; } } else { record.function_queries[631].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained)); }; + let __ret: [G; OUT_627] = [__v_12]; + if let Some(result) = record.function_queries[627].get_mut(&inp[..]) { debug_assert_eq!(result.output, &__ret[..]); if !unconstrained { *result.multiplicity += G::ONE; } } else { record.function_queries[627].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained)); }; return Ok(__ret); }, } }, _ => { let __v_11: G = G::from_u64(0); - let __ret: [G; OUT_631] = [__v_11]; - if let Some(result) = record.function_queries[631].get_mut(&inp[..]) { debug_assert_eq!(result.output, &__ret[..]); if !unconstrained { *result.multiplicity += G::ONE; } } else { record.function_queries[631].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained)); }; + let __ret: [G; OUT_627] = [__v_11]; + if let Some(result) = record.function_queries[627].get_mut(&inp[..]) { debug_assert_eq!(result.output, &__ret[..]); if !unconstrained { *result.multiplicity += G::ONE; } } else { record.function_queries[627].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained)); }; return Ok(__ret); }, } @@ -53510,28 +53226,28 @@ fn aiur_fn_631( let __v_10: G = __loaded[3]; match __v_7.as_canonical_u64() { 4u64 => { - let __r_arr: [G; OUT_631] = { let __args: [G; IN_631] = [__v_4, __v_8]; let __cu = unconstrained; if let Some(result) = record.function_queries[631].get_mut(&__args[..]) { if !__cu && *result.multiplicity == G::ZERO { aiur_fn_631(__args, record, io_buffer, false)? } else { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_631] = unsafe { *(result.output.as_ptr() as *const [G; OUT_631]) }; __ret } } else { aiur_fn_631(__args, record, io_buffer, __cu)? } }; + let __r_arr: [G; OUT_627] = { let __args: [G; IN_627] = [__v_4, __v_8]; let __cu = unconstrained; if let Some(result) = record.function_queries[627].get_mut(&__args[..]) { if !__cu && *result.multiplicity == G::ZERO { aiur_fn_627(__args, record, io_buffer, false)? } else { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_627] = unsafe { *(result.output.as_ptr() as *const [G; OUT_627]) }; __ret } } else { aiur_fn_627(__args, record, io_buffer, __cu)? } }; let __v_11: G = __r_arr[0]; match __v_11.as_canonical_u64() { 1u64 => { - let __r_arr: [G; OUT_631] = { let __args: [G; IN_631] = [__v_5, __v_9]; let __cu = unconstrained; if let Some(result) = record.function_queries[631].get_mut(&__args[..]) { if !__cu && *result.multiplicity == G::ZERO { aiur_fn_631(__args, record, io_buffer, false)? } else { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_631] = unsafe { *(result.output.as_ptr() as *const [G; OUT_631]) }; __ret } } else { aiur_fn_631(__args, record, io_buffer, __cu)? } }; + let __r_arr: [G; OUT_627] = { let __args: [G; IN_627] = [__v_5, __v_9]; let __cu = unconstrained; if let Some(result) = record.function_queries[627].get_mut(&__args[..]) { if !__cu && *result.multiplicity == G::ZERO { aiur_fn_627(__args, record, io_buffer, false)? } else { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_627] = unsafe { *(result.output.as_ptr() as *const [G; OUT_627]) }; __ret } } else { aiur_fn_627(__args, record, io_buffer, __cu)? } }; let __v_12: G = __r_arr[0]; - let __ret: [G; OUT_631] = [__v_12]; - if let Some(result) = record.function_queries[631].get_mut(&inp[..]) { debug_assert_eq!(result.output, &__ret[..]); if !unconstrained { *result.multiplicity += G::ONE; } } else { record.function_queries[631].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained)); }; + let __ret: [G; OUT_627] = [__v_12]; + if let Some(result) = record.function_queries[627].get_mut(&inp[..]) { debug_assert_eq!(result.output, &__ret[..]); if !unconstrained { *result.multiplicity += G::ONE; } } else { record.function_queries[627].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained)); }; return Ok(__ret); }, _ => { let __v_12: G = G::from_u64(0); - let __ret: [G; OUT_631] = [__v_12]; - if let Some(result) = record.function_queries[631].get_mut(&inp[..]) { debug_assert_eq!(result.output, &__ret[..]); if !unconstrained { *result.multiplicity += G::ONE; } } else { record.function_queries[631].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained)); }; + let __ret: [G; OUT_627] = [__v_12]; + if let Some(result) = record.function_queries[627].get_mut(&inp[..]) { debug_assert_eq!(result.output, &__ret[..]); if !unconstrained { *result.multiplicity += G::ONE; } } else { record.function_queries[627].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained)); }; return Ok(__ret); }, } }, _ => { let __v_11: G = G::from_u64(0); - let __ret: [G; OUT_631] = [__v_11]; - if let Some(result) = record.function_queries[631].get_mut(&inp[..]) { debug_assert_eq!(result.output, &__ret[..]); if !unconstrained { *result.multiplicity += G::ONE; } } else { record.function_queries[631].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained)); }; + let __ret: [G; OUT_627] = [__v_11]; + if let Some(result) = record.function_queries[627].get_mut(&inp[..]) { debug_assert_eq!(result.output, &__ret[..]); if !unconstrained { *result.multiplicity += G::ONE; } } else { record.function_queries[627].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained)); }; return Ok(__ret); }, } @@ -53544,28 +53260,28 @@ fn aiur_fn_631( let __v_10: G = __loaded[3]; match __v_7.as_canonical_u64() { 5u64 => { - let __r_arr: [G; OUT_631] = { let __args: [G; IN_631] = [__v_4, __v_8]; let __cu = unconstrained; if let Some(result) = record.function_queries[631].get_mut(&__args[..]) { if !__cu && *result.multiplicity == G::ZERO { aiur_fn_631(__args, record, io_buffer, false)? } else { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_631] = unsafe { *(result.output.as_ptr() as *const [G; OUT_631]) }; __ret } } else { aiur_fn_631(__args, record, io_buffer, __cu)? } }; + let __r_arr: [G; OUT_627] = { let __args: [G; IN_627] = [__v_4, __v_8]; let __cu = unconstrained; if let Some(result) = record.function_queries[627].get_mut(&__args[..]) { if !__cu && *result.multiplicity == G::ZERO { aiur_fn_627(__args, record, io_buffer, false)? } else { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_627] = unsafe { *(result.output.as_ptr() as *const [G; OUT_627]) }; __ret } } else { aiur_fn_627(__args, record, io_buffer, __cu)? } }; let __v_11: G = __r_arr[0]; match __v_11.as_canonical_u64() { 1u64 => { - let __r_arr: [G; OUT_631] = { let __args: [G; IN_631] = [__v_5, __v_9]; let __cu = unconstrained; if let Some(result) = record.function_queries[631].get_mut(&__args[..]) { if !__cu && *result.multiplicity == G::ZERO { aiur_fn_631(__args, record, io_buffer, false)? } else { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_631] = unsafe { *(result.output.as_ptr() as *const [G; OUT_631]) }; __ret } } else { aiur_fn_631(__args, record, io_buffer, __cu)? } }; + let __r_arr: [G; OUT_627] = { let __args: [G; IN_627] = [__v_5, __v_9]; let __cu = unconstrained; if let Some(result) = record.function_queries[627].get_mut(&__args[..]) { if !__cu && *result.multiplicity == G::ZERO { aiur_fn_627(__args, record, io_buffer, false)? } else { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_627] = unsafe { *(result.output.as_ptr() as *const [G; OUT_627]) }; __ret } } else { aiur_fn_627(__args, record, io_buffer, __cu)? } }; let __v_12: G = __r_arr[0]; - let __ret: [G; OUT_631] = [__v_12]; - if let Some(result) = record.function_queries[631].get_mut(&inp[..]) { debug_assert_eq!(result.output, &__ret[..]); if !unconstrained { *result.multiplicity += G::ONE; } } else { record.function_queries[631].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained)); }; + let __ret: [G; OUT_627] = [__v_12]; + if let Some(result) = record.function_queries[627].get_mut(&inp[..]) { debug_assert_eq!(result.output, &__ret[..]); if !unconstrained { *result.multiplicity += G::ONE; } } else { record.function_queries[627].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained)); }; return Ok(__ret); }, _ => { let __v_12: G = G::from_u64(0); - let __ret: [G; OUT_631] = [__v_12]; - if let Some(result) = record.function_queries[631].get_mut(&inp[..]) { debug_assert_eq!(result.output, &__ret[..]); if !unconstrained { *result.multiplicity += G::ONE; } } else { record.function_queries[631].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained)); }; + let __ret: [G; OUT_627] = [__v_12]; + if let Some(result) = record.function_queries[627].get_mut(&inp[..]) { debug_assert_eq!(result.output, &__ret[..]); if !unconstrained { *result.multiplicity += G::ONE; } } else { record.function_queries[627].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained)); }; return Ok(__ret); }, } }, _ => { let __v_11: G = G::from_u64(0); - let __ret: [G; OUT_631] = [__v_11]; - if let Some(result) = record.function_queries[631].get_mut(&inp[..]) { debug_assert_eq!(result.output, &__ret[..]); if !unconstrained { *result.multiplicity += G::ONE; } } else { record.function_queries[631].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained)); }; + let __ret: [G; OUT_627] = [__v_11]; + if let Some(result) = record.function_queries[627].get_mut(&inp[..]) { debug_assert_eq!(result.output, &__ret[..]); if !unconstrained { *result.multiplicity += G::ONE; } } else { record.function_queries[627].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained)); }; return Ok(__ret); }, } @@ -53578,40 +53294,40 @@ fn aiur_fn_631( let __v_10: G = __loaded[3]; match __v_7.as_canonical_u64() { 6u64 => { - let __r_arr: [G; OUT_631] = { let __args: [G; IN_631] = [__v_4, __v_8]; let __cu = unconstrained; if let Some(result) = record.function_queries[631].get_mut(&__args[..]) { if !__cu && *result.multiplicity == G::ZERO { aiur_fn_631(__args, record, io_buffer, false)? } else { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_631] = unsafe { *(result.output.as_ptr() as *const [G; OUT_631]) }; __ret } } else { aiur_fn_631(__args, record, io_buffer, __cu)? } }; + let __r_arr: [G; OUT_627] = { let __args: [G; IN_627] = [__v_4, __v_8]; let __cu = unconstrained; if let Some(result) = record.function_queries[627].get_mut(&__args[..]) { if !__cu && *result.multiplicity == G::ZERO { aiur_fn_627(__args, record, io_buffer, false)? } else { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_627] = unsafe { *(result.output.as_ptr() as *const [G; OUT_627]) }; __ret } } else { aiur_fn_627(__args, record, io_buffer, __cu)? } }; let __v_11: G = __r_arr[0]; match __v_11.as_canonical_u64() { 1u64 => { - let __r_arr: [G; OUT_631] = { let __args: [G; IN_631] = [__v_5, __v_9]; let __cu = unconstrained; if let Some(result) = record.function_queries[631].get_mut(&__args[..]) { if !__cu && *result.multiplicity == G::ZERO { aiur_fn_631(__args, record, io_buffer, false)? } else { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_631] = unsafe { *(result.output.as_ptr() as *const [G; OUT_631]) }; __ret } } else { aiur_fn_631(__args, record, io_buffer, __cu)? } }; + let __r_arr: [G; OUT_627] = { let __args: [G; IN_627] = [__v_5, __v_9]; let __cu = unconstrained; if let Some(result) = record.function_queries[627].get_mut(&__args[..]) { if !__cu && *result.multiplicity == G::ZERO { aiur_fn_627(__args, record, io_buffer, false)? } else { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_627] = unsafe { *(result.output.as_ptr() as *const [G; OUT_627]) }; __ret } } else { aiur_fn_627(__args, record, io_buffer, __cu)? } }; let __v_12: G = __r_arr[0]; match __v_12.as_canonical_u64() { 1u64 => { - let __r_arr: [G; OUT_631] = { let __args: [G; IN_631] = [__v_6, __v_10]; let __cu = unconstrained; if let Some(result) = record.function_queries[631].get_mut(&__args[..]) { if !__cu && *result.multiplicity == G::ZERO { aiur_fn_631(__args, record, io_buffer, false)? } else { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_631] = unsafe { *(result.output.as_ptr() as *const [G; OUT_631]) }; __ret } } else { aiur_fn_631(__args, record, io_buffer, __cu)? } }; + let __r_arr: [G; OUT_627] = { let __args: [G; IN_627] = [__v_6, __v_10]; let __cu = unconstrained; if let Some(result) = record.function_queries[627].get_mut(&__args[..]) { if !__cu && *result.multiplicity == G::ZERO { aiur_fn_627(__args, record, io_buffer, false)? } else { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_627] = unsafe { *(result.output.as_ptr() as *const [G; OUT_627]) }; __ret } } else { aiur_fn_627(__args, record, io_buffer, __cu)? } }; let __v_13: G = __r_arr[0]; - let __ret: [G; OUT_631] = [__v_13]; - if let Some(result) = record.function_queries[631].get_mut(&inp[..]) { debug_assert_eq!(result.output, &__ret[..]); if !unconstrained { *result.multiplicity += G::ONE; } } else { record.function_queries[631].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained)); }; + let __ret: [G; OUT_627] = [__v_13]; + if let Some(result) = record.function_queries[627].get_mut(&inp[..]) { debug_assert_eq!(result.output, &__ret[..]); if !unconstrained { *result.multiplicity += G::ONE; } } else { record.function_queries[627].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained)); }; return Ok(__ret); }, _ => { let __v_13: G = G::from_u64(0); - let __ret: [G; OUT_631] = [__v_13]; - if let Some(result) = record.function_queries[631].get_mut(&inp[..]) { debug_assert_eq!(result.output, &__ret[..]); if !unconstrained { *result.multiplicity += G::ONE; } } else { record.function_queries[631].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained)); }; + let __ret: [G; OUT_627] = [__v_13]; + if let Some(result) = record.function_queries[627].get_mut(&inp[..]) { debug_assert_eq!(result.output, &__ret[..]); if !unconstrained { *result.multiplicity += G::ONE; } } else { record.function_queries[627].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained)); }; return Ok(__ret); }, } }, _ => { let __v_12: G = G::from_u64(0); - let __ret: [G; OUT_631] = [__v_12]; - if let Some(result) = record.function_queries[631].get_mut(&inp[..]) { debug_assert_eq!(result.output, &__ret[..]); if !unconstrained { *result.multiplicity += G::ONE; } } else { record.function_queries[631].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained)); }; + let __ret: [G; OUT_627] = [__v_12]; + if let Some(result) = record.function_queries[627].get_mut(&inp[..]) { debug_assert_eq!(result.output, &__ret[..]); if !unconstrained { *result.multiplicity += G::ONE; } } else { record.function_queries[627].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained)); }; return Ok(__ret); }, } }, _ => { let __v_11: G = G::from_u64(0); - let __ret: [G; OUT_631] = [__v_11]; - if let Some(result) = record.function_queries[631].get_mut(&inp[..]) { debug_assert_eq!(result.output, &__ret[..]); if !unconstrained { *result.multiplicity += G::ONE; } } else { record.function_queries[631].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained)); }; + let __ret: [G; OUT_627] = [__v_11]; + if let Some(result) = record.function_queries[627].get_mut(&inp[..]) { debug_assert_eq!(result.output, &__ret[..]); if !unconstrained { *result.multiplicity += G::ONE; } } else { record.function_queries[627].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained)); }; return Ok(__ret); }, } @@ -53624,16 +53340,16 @@ fn aiur_fn_631( let __v_10: G = __loaded[3]; match __v_7.as_canonical_u64() { 7u64 => { - let __r_arr: [G; OUT_340] = { let __args: [G; IN_340] = [__v_4, __v_5, __v_8, __v_9]; let __cu = unconstrained; if let Some(result) = record.function_queries[340].get_mut(&__args[..]) { if !__cu && *result.multiplicity == G::ZERO { aiur_fn_340(__args, record, io_buffer, false)? } else { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_340] = unsafe { *(result.output.as_ptr() as *const [G; OUT_340]) }; __ret } } else { aiur_fn_340(__args, record, io_buffer, __cu)? } }; + let __r_arr: [G; OUT_336] = { let __args: [G; IN_336] = [__v_4, __v_5, __v_8, __v_9]; let __cu = unconstrained; if let Some(result) = record.function_queries[336].get_mut(&__args[..]) { if !__cu && *result.multiplicity == G::ZERO { aiur_fn_336(__args, record, io_buffer, false)? } else { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_336] = unsafe { *(result.output.as_ptr() as *const [G; OUT_336]) }; __ret } } else { aiur_fn_336(__args, record, io_buffer, __cu)? } }; let __v_11: G = __r_arr[0]; - let __ret: [G; OUT_631] = [__v_11]; - if let Some(result) = record.function_queries[631].get_mut(&inp[..]) { debug_assert_eq!(result.output, &__ret[..]); if !unconstrained { *result.multiplicity += G::ONE; } } else { record.function_queries[631].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained)); }; + let __ret: [G; OUT_627] = [__v_11]; + if let Some(result) = record.function_queries[627].get_mut(&inp[..]) { debug_assert_eq!(result.output, &__ret[..]); if !unconstrained { *result.multiplicity += G::ONE; } } else { record.function_queries[627].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained)); }; return Ok(__ret); }, _ => { let __v_11: G = G::from_u64(0); - let __ret: [G; OUT_631] = [__v_11]; - if let Some(result) = record.function_queries[631].get_mut(&inp[..]) { debug_assert_eq!(result.output, &__ret[..]); if !unconstrained { *result.multiplicity += G::ONE; } } else { record.function_queries[631].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained)); }; + let __ret: [G; OUT_627] = [__v_11]; + if let Some(result) = record.function_queries[627].get_mut(&inp[..]) { debug_assert_eq!(result.output, &__ret[..]); if !unconstrained { *result.multiplicity += G::ONE; } } else { record.function_queries[627].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained)); }; return Ok(__ret); }, } @@ -53653,32 +53369,32 @@ fn aiur_fn_631( let __v_12: G = (__v_5 - __v_9); match __v_12.as_canonical_u64() { 0u64 => { - let __r_arr: [G; OUT_631] = { let __args: [G; IN_631] = [__v_6, __v_10]; let __cu = unconstrained; if let Some(result) = record.function_queries[631].get_mut(&__args[..]) { if !__cu && *result.multiplicity == G::ZERO { aiur_fn_631(__args, record, io_buffer, false)? } else { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_631] = unsafe { *(result.output.as_ptr() as *const [G; OUT_631]) }; __ret } } else { aiur_fn_631(__args, record, io_buffer, __cu)? } }; + let __r_arr: [G; OUT_627] = { let __args: [G; IN_627] = [__v_6, __v_10]; let __cu = unconstrained; if let Some(result) = record.function_queries[627].get_mut(&__args[..]) { if !__cu && *result.multiplicity == G::ZERO { aiur_fn_627(__args, record, io_buffer, false)? } else { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_627] = unsafe { *(result.output.as_ptr() as *const [G; OUT_627]) }; __ret } } else { aiur_fn_627(__args, record, io_buffer, __cu)? } }; let __v_13: G = __r_arr[0]; - let __ret: [G; OUT_631] = [__v_13]; - if let Some(result) = record.function_queries[631].get_mut(&inp[..]) { debug_assert_eq!(result.output, &__ret[..]); if !unconstrained { *result.multiplicity += G::ONE; } } else { record.function_queries[631].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained)); }; + let __ret: [G; OUT_627] = [__v_13]; + if let Some(result) = record.function_queries[627].get_mut(&inp[..]) { debug_assert_eq!(result.output, &__ret[..]); if !unconstrained { *result.multiplicity += G::ONE; } } else { record.function_queries[627].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained)); }; return Ok(__ret); }, _ => { let __v_13: G = G::from_u64(0); - let __ret: [G; OUT_631] = [__v_13]; - if let Some(result) = record.function_queries[631].get_mut(&inp[..]) { debug_assert_eq!(result.output, &__ret[..]); if !unconstrained { *result.multiplicity += G::ONE; } } else { record.function_queries[631].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained)); }; + let __ret: [G; OUT_627] = [__v_13]; + if let Some(result) = record.function_queries[627].get_mut(&inp[..]) { debug_assert_eq!(result.output, &__ret[..]); if !unconstrained { *result.multiplicity += G::ONE; } } else { record.function_queries[627].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained)); }; return Ok(__ret); }, } }, _ => { let __v_12: G = G::from_u64(0); - let __ret: [G; OUT_631] = [__v_12]; - if let Some(result) = record.function_queries[631].get_mut(&inp[..]) { debug_assert_eq!(result.output, &__ret[..]); if !unconstrained { *result.multiplicity += G::ONE; } } else { record.function_queries[631].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained)); }; + let __ret: [G; OUT_627] = [__v_12]; + if let Some(result) = record.function_queries[627].get_mut(&inp[..]) { debug_assert_eq!(result.output, &__ret[..]); if !unconstrained { *result.multiplicity += G::ONE; } } else { record.function_queries[627].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained)); }; return Ok(__ret); }, } }, _ => { let __v_11: G = G::from_u64(0); - let __ret: [G; OUT_631] = [__v_11]; - if let Some(result) = record.function_queries[631].get_mut(&inp[..]) { debug_assert_eq!(result.output, &__ret[..]); if !unconstrained { *result.multiplicity += G::ONE; } } else { record.function_queries[631].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained)); }; + let __ret: [G; OUT_627] = [__v_11]; + if let Some(result) = record.function_queries[627].get_mut(&inp[..]) { debug_assert_eq!(result.output, &__ret[..]); if !unconstrained { *result.multiplicity += G::ONE; } } else { record.function_queries[627].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained)); }; return Ok(__ret); }, } @@ -53692,15 +53408,15 @@ fn aiur_fn_631( }) } -const INPUT_SIZE_632: usize = 2; -const IN_632: usize = 2; -const OUT_632: usize = 1; -fn aiur_fn_632( - inp: [G; IN_632], +const INPUT_SIZE_628: usize = 2; +const IN_628: usize = 2; +const OUT_628: usize = 1; +fn aiur_fn_628( + inp: [G; IN_628], record: &mut QueryRecord, io_buffer: &mut IOBuffer, unconstrained: bool, -) -> Result<[G; OUT_632], ExecError> { +) -> Result<[G; OUT_628], ExecError> { stacker::maybe_grow(64 * 1024, 4 * 1024 * 1024, || { let __v_0: G = inp[0]; let __v_1: G = inp[1]; @@ -53717,14 +53433,14 @@ fn aiur_fn_632( match __v_5.as_canonical_u64() { 1u64 => { let __v_8: G = G::from_u64(1); - let __ret: [G; OUT_632] = [__v_8]; - if let Some(result) = record.function_queries[632].get_mut(&inp[..]) { debug_assert_eq!(result.output, &__ret[..]); if !unconstrained { *result.multiplicity += G::ONE; } } else { record.function_queries[632].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained)); }; + let __ret: [G; OUT_628] = [__v_8]; + if let Some(result) = record.function_queries[628].get_mut(&inp[..]) { debug_assert_eq!(result.output, &__ret[..]); if !unconstrained { *result.multiplicity += G::ONE; } } else { record.function_queries[628].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained)); }; return Ok(__ret); }, _ => { let __v_8: G = G::from_u64(0); - let __ret: [G; OUT_632] = [__v_8]; - if let Some(result) = record.function_queries[632].get_mut(&inp[..]) { debug_assert_eq!(result.output, &__ret[..]); if !unconstrained { *result.multiplicity += G::ONE; } } else { record.function_queries[632].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained)); }; + let __ret: [G; OUT_628] = [__v_8]; + if let Some(result) = record.function_queries[628].get_mut(&inp[..]) { debug_assert_eq!(result.output, &__ret[..]); if !unconstrained { *result.multiplicity += G::ONE; } } else { record.function_queries[628].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained)); }; return Ok(__ret); }, } @@ -53737,25 +53453,25 @@ fn aiur_fn_632( match __v_5.as_canonical_u64() { 1u64 => { let __v_8: G = G::from_u64(0); - let __ret: [G; OUT_632] = [__v_8]; - if let Some(result) = record.function_queries[632].get_mut(&inp[..]) { debug_assert_eq!(result.output, &__ret[..]); if !unconstrained { *result.multiplicity += G::ONE; } } else { record.function_queries[632].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained)); }; + let __ret: [G; OUT_628] = [__v_8]; + if let Some(result) = record.function_queries[628].get_mut(&inp[..]) { debug_assert_eq!(result.output, &__ret[..]); if !unconstrained { *result.multiplicity += G::ONE; } } else { record.function_queries[628].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained)); }; return Ok(__ret); }, 0u64 => { - let __r_arr: [G; OUT_327] = { let __args: [G; IN_327] = [__v_3, __v_6]; let __cu = unconstrained; if let Some(result) = record.function_queries[327].get_mut(&__args[..]) { if !__cu && *result.multiplicity == G::ZERO { aiur_fn_327(__args, record, io_buffer, false)? } else { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_327] = unsafe { *(result.output.as_ptr() as *const [G; OUT_327]) }; __ret } } else { aiur_fn_327(__args, record, io_buffer, __cu)? } }; + let __r_arr: [G; OUT_323] = { let __args: [G; IN_323] = [__v_3, __v_6]; let __cu = unconstrained; if let Some(result) = record.function_queries[323].get_mut(&__args[..]) { if !__cu && *result.multiplicity == G::ZERO { aiur_fn_323(__args, record, io_buffer, false)? } else { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_323] = unsafe { *(result.output.as_ptr() as *const [G; OUT_323]) }; __ret } } else { aiur_fn_323(__args, record, io_buffer, __cu)? } }; let __v_8: G = __r_arr[0]; match __v_8.as_canonical_u64() { 1u64 => { - let __r_arr: [G; OUT_632] = { let __args: [G; IN_632] = [__v_4, __v_7]; let __cu = unconstrained; if let Some(result) = record.function_queries[632].get_mut(&__args[..]) { if !__cu && *result.multiplicity == G::ZERO { aiur_fn_632(__args, record, io_buffer, false)? } else { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_632] = unsafe { *(result.output.as_ptr() as *const [G; OUT_632]) }; __ret } } else { aiur_fn_632(__args, record, io_buffer, __cu)? } }; + let __r_arr: [G; OUT_628] = { let __args: [G; IN_628] = [__v_4, __v_7]; let __cu = unconstrained; if let Some(result) = record.function_queries[628].get_mut(&__args[..]) { if !__cu && *result.multiplicity == G::ZERO { aiur_fn_628(__args, record, io_buffer, false)? } else { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_628] = unsafe { *(result.output.as_ptr() as *const [G; OUT_628]) }; __ret } } else { aiur_fn_628(__args, record, io_buffer, __cu)? } }; let __v_9: G = __r_arr[0]; - let __ret: [G; OUT_632] = [__v_9]; - if let Some(result) = record.function_queries[632].get_mut(&inp[..]) { debug_assert_eq!(result.output, &__ret[..]); if !unconstrained { *result.multiplicity += G::ONE; } } else { record.function_queries[632].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained)); }; + let __ret: [G; OUT_628] = [__v_9]; + if let Some(result) = record.function_queries[628].get_mut(&inp[..]) { debug_assert_eq!(result.output, &__ret[..]); if !unconstrained { *result.multiplicity += G::ONE; } } else { record.function_queries[628].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained)); }; return Ok(__ret); }, _ => { let __v_9: G = G::from_u64(0); - let __ret: [G; OUT_632] = [__v_9]; - if let Some(result) = record.function_queries[632].get_mut(&inp[..]) { debug_assert_eq!(result.output, &__ret[..]); if !unconstrained { *result.multiplicity += G::ONE; } } else { record.function_queries[632].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained)); }; + let __ret: [G; OUT_628] = [__v_9]; + if let Some(result) = record.function_queries[628].get_mut(&inp[..]) { debug_assert_eq!(result.output, &__ret[..]); if !unconstrained { *result.multiplicity += G::ONE; } } else { record.function_queries[628].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained)); }; return Ok(__ret); }, } @@ -53772,15 +53488,15 @@ fn aiur_fn_632( }) } -const INPUT_SIZE_633: usize = 2; -const IN_633: usize = 2; -const OUT_633: usize = 1; -fn aiur_fn_633( - inp: [G; IN_633], +const INPUT_SIZE_629: usize = 2; +const IN_629: usize = 2; +const OUT_629: usize = 1; +fn aiur_fn_629( + inp: [G; IN_629], record: &mut QueryRecord, io_buffer: &mut IOBuffer, unconstrained: bool, -) -> Result<[G; OUT_633], ExecError> { +) -> Result<[G; OUT_629], ExecError> { stacker::maybe_grow(64 * 1024, 4 * 1024 * 1024, || { let __v_0: G = inp[0]; let __v_1: G = inp[1]; @@ -53797,14 +53513,14 @@ fn aiur_fn_633( match __v_5.as_canonical_u64() { 1u64 => { let __v_8: G = G::from_u64(1); - let __ret: [G; OUT_633] = [__v_8]; - if let Some(result) = record.function_queries[633].get_mut(&inp[..]) { debug_assert_eq!(result.output, &__ret[..]); if !unconstrained { *result.multiplicity += G::ONE; } } else { record.function_queries[633].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained)); }; + let __ret: [G; OUT_629] = [__v_8]; + if let Some(result) = record.function_queries[629].get_mut(&inp[..]) { debug_assert_eq!(result.output, &__ret[..]); if !unconstrained { *result.multiplicity += G::ONE; } } else { record.function_queries[629].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained)); }; return Ok(__ret); }, _ => { let __v_8: G = G::from_u64(0); - let __ret: [G; OUT_633] = [__v_8]; - if let Some(result) = record.function_queries[633].get_mut(&inp[..]) { debug_assert_eq!(result.output, &__ret[..]); if !unconstrained { *result.multiplicity += G::ONE; } } else { record.function_queries[633].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained)); }; + let __ret: [G; OUT_629] = [__v_8]; + if let Some(result) = record.function_queries[629].get_mut(&inp[..]) { debug_assert_eq!(result.output, &__ret[..]); if !unconstrained { *result.multiplicity += G::ONE; } } else { record.function_queries[629].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained)); }; return Ok(__ret); }, } @@ -53817,25 +53533,25 @@ fn aiur_fn_633( match __v_5.as_canonical_u64() { 1u64 => { let __v_8: G = G::from_u64(0); - let __ret: [G; OUT_633] = [__v_8]; - if let Some(result) = record.function_queries[633].get_mut(&inp[..]) { debug_assert_eq!(result.output, &__ret[..]); if !unconstrained { *result.multiplicity += G::ONE; } } else { record.function_queries[633].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained)); }; + let __ret: [G; OUT_629] = [__v_8]; + if let Some(result) = record.function_queries[629].get_mut(&inp[..]) { debug_assert_eq!(result.output, &__ret[..]); if !unconstrained { *result.multiplicity += G::ONE; } } else { record.function_queries[629].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained)); }; return Ok(__ret); }, 0u64 => { - let __r_arr: [G; OUT_631] = { let __args: [G; IN_631] = [__v_3, __v_6]; let __cu = unconstrained; if let Some(result) = record.function_queries[631].get_mut(&__args[..]) { if !__cu && *result.multiplicity == G::ZERO { aiur_fn_631(__args, record, io_buffer, false)? } else { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_631] = unsafe { *(result.output.as_ptr() as *const [G; OUT_631]) }; __ret } } else { aiur_fn_631(__args, record, io_buffer, __cu)? } }; + let __r_arr: [G; OUT_627] = { let __args: [G; IN_627] = [__v_3, __v_6]; let __cu = unconstrained; if let Some(result) = record.function_queries[627].get_mut(&__args[..]) { if !__cu && *result.multiplicity == G::ZERO { aiur_fn_627(__args, record, io_buffer, false)? } else { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_627] = unsafe { *(result.output.as_ptr() as *const [G; OUT_627]) }; __ret } } else { aiur_fn_627(__args, record, io_buffer, __cu)? } }; let __v_8: G = __r_arr[0]; match __v_8.as_canonical_u64() { 1u64 => { - let __r_arr: [G; OUT_633] = { let __args: [G; IN_633] = [__v_4, __v_7]; let __cu = unconstrained; if let Some(result) = record.function_queries[633].get_mut(&__args[..]) { if !__cu && *result.multiplicity == G::ZERO { aiur_fn_633(__args, record, io_buffer, false)? } else { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_633] = unsafe { *(result.output.as_ptr() as *const [G; OUT_633]) }; __ret } } else { aiur_fn_633(__args, record, io_buffer, __cu)? } }; + let __r_arr: [G; OUT_629] = { let __args: [G; IN_629] = [__v_4, __v_7]; let __cu = unconstrained; if let Some(result) = record.function_queries[629].get_mut(&__args[..]) { if !__cu && *result.multiplicity == G::ZERO { aiur_fn_629(__args, record, io_buffer, false)? } else { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_629] = unsafe { *(result.output.as_ptr() as *const [G; OUT_629]) }; __ret } } else { aiur_fn_629(__args, record, io_buffer, __cu)? } }; let __v_9: G = __r_arr[0]; - let __ret: [G; OUT_633] = [__v_9]; - if let Some(result) = record.function_queries[633].get_mut(&inp[..]) { debug_assert_eq!(result.output, &__ret[..]); if !unconstrained { *result.multiplicity += G::ONE; } } else { record.function_queries[633].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained)); }; + let __ret: [G; OUT_629] = [__v_9]; + if let Some(result) = record.function_queries[629].get_mut(&inp[..]) { debug_assert_eq!(result.output, &__ret[..]); if !unconstrained { *result.multiplicity += G::ONE; } } else { record.function_queries[629].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained)); }; return Ok(__ret); }, _ => { let __v_9: G = G::from_u64(0); - let __ret: [G; OUT_633] = [__v_9]; - if let Some(result) = record.function_queries[633].get_mut(&inp[..]) { debug_assert_eq!(result.output, &__ret[..]); if !unconstrained { *result.multiplicity += G::ONE; } } else { record.function_queries[633].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained)); }; + let __ret: [G; OUT_629] = [__v_9]; + if let Some(result) = record.function_queries[629].get_mut(&inp[..]) { debug_assert_eq!(result.output, &__ret[..]); if !unconstrained { *result.multiplicity += G::ONE; } } else { record.function_queries[629].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained)); }; return Ok(__ret); }, } @@ -53852,15 +53568,15 @@ fn aiur_fn_633( }) } -const INPUT_SIZE_634: usize = 13; -const IN_634: usize = 13; -const OUT_634: usize = 1; -fn aiur_fn_634( - inp: [G; IN_634], +const INPUT_SIZE_630: usize = 13; +const IN_630: usize = 13; +const OUT_630: usize = 1; +fn aiur_fn_630( + inp: [G; IN_630], record: &mut QueryRecord, io_buffer: &mut IOBuffer, unconstrained: bool, -) -> Result<[G; OUT_634], ExecError> { +) -> Result<[G; OUT_630], ExecError> { stacker::maybe_grow(64 * 1024, 4 * 1024 * 1024, || { let __v_0: G = inp[0]; let __v_1: G = inp[1]; @@ -53877,37 +53593,37 @@ fn aiur_fn_634( let __v_12: G = inp[12]; match __v_0.as_canonical_u64() { 7u64 => { - let __r_arr: [G; OUT_625] = { let __args: [G; IN_625] = [__v_2, __v_3, __v_5, __v_6, __v_4, __v_12]; let __cu = unconstrained; if let Some(result) = record.function_queries[625].get_mut(&__args[..]) { if !__cu && *result.multiplicity == G::ZERO { aiur_fn_625(__args, record, io_buffer, false)? } else { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_625] = unsafe { *(result.output.as_ptr() as *const [G; OUT_625]) }; __ret } } else { aiur_fn_625(__args, record, io_buffer, __cu)? } }; + let __r_arr: [G; OUT_621] = { let __args: [G; IN_621] = [__v_2, __v_3, __v_5, __v_6, __v_4, __v_12]; let __cu = unconstrained; if let Some(result) = record.function_queries[621].get_mut(&__args[..]) { if !__cu && *result.multiplicity == G::ZERO { aiur_fn_621(__args, record, io_buffer, false)? } else { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_621] = unsafe { *(result.output.as_ptr() as *const [G; OUT_621]) }; __ret } } else { aiur_fn_621(__args, record, io_buffer, __cu)? } }; let __v_13: G = __r_arr[0]; - let __ret: [G; OUT_634] = [__v_13]; - if let Some(result) = record.function_queries[634].get_mut(&inp[..]) { debug_assert_eq!(result.output, &__ret[..]); if !unconstrained { *result.multiplicity += G::ONE; } } else { record.function_queries[634].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained)); }; + let __ret: [G; OUT_630] = [__v_13]; + if let Some(result) = record.function_queries[630].get_mut(&inp[..]) { debug_assert_eq!(result.output, &__ret[..]); if !unconstrained { *result.multiplicity += G::ONE; } } else { record.function_queries[630].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained)); }; return Ok(__ret); }, _ => { let __v_13: G = G::from_u64(1); let __v_14: G = G::from_u64(1); let __v_15: G = { let __values: [G; 3] = [__v_13, __v_14, __v_14]; let __mq = record.memory_queries.get_mut(&3).ok_or(ExecError::InvalidMemorySize(3))?; if let Some(result) = __mq.get_mut(&__values[..]) { if !unconstrained { *result.multiplicity += G::ONE; } result.output[0] } else { let __ptr = G::from_usize(__mq.len()); __mq.insert(&__values[..], &[__ptr], G::from_bool(!unconstrained)); __ptr } }; - let __ret: [G; OUT_634] = [__v_15]; - if let Some(result) = record.function_queries[634].get_mut(&inp[..]) { debug_assert_eq!(result.output, &__ret[..]); if !unconstrained { *result.multiplicity += G::ONE; } } else { record.function_queries[634].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained)); }; + let __ret: [G; OUT_630] = [__v_15]; + if let Some(result) = record.function_queries[630].get_mut(&inp[..]) { debug_assert_eq!(result.output, &__ret[..]); if !unconstrained { *result.multiplicity += G::ONE; } } else { record.function_queries[630].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained)); }; return Ok(__ret); }, } }) } -const INPUT_SIZE_635: usize = 2; -const IN_635: usize = 2; -const OUT_635: usize = 1; -fn aiur_fn_635( - inp: [G; IN_635], +const INPUT_SIZE_631: usize = 2; +const IN_631: usize = 2; +const OUT_631: usize = 1; +fn aiur_fn_631( + inp: [G; IN_631], record: &mut QueryRecord, io_buffer: &mut IOBuffer, unconstrained: bool, -) -> Result<[G; OUT_635], ExecError> { +) -> Result<[G; OUT_631], ExecError> { stacker::maybe_grow(64 * 1024, 4 * 1024 * 1024, || { let __v_0: G = inp[0]; let __v_1: G = inp[1]; - let __r_arr: [G; OUT_282] = { let __args: [G; IN_282] = [__v_0]; let __cu = unconstrained; if let Some(result) = record.function_queries[282].get_mut(&__args[..]) { if !__cu && *result.multiplicity == G::ZERO { aiur_fn_282(__args, record, io_buffer, false)? } else { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_282] = unsafe { *(result.output.as_ptr() as *const [G; OUT_282]) }; __ret } } else { aiur_fn_282(__args, record, io_buffer, __cu)? } }; + let __r_arr: [G; OUT_278] = { let __args: [G; IN_278] = [__v_0]; let __cu = unconstrained; if let Some(result) = record.function_queries[278].get_mut(&__args[..]) { if !__cu && *result.multiplicity == G::ZERO { aiur_fn_278(__args, record, io_buffer, false)? } else { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_278] = unsafe { *(result.output.as_ptr() as *const [G; OUT_278]) }; __ret } } else { aiur_fn_278(__args, record, io_buffer, __cu)? } }; let __v_2: G = __r_arr[0]; let __v_3: G = __r_arr[1]; let __v_4: G = __r_arr[2]; @@ -53961,15 +53677,15 @@ fn aiur_fn_635( match __v_2.as_canonical_u64() { 8u64 => { let __v_50: G = G::from_u64(0); - let __r_arr: [G; OUT_636] = { let __args: [G; IN_636] = [__v_3, __v_3, __v_0, __v_50, __v_1]; let __cu = unconstrained; if let Some(result) = record.function_queries[636].get_mut(&__args[..]) { if !__cu && *result.multiplicity == G::ZERO { aiur_fn_636(__args, record, io_buffer, false)? } else { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_636] = unsafe { *(result.output.as_ptr() as *const [G; OUT_636]) }; __ret } } else { aiur_fn_636(__args, record, io_buffer, __cu)? } }; + let __r_arr: [G; OUT_632] = { let __args: [G; IN_632] = [__v_3, __v_3, __v_0, __v_50, __v_1]; let __cu = unconstrained; if let Some(result) = record.function_queries[632].get_mut(&__args[..]) { if !__cu && *result.multiplicity == G::ZERO { aiur_fn_632(__args, record, io_buffer, false)? } else { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_632] = unsafe { *(result.output.as_ptr() as *const [G; OUT_632]) }; __ret } } else { aiur_fn_632(__args, record, io_buffer, __cu)? } }; let __v_51: G = __r_arr[0]; - let __ret: [G; OUT_635] = [__v_51]; - if let Some(result) = record.function_queries[635].get_mut(&inp[..]) { debug_assert_eq!(result.output, &__ret[..]); if !unconstrained { *result.multiplicity += G::ONE; } } else { record.function_queries[635].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained)); }; + let __ret: [G; OUT_631] = [__v_51]; + if let Some(result) = record.function_queries[631].get_mut(&inp[..]) { debug_assert_eq!(result.output, &__ret[..]); if !unconstrained { *result.multiplicity += G::ONE; } } else { record.function_queries[631].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained)); }; return Ok(__ret); }, _ => { - let __ret: [G; OUT_635] = [__v_1]; - if let Some(result) = record.function_queries[635].get_mut(&inp[..]) { debug_assert_eq!(result.output, &__ret[..]); if !unconstrained { *result.multiplicity += G::ONE; } } else { record.function_queries[635].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained)); }; + let __ret: [G; OUT_631] = [__v_1]; + if let Some(result) = record.function_queries[631].get_mut(&inp[..]) { debug_assert_eq!(result.output, &__ret[..]); if !unconstrained { *result.multiplicity += G::ONE; } } else { record.function_queries[631].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained)); }; return Ok(__ret); }, } @@ -53978,15 +53694,15 @@ fn aiur_fn_635( }) } -const INPUT_SIZE_636: usize = 5; -const IN_636: usize = 5; -const OUT_636: usize = 1; -fn aiur_fn_636( - inp: [G; IN_636], +const INPUT_SIZE_632: usize = 5; +const IN_632: usize = 5; +const OUT_632: usize = 1; +fn aiur_fn_632( + inp: [G; IN_632], record: &mut QueryRecord, io_buffer: &mut IOBuffer, unconstrained: bool, -) -> Result<[G; OUT_636], ExecError> { +) -> Result<[G; OUT_632], ExecError> { stacker::maybe_grow(64 * 1024, 4 * 1024 * 1024, || { let __v_0: G = inp[0]; let __v_1: G = inp[1]; @@ -54043,16 +53759,16 @@ fn aiur_fn_636( let __v_51: G = __loaded[46]; match __v_5.as_canonical_u64() { 1u64 => { - let __ret: [G; OUT_636] = [__v_4]; - if let Some(result) = record.function_queries[636].get_mut(&inp[..]) { debug_assert_eq!(result.output, &__ret[..]); if !unconstrained { *result.multiplicity += G::ONE; } } else { record.function_queries[636].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained)); }; + let __ret: [G; OUT_632] = [__v_4]; + if let Some(result) = record.function_queries[632].get_mut(&inp[..]) { debug_assert_eq!(result.output, &__ret[..]); if !unconstrained { *result.multiplicity += G::ONE; } } else { record.function_queries[632].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained)); }; return Ok(__ret); }, 0u64 => { match __v_6.as_canonical_u64() { 2u64 => { - let __r_arr: [G; OUT_294] = { let __args: [G; IN_294] = [__v_0, __v_2, __v_3]; let __cu = unconstrained; if let Some(result) = record.function_queries[294].get_mut(&__args[..]) { if !__cu && *result.multiplicity == G::ZERO { aiur_fn_294(__args, record, io_buffer, false)? } else { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_294] = unsafe { *(result.output.as_ptr() as *const [G; OUT_294]) }; __ret } } else { aiur_fn_294(__args, record, io_buffer, __cu)? } }; + let __r_arr: [G; OUT_290] = { let __args: [G; IN_290] = [__v_0, __v_2, __v_3]; let __cu = unconstrained; if let Some(result) = record.function_queries[290].get_mut(&__args[..]) { if !__cu && *result.multiplicity == G::ZERO { aiur_fn_290(__args, record, io_buffer, false)? } else { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_290] = unsafe { *(result.output.as_ptr() as *const [G; OUT_290]) }; __ret } } else { aiur_fn_290(__args, record, io_buffer, __cu)? } }; let __v_52: G = __r_arr[0]; - let __r_arr: [G; OUT_287] = { let __args: [G; IN_287] = [__v_52]; let __cu = unconstrained; if let Some(result) = record.function_queries[287].get_mut(&__args[..]) { if !__cu && *result.multiplicity == G::ZERO { aiur_fn_287(__args, record, io_buffer, false)? } else { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_287] = unsafe { *(result.output.as_ptr() as *const [G; OUT_287]) }; __ret } } else { aiur_fn_287(__args, record, io_buffer, __cu)? } }; + let __r_arr: [G; OUT_283] = { let __args: [G; IN_283] = [__v_52]; let __cu = unconstrained; if let Some(result) = record.function_queries[283].get_mut(&__args[..]) { if !__cu && *result.multiplicity == G::ZERO { aiur_fn_283(__args, record, io_buffer, false)? } else { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_283] = unsafe { *(result.output.as_ptr() as *const [G; OUT_283]) }; __ret } } else { aiur_fn_283(__args, record, io_buffer, __cu)? } }; let __v_53: G = __r_arr[0]; let __loaded: [G; 12] = { let __mq = record.memory_queries.get_mut(&12).ok_or(ExecError::InvalidMemorySize(12))?; let __ptr_u64 = __v_53.as_canonical_u64(); let __ptr_usize = usize::try_from(__ptr_u64).ok().ok_or(ExecError::PointerTooLarge(__ptr_u64))?; let (__args, __mult) = __mq.get_index_mut(__ptr_usize).ok_or(ExecError::UnboundPointer { ptr: __ptr_u64, size: 12 })?; if !unconstrained { *__mult += G::ONE; } let __arr: [G; 12] = __args[..12].try_into().unwrap(); __arr }; let __v_54: G = __loaded[0]; @@ -54069,9 +53785,9 @@ fn aiur_fn_636( let __v_65: G = __loaded[11]; match __v_54.as_canonical_u64() { 7u64 => { - let __r_arr: [G; OUT_623] = { let __args: [G; IN_623] = [__v_56, __v_57, __v_59, __v_60, __v_58]; let __cu = unconstrained; if let Some(result) = record.function_queries[623].get_mut(&__args[..]) { if !__cu && *result.multiplicity == G::ZERO { aiur_fn_623(__args, record, io_buffer, false)? } else { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_623] = unsafe { *(result.output.as_ptr() as *const [G; OUT_623]) }; __ret } } else { aiur_fn_623(__args, record, io_buffer, __cu)? } }; + let __r_arr: [G; OUT_619] = { let __args: [G; IN_619] = [__v_56, __v_57, __v_59, __v_60, __v_58]; let __cu = unconstrained; if let Some(result) = record.function_queries[619].get_mut(&__args[..]) { if !__cu && *result.multiplicity == G::ZERO { aiur_fn_619(__args, record, io_buffer, false)? } else { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_619] = unsafe { *(result.output.as_ptr() as *const [G; OUT_619]) }; __ret } } else { aiur_fn_619(__args, record, io_buffer, __cu)? } }; let __v_66: G = __r_arr[0]; - let __r_arr: [G; OUT_287] = { let __args: [G; IN_287] = [__v_66]; let __cu = unconstrained; if let Some(result) = record.function_queries[287].get_mut(&__args[..]) { if !__cu && *result.multiplicity == G::ZERO { aiur_fn_287(__args, record, io_buffer, false)? } else { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_287] = unsafe { *(result.output.as_ptr() as *const [G; OUT_287]) }; __ret } } else { aiur_fn_287(__args, record, io_buffer, __cu)? } }; + let __r_arr: [G; OUT_283] = { let __args: [G; IN_283] = [__v_66]; let __cu = unconstrained; if let Some(result) = record.function_queries[283].get_mut(&__args[..]) { if !__cu && *result.multiplicity == G::ZERO { aiur_fn_283(__args, record, io_buffer, false)? } else { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_283] = unsafe { *(result.output.as_ptr() as *const [G; OUT_283]) }; __ret } } else { aiur_fn_283(__args, record, io_buffer, __cu)? } }; let __v_67: G = __r_arr[0]; let __loaded: [G; 12] = { let __mq = record.memory_queries.get_mut(&12).ok_or(ExecError::InvalidMemorySize(12))?; let __ptr_u64 = __v_67.as_canonical_u64(); let __ptr_usize = usize::try_from(__ptr_u64).ok().ok_or(ExecError::PointerTooLarge(__ptr_u64))?; let (__args, __mult) = __mq.get_index_mut(__ptr_usize).ok_or(ExecError::UnboundPointer { ptr: __ptr_u64, size: 12 })?; if !unconstrained { *__mult += G::ONE; } let __arr: [G; 12] = __args[..12].try_into().unwrap(); __arr }; let __v_68: G = __loaded[0]; @@ -54088,20 +53804,20 @@ fn aiur_fn_636( let __v_79: G = __loaded[11]; match __v_68.as_canonical_u64() { 5u64 => { - let __ret: [G; OUT_636] = [__v_75]; - if let Some(result) = record.function_queries[636].get_mut(&inp[..]) { debug_assert_eq!(result.output, &__ret[..]); if !unconstrained { *result.multiplicity += G::ONE; } } else { record.function_queries[636].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained)); }; + let __ret: [G; OUT_632] = [__v_75]; + if let Some(result) = record.function_queries[632].get_mut(&inp[..]) { debug_assert_eq!(result.output, &__ret[..]); if !unconstrained { *result.multiplicity += G::ONE; } } else { record.function_queries[632].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained)); }; return Ok(__ret); }, _ => { - let __ret: [G; OUT_636] = [__v_4]; - if let Some(result) = record.function_queries[636].get_mut(&inp[..]) { debug_assert_eq!(result.output, &__ret[..]); if !unconstrained { *result.multiplicity += G::ONE; } } else { record.function_queries[636].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained)); }; + let __ret: [G; OUT_632] = [__v_4]; + if let Some(result) = record.function_queries[632].get_mut(&inp[..]) { debug_assert_eq!(result.output, &__ret[..]); if !unconstrained { *result.multiplicity += G::ONE; } } else { record.function_queries[632].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained)); }; return Ok(__ret); }, } }, _ => { - let __ret: [G; OUT_636] = [__v_4]; - if let Some(result) = record.function_queries[636].get_mut(&inp[..]) { debug_assert_eq!(result.output, &__ret[..]); if !unconstrained { *result.multiplicity += G::ONE; } } else { record.function_queries[636].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained)); }; + let __ret: [G; OUT_632] = [__v_4]; + if let Some(result) = record.function_queries[632].get_mut(&inp[..]) { debug_assert_eq!(result.output, &__ret[..]); if !unconstrained { *result.multiplicity += G::ONE; } } else { record.function_queries[632].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained)); }; return Ok(__ret); }, } @@ -54109,10 +53825,10 @@ fn aiur_fn_636( _ => { let __v_52: G = G::from_u64(1); let __v_53: G = (__v_3 + __v_52); - let __r_arr: [G; OUT_636] = { let __args: [G; IN_636] = [__v_0, __v_51, __v_2, __v_53, __v_4]; let __cu = unconstrained; if let Some(result) = record.function_queries[636].get_mut(&__args[..]) { if !__cu && *result.multiplicity == G::ZERO { aiur_fn_636(__args, record, io_buffer, false)? } else { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_636] = unsafe { *(result.output.as_ptr() as *const [G; OUT_636]) }; __ret } } else { aiur_fn_636(__args, record, io_buffer, __cu)? } }; + let __r_arr: [G; OUT_632] = { let __args: [G; IN_632] = [__v_0, __v_51, __v_2, __v_53, __v_4]; let __cu = unconstrained; if let Some(result) = record.function_queries[632].get_mut(&__args[..]) { if !__cu && *result.multiplicity == G::ZERO { aiur_fn_632(__args, record, io_buffer, false)? } else { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_632] = unsafe { *(result.output.as_ptr() as *const [G; OUT_632]) }; __ret } } else { aiur_fn_632(__args, record, io_buffer, __cu)? } }; let __v_54: G = __r_arr[0]; - let __ret: [G; OUT_636] = [__v_54]; - if let Some(result) = record.function_queries[636].get_mut(&inp[..]) { debug_assert_eq!(result.output, &__ret[..]); if !unconstrained { *result.multiplicity += G::ONE; } } else { record.function_queries[636].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained)); }; + let __ret: [G; OUT_632] = [__v_54]; + if let Some(result) = record.function_queries[632].get_mut(&inp[..]) { debug_assert_eq!(result.output, &__ret[..]); if !unconstrained { *result.multiplicity += G::ONE; } } else { record.function_queries[632].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained)); }; return Ok(__ret); }, } @@ -54124,20 +53840,20 @@ fn aiur_fn_636( }) } -const INPUT_SIZE_637: usize = 3; -const IN_637: usize = 3; -const OUT_637: usize = 1; -fn aiur_fn_637( - inp: [G; IN_637], +const INPUT_SIZE_633: usize = 3; +const IN_633: usize = 3; +const OUT_633: usize = 1; +fn aiur_fn_633( + inp: [G; IN_633], record: &mut QueryRecord, io_buffer: &mut IOBuffer, unconstrained: bool, -) -> Result<[G; OUT_637], ExecError> { +) -> Result<[G; OUT_633], ExecError> { stacker::maybe_grow(64 * 1024, 4 * 1024 * 1024, || { let __v_0: G = inp[0]; let __v_1: G = inp[1]; let __v_2: G = inp[2]; - let __r_arr: [G; OUT_282] = { let __args: [G; IN_282] = [__v_0]; let __cu = unconstrained; if let Some(result) = record.function_queries[282].get_mut(&__args[..]) { if !__cu && *result.multiplicity == G::ZERO { aiur_fn_282(__args, record, io_buffer, false)? } else { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_282] = unsafe { *(result.output.as_ptr() as *const [G; OUT_282]) }; __ret } } else { aiur_fn_282(__args, record, io_buffer, __cu)? } }; + let __r_arr: [G; OUT_278] = { let __args: [G; IN_278] = [__v_0]; let __cu = unconstrained; if let Some(result) = record.function_queries[278].get_mut(&__args[..]) { if !__cu && *result.multiplicity == G::ZERO { aiur_fn_278(__args, record, io_buffer, false)? } else { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_278] = unsafe { *(result.output.as_ptr() as *const [G; OUT_278]) }; __ret } } else { aiur_fn_278(__args, record, io_buffer, __cu)? } }; let __v_3: G = __r_arr[0]; let __v_4: G = __r_arr[1]; let __v_5: G = __r_arr[2]; @@ -54191,7 +53907,7 @@ fn aiur_fn_637( match __v_3.as_canonical_u64() { 8u64 => { let __v_51: G = G::from_u64(0); - let __r_arr: [G; OUT_636] = { let __args: [G; IN_636] = [__v_4, __v_4, __v_0, __v_51, __v_1]; let __cu = unconstrained; if let Some(result) = record.function_queries[636].get_mut(&__args[..]) { if !__cu && *result.multiplicity == G::ZERO { aiur_fn_636(__args, record, io_buffer, false)? } else { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_636] = unsafe { *(result.output.as_ptr() as *const [G; OUT_636]) }; __ret } } else { aiur_fn_636(__args, record, io_buffer, __cu)? } }; + let __r_arr: [G; OUT_632] = { let __args: [G; IN_632] = [__v_4, __v_4, __v_0, __v_51, __v_1]; let __cu = unconstrained; if let Some(result) = record.function_queries[632].get_mut(&__args[..]) { if !__cu && *result.multiplicity == G::ZERO { aiur_fn_632(__args, record, io_buffer, false)? } else { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_632] = unsafe { *(result.output.as_ptr() as *const [G; OUT_632]) }; __ret } } else { aiur_fn_632(__args, record, io_buffer, __cu)? } }; let __v_52: G = __r_arr[0]; break '__mc_0 [__v_52]; }, @@ -54203,7 +53919,7 @@ fn aiur_fn_637( } }; let __v_51: G = __mc_out___mc_0[0]; - let __r_arr: [G; OUT_282] = { let __args: [G; IN_282] = [__v_51]; let __cu = unconstrained; if let Some(result) = record.function_queries[282].get_mut(&__args[..]) { if !__cu && *result.multiplicity == G::ZERO { aiur_fn_282(__args, record, io_buffer, false)? } else { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_282] = unsafe { *(result.output.as_ptr() as *const [G; OUT_282]) }; __ret } } else { aiur_fn_282(__args, record, io_buffer, __cu)? } }; + let __r_arr: [G; OUT_278] = { let __args: [G; IN_278] = [__v_51]; let __cu = unconstrained; if let Some(result) = record.function_queries[278].get_mut(&__args[..]) { if !__cu && *result.multiplicity == G::ZERO { aiur_fn_278(__args, record, io_buffer, false)? } else { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_278] = unsafe { *(result.output.as_ptr() as *const [G; OUT_278]) }; __ret } } else { aiur_fn_278(__args, record, io_buffer, __cu)? } }; let __v_52: G = __r_arr[0]; let __v_53: G = __r_arr[1]; let __v_54: G = __r_arr[2]; @@ -54257,12 +53973,12 @@ fn aiur_fn_637( match __v_52.as_canonical_u64() { 8u64 => { let __v_100: G = G::from_u64(0); - let __r_arr: [G; OUT_629] = { let __args: [G; IN_629] = [__v_53, __v_53, __v_51, __v_2, __v_100]; let __cu = unconstrained; if let Some(result) = record.function_queries[629].get_mut(&__args[..]) { if !__cu && *result.multiplicity == G::ZERO { aiur_fn_629(__args, record, io_buffer, false)? } else { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_629] = unsafe { *(result.output.as_ptr() as *const [G; OUT_629]) }; __ret } } else { aiur_fn_629(__args, record, io_buffer, __cu)? } }; + let __r_arr: [G; OUT_625] = { let __args: [G; IN_625] = [__v_53, __v_53, __v_51, __v_2, __v_100]; let __cu = unconstrained; if let Some(result) = record.function_queries[625].get_mut(&__args[..]) { if !__cu && *result.multiplicity == G::ZERO { aiur_fn_625(__args, record, io_buffer, false)? } else { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_625] = unsafe { *(result.output.as_ptr() as *const [G; OUT_625]) }; __ret } } else { aiur_fn_625(__args, record, io_buffer, __cu)? } }; let __v_101: G = __r_arr[0]; break '__mc_1 [__v_101]; }, _ => { - let __r_arr: [G; OUT_287] = { let __args: [G; IN_287] = [__v_51]; let __cu = unconstrained; if let Some(result) = record.function_queries[287].get_mut(&__args[..]) { if !__cu && *result.multiplicity == G::ZERO { aiur_fn_287(__args, record, io_buffer, false)? } else { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_287] = unsafe { *(result.output.as_ptr() as *const [G; OUT_287]) }; __ret } } else { aiur_fn_287(__args, record, io_buffer, __cu)? } }; + let __r_arr: [G; OUT_283] = { let __args: [G; IN_283] = [__v_51]; let __cu = unconstrained; if let Some(result) = record.function_queries[283].get_mut(&__args[..]) { if !__cu && *result.multiplicity == G::ZERO { aiur_fn_283(__args, record, io_buffer, false)? } else { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_283] = unsafe { *(result.output.as_ptr() as *const [G; OUT_283]) }; __ret } } else { aiur_fn_283(__args, record, io_buffer, __cu)? } }; let __v_100: G = __r_arr[0]; let __loaded: [G; 12] = { let __mq = record.memory_queries.get_mut(&12).ok_or(ExecError::InvalidMemorySize(12))?; let __ptr_u64 = __v_100.as_canonical_u64(); let __ptr_usize = usize::try_from(__ptr_u64).ok().ok_or(ExecError::PointerTooLarge(__ptr_u64))?; let (__args, __mult) = __mq.get_index_mut(__ptr_usize).ok_or(ExecError::UnboundPointer { ptr: __ptr_u64, size: 12 })?; if !unconstrained { *__mult += G::ONE; } let __arr: [G; 12] = __args[..12].try_into().unwrap(); __arr }; let __v_101: G = __loaded[0]; @@ -54280,7 +53996,7 @@ fn aiur_fn_637( match __v_101.as_canonical_u64() { 5u64 => { let __v_113: G = G::from_u64(0); - let __r_arr: [G; OUT_627] = { let __args: [G; IN_627] = [__v_2, __v_102, __v_113]; let __cu = unconstrained; if let Some(result) = record.function_queries[627].get_mut(&__args[..]) { if !__cu && *result.multiplicity == G::ZERO { aiur_fn_627(__args, record, io_buffer, false)? } else { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_627] = unsafe { *(result.output.as_ptr() as *const [G; OUT_627]) }; __ret } } else { aiur_fn_627(__args, record, io_buffer, __cu)? } }; + let __r_arr: [G; OUT_623] = { let __args: [G; IN_623] = [__v_2, __v_102, __v_113]; let __cu = unconstrained; if let Some(result) = record.function_queries[623].get_mut(&__args[..]) { if !__cu && *result.multiplicity == G::ZERO { aiur_fn_623(__args, record, io_buffer, false)? } else { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_623] = unsafe { *(result.output.as_ptr() as *const [G; OUT_623]) }; __ret } } else { aiur_fn_623(__args, record, io_buffer, __cu)? } }; let __v_114: G = __r_arr[0]; let __v_115: G = G::from_u64(0); let __v_116: G = G::from_u64(0); @@ -54306,40 +54022,40 @@ fn aiur_fn_637( } }; let __v_100: G = __mc_out___mc_1[0]; - let __r_arr: [G; OUT_621] = { let __args: [G; IN_621] = [__v_0]; let __cu = unconstrained; if let Some(result) = record.function_queries[621].get_mut(&__args[..]) { if !__cu && *result.multiplicity == G::ZERO { aiur_fn_621(__args, record, io_buffer, false)? } else { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_621] = unsafe { *(result.output.as_ptr() as *const [G; OUT_621]) }; __ret } } else { aiur_fn_621(__args, record, io_buffer, __cu)? } }; + let __r_arr: [G; OUT_617] = { let __args: [G; IN_617] = [__v_0]; let __cu = unconstrained; if let Some(result) = record.function_queries[617].get_mut(&__args[..]) { if !__cu && *result.multiplicity == G::ZERO { aiur_fn_617(__args, record, io_buffer, false)? } else { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_617] = unsafe { *(result.output.as_ptr() as *const [G; OUT_617]) }; __ret } } else { aiur_fn_617(__args, record, io_buffer, __cu)? } }; let __v_101: G = __r_arr[0]; match __v_101.as_canonical_u64() { 0u64 => { - let __ret: [G; OUT_637] = [__v_100]; - if let Some(result) = record.function_queries[637].get_mut(&inp[..]) { debug_assert_eq!(result.output, &__ret[..]); if !unconstrained { *result.multiplicity += G::ONE; } } else { record.function_queries[637].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained)); }; + let __ret: [G; OUT_633] = [__v_100]; + if let Some(result) = record.function_queries[633].get_mut(&inp[..]) { debug_assert_eq!(result.output, &__ret[..]); if !unconstrained { *result.multiplicity += G::ONE; } } else { record.function_queries[633].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained)); }; return Ok(__ret); }, _ => { - let __r_arr: [G; OUT_638] = { let __args: [G; IN_638] = [__v_0, __v_51, __v_2, __v_100]; let __cu = unconstrained; if let Some(result) = record.function_queries[638].get_mut(&__args[..]) { if !__cu && *result.multiplicity == G::ZERO { aiur_fn_638(__args, record, io_buffer, false)? } else { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_638] = unsafe { *(result.output.as_ptr() as *const [G; OUT_638]) }; __ret } } else { aiur_fn_638(__args, record, io_buffer, __cu)? } }; + let __r_arr: [G; OUT_634] = { let __args: [G; IN_634] = [__v_0, __v_51, __v_2, __v_100]; let __cu = unconstrained; if let Some(result) = record.function_queries[634].get_mut(&__args[..]) { if !__cu && *result.multiplicity == G::ZERO { aiur_fn_634(__args, record, io_buffer, false)? } else { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_634] = unsafe { *(result.output.as_ptr() as *const [G; OUT_634]) }; __ret } } else { aiur_fn_634(__args, record, io_buffer, __cu)? } }; let __v_102: G = __r_arr[0]; - let __ret: [G; OUT_637] = [__v_102]; - if let Some(result) = record.function_queries[637].get_mut(&inp[..]) { debug_assert_eq!(result.output, &__ret[..]); if !unconstrained { *result.multiplicity += G::ONE; } } else { record.function_queries[637].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained)); }; + let __ret: [G; OUT_633] = [__v_102]; + if let Some(result) = record.function_queries[633].get_mut(&inp[..]) { debug_assert_eq!(result.output, &__ret[..]); if !unconstrained { *result.multiplicity += G::ONE; } } else { record.function_queries[633].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained)); }; return Ok(__ret); }, } }) } -const INPUT_SIZE_638: usize = 4; -const IN_638: usize = 4; -const OUT_638: usize = 1; -fn aiur_fn_638( - inp: [G; IN_638], +const INPUT_SIZE_634: usize = 4; +const IN_634: usize = 4; +const OUT_634: usize = 1; +fn aiur_fn_634( + inp: [G; IN_634], record: &mut QueryRecord, io_buffer: &mut IOBuffer, unconstrained: bool, -) -> Result<[G; OUT_638], ExecError> { +) -> Result<[G; OUT_634], ExecError> { stacker::maybe_grow(64 * 1024, 4 * 1024 * 1024, || { let __v_0: G = inp[0]; let __v_1: G = inp[1]; let __v_2: G = inp[2]; let __v_3: G = inp[3]; - let __r_arr: [G; OUT_282] = { let __args: [G; IN_282] = [__v_0]; let __cu = unconstrained; if let Some(result) = record.function_queries[282].get_mut(&__args[..]) { if !__cu && *result.multiplicity == G::ZERO { aiur_fn_282(__args, record, io_buffer, false)? } else { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_282] = unsafe { *(result.output.as_ptr() as *const [G; OUT_282]) }; __ret } } else { aiur_fn_282(__args, record, io_buffer, __cu)? } }; + let __r_arr: [G; OUT_278] = { let __args: [G; IN_278] = [__v_0]; let __cu = unconstrained; if let Some(result) = record.function_queries[278].get_mut(&__args[..]) { if !__cu && *result.multiplicity == G::ZERO { aiur_fn_278(__args, record, io_buffer, false)? } else { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_278] = unsafe { *(result.output.as_ptr() as *const [G; OUT_278]) }; __ret } } else { aiur_fn_278(__args, record, io_buffer, __cu)? } }; let __v_4: G = __r_arr[0]; let __v_5: G = __r_arr[1]; let __v_6: G = __r_arr[2]; @@ -54393,15 +54109,15 @@ fn aiur_fn_638( match __v_4.as_canonical_u64() { 8u64 => { let __v_52: G = G::from_u64(0); - let __r_arr: [G; OUT_639] = { let __args: [G; IN_639] = [__v_5, __v_5, __v_0, __v_1, __v_2, __v_3, __v_52]; let __cu = unconstrained; if let Some(result) = record.function_queries[639].get_mut(&__args[..]) { if !__cu && *result.multiplicity == G::ZERO { aiur_fn_639(__args, record, io_buffer, false)? } else { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_639] = unsafe { *(result.output.as_ptr() as *const [G; OUT_639]) }; __ret } } else { aiur_fn_639(__args, record, io_buffer, __cu)? } }; + let __r_arr: [G; OUT_635] = { let __args: [G; IN_635] = [__v_5, __v_5, __v_0, __v_1, __v_2, __v_3, __v_52]; let __cu = unconstrained; if let Some(result) = record.function_queries[635].get_mut(&__args[..]) { if !__cu && *result.multiplicity == G::ZERO { aiur_fn_635(__args, record, io_buffer, false)? } else { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_635] = unsafe { *(result.output.as_ptr() as *const [G; OUT_635]) }; __ret } } else { aiur_fn_635(__args, record, io_buffer, __cu)? } }; let __v_53: G = __r_arr[0]; - let __ret: [G; OUT_638] = [__v_53]; - if let Some(result) = record.function_queries[638].get_mut(&inp[..]) { debug_assert_eq!(result.output, &__ret[..]); if !unconstrained { *result.multiplicity += G::ONE; } } else { record.function_queries[638].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained)); }; + let __ret: [G; OUT_634] = [__v_53]; + if let Some(result) = record.function_queries[634].get_mut(&inp[..]) { debug_assert_eq!(result.output, &__ret[..]); if !unconstrained { *result.multiplicity += G::ONE; } } else { record.function_queries[634].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained)); }; return Ok(__ret); }, _ => { - let __ret: [G; OUT_638] = [__v_3]; - if let Some(result) = record.function_queries[638].get_mut(&inp[..]) { debug_assert_eq!(result.output, &__ret[..]); if !unconstrained { *result.multiplicity += G::ONE; } } else { record.function_queries[638].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained)); }; + let __ret: [G; OUT_634] = [__v_3]; + if let Some(result) = record.function_queries[634].get_mut(&inp[..]) { debug_assert_eq!(result.output, &__ret[..]); if !unconstrained { *result.multiplicity += G::ONE; } } else { record.function_queries[634].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained)); }; return Ok(__ret); }, } @@ -54410,15 +54126,15 @@ fn aiur_fn_638( }) } -const INPUT_SIZE_639: usize = 7; -const IN_639: usize = 7; -const OUT_639: usize = 1; -fn aiur_fn_639( - inp: [G; IN_639], +const INPUT_SIZE_635: usize = 7; +const IN_635: usize = 7; +const OUT_635: usize = 1; +fn aiur_fn_635( + inp: [G; IN_635], record: &mut QueryRecord, io_buffer: &mut IOBuffer, unconstrained: bool, -) -> Result<[G; OUT_639], ExecError> { +) -> Result<[G; OUT_635], ExecError> { stacker::maybe_grow(64 * 1024, 4 * 1024 * 1024, || { let __v_0: G = inp[0]; let __v_1: G = inp[1]; @@ -54477,16 +54193,16 @@ fn aiur_fn_639( let __v_53: G = __loaded[46]; match __v_7.as_canonical_u64() { 1u64 => { - let __ret: [G; OUT_639] = [__v_5]; - if let Some(result) = record.function_queries[639].get_mut(&inp[..]) { debug_assert_eq!(result.output, &__ret[..]); if !unconstrained { *result.multiplicity += G::ONE; } } else { record.function_queries[639].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained)); }; + let __ret: [G; OUT_635] = [__v_5]; + if let Some(result) = record.function_queries[635].get_mut(&inp[..]) { debug_assert_eq!(result.output, &__ret[..]); if !unconstrained { *result.multiplicity += G::ONE; } } else { record.function_queries[635].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained)); }; return Ok(__ret); }, 0u64 => { match __v_8.as_canonical_u64() { 2u64 => { - let __r_arr: [G; OUT_294] = { let __args: [G; IN_294] = [__v_0, __v_2, __v_6]; let __cu = unconstrained; if let Some(result) = record.function_queries[294].get_mut(&__args[..]) { if !__cu && *result.multiplicity == G::ZERO { aiur_fn_294(__args, record, io_buffer, false)? } else { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_294] = unsafe { *(result.output.as_ptr() as *const [G; OUT_294]) }; __ret } } else { aiur_fn_294(__args, record, io_buffer, __cu)? } }; + let __r_arr: [G; OUT_290] = { let __args: [G; IN_290] = [__v_0, __v_2, __v_6]; let __cu = unconstrained; if let Some(result) = record.function_queries[290].get_mut(&__args[..]) { if !__cu && *result.multiplicity == G::ZERO { aiur_fn_290(__args, record, io_buffer, false)? } else { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_290] = unsafe { *(result.output.as_ptr() as *const [G; OUT_290]) }; __ret } } else { aiur_fn_290(__args, record, io_buffer, __cu)? } }; let __v_54: G = __r_arr[0]; - let __r_arr: [G; OUT_287] = { let __args: [G; IN_287] = [__v_54]; let __cu = unconstrained; if let Some(result) = record.function_queries[287].get_mut(&__args[..]) { if !__cu && *result.multiplicity == G::ZERO { aiur_fn_287(__args, record, io_buffer, false)? } else { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_287] = unsafe { *(result.output.as_ptr() as *const [G; OUT_287]) }; __ret } } else { aiur_fn_287(__args, record, io_buffer, __cu)? } }; + let __r_arr: [G; OUT_283] = { let __args: [G; IN_283] = [__v_54]; let __cu = unconstrained; if let Some(result) = record.function_queries[283].get_mut(&__args[..]) { if !__cu && *result.multiplicity == G::ZERO { aiur_fn_283(__args, record, io_buffer, false)? } else { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_283] = unsafe { *(result.output.as_ptr() as *const [G; OUT_283]) }; __ret } } else { aiur_fn_283(__args, record, io_buffer, __cu)? } }; let __v_55: G = __r_arr[0]; let __loaded: [G; 12] = { let __mq = record.memory_queries.get_mut(&12).ok_or(ExecError::InvalidMemorySize(12))?; let __ptr_u64 = __v_55.as_canonical_u64(); let __ptr_usize = usize::try_from(__ptr_u64).ok().ok_or(ExecError::PointerTooLarge(__ptr_u64))?; let (__args, __mult) = __mq.get_index_mut(__ptr_usize).ok_or(ExecError::UnboundPointer { ptr: __ptr_u64, size: 12 })?; if !unconstrained { *__mult += G::ONE; } let __arr: [G; 12] = __args[..12].try_into().unwrap(); __arr }; let __v_56: G = __loaded[0]; @@ -54503,9 +54219,9 @@ fn aiur_fn_639( let __v_67: G = __loaded[11]; let __mc_out___mc_0: [G; 5] = '__mc_0: { match __v_56.as_canonical_u64() { 7u64 => { - let __r_arr: [G; OUT_623] = { let __args: [G; IN_623] = [__v_58, __v_59, __v_61, __v_62, __v_60]; let __cu = unconstrained; if let Some(result) = record.function_queries[623].get_mut(&__args[..]) { if !__cu && *result.multiplicity == G::ZERO { aiur_fn_623(__args, record, io_buffer, false)? } else { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_623] = unsafe { *(result.output.as_ptr() as *const [G; OUT_623]) }; __ret } } else { aiur_fn_623(__args, record, io_buffer, __cu)? } }; + let __r_arr: [G; OUT_619] = { let __args: [G; IN_619] = [__v_58, __v_59, __v_61, __v_62, __v_60]; let __cu = unconstrained; if let Some(result) = record.function_queries[619].get_mut(&__args[..]) { if !__cu && *result.multiplicity == G::ZERO { aiur_fn_619(__args, record, io_buffer, false)? } else { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_619] = unsafe { *(result.output.as_ptr() as *const [G; OUT_619]) }; __ret } } else { aiur_fn_619(__args, record, io_buffer, __cu)? } }; let __v_68: G = __r_arr[0]; - let __r_arr: [G; OUT_287] = { let __args: [G; IN_287] = [__v_68]; let __cu = unconstrained; if let Some(result) = record.function_queries[287].get_mut(&__args[..]) { if !__cu && *result.multiplicity == G::ZERO { aiur_fn_287(__args, record, io_buffer, false)? } else { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_287] = unsafe { *(result.output.as_ptr() as *const [G; OUT_287]) }; __ret } } else { aiur_fn_287(__args, record, io_buffer, __cu)? } }; + let __r_arr: [G; OUT_283] = { let __args: [G; IN_283] = [__v_68]; let __cu = unconstrained; if let Some(result) = record.function_queries[283].get_mut(&__args[..]) { if !__cu && *result.multiplicity == G::ZERO { aiur_fn_283(__args, record, io_buffer, false)? } else { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_283] = unsafe { *(result.output.as_ptr() as *const [G; OUT_283]) }; __ret } } else { aiur_fn_283(__args, record, io_buffer, __cu)? } }; let __v_69: G = __r_arr[0]; let __loaded: [G; 12] = { let __mq = record.memory_queries.get_mut(&12).ok_or(ExecError::InvalidMemorySize(12))?; let __ptr_u64 = __v_69.as_canonical_u64(); let __ptr_usize = usize::try_from(__ptr_u64).ok().ok_or(ExecError::PointerTooLarge(__ptr_u64))?; let (__args, __mult) = __mq.get_index_mut(__ptr_usize).ok_or(ExecError::UnboundPointer { ptr: __ptr_u64, size: 12 })?; if !unconstrained { *__mult += G::ONE; } let __arr: [G; 12] = __args[..12].try_into().unwrap(); __arr }; let __v_70: G = __loaded[0]; @@ -54564,39 +54280,39 @@ fn aiur_fn_639( 0u64 => { let __v_73: G = G::from_u64(1); let __v_74: G = (__v_6 + __v_73); - let __r_arr: [G; OUT_639] = { let __args: [G; IN_639] = [__v_0, __v_53, __v_2, __v_3, __v_4, __v_5, __v_74]; let __cu = unconstrained; if let Some(result) = record.function_queries[639].get_mut(&__args[..]) { if !__cu && *result.multiplicity == G::ZERO { aiur_fn_639(__args, record, io_buffer, false)? } else { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_639] = unsafe { *(result.output.as_ptr() as *const [G; OUT_639]) }; __ret } } else { aiur_fn_639(__args, record, io_buffer, __cu)? } }; + let __r_arr: [G; OUT_635] = { let __args: [G; IN_635] = [__v_0, __v_53, __v_2, __v_3, __v_4, __v_5, __v_74]; let __cu = unconstrained; if let Some(result) = record.function_queries[635].get_mut(&__args[..]) { if !__cu && *result.multiplicity == G::ZERO { aiur_fn_635(__args, record, io_buffer, false)? } else { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_635] = unsafe { *(result.output.as_ptr() as *const [G; OUT_635]) }; __ret } } else { aiur_fn_635(__args, record, io_buffer, __cu)? } }; let __v_75: G = __r_arr[0]; - let __ret: [G; OUT_639] = [__v_75]; - if let Some(result) = record.function_queries[639].get_mut(&inp[..]) { debug_assert_eq!(result.output, &__ret[..]); if !unconstrained { *result.multiplicity += G::ONE; } } else { record.function_queries[639].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained)); }; + let __ret: [G; OUT_635] = [__v_75]; + if let Some(result) = record.function_queries[635].get_mut(&inp[..]) { debug_assert_eq!(result.output, &__ret[..]); if !unconstrained { *result.multiplicity += G::ONE; } } else { record.function_queries[635].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained)); }; return Ok(__ret); }, _ => { - let __r_arr: [G; OUT_634] = { let __args: [G; IN_634] = [__v_56, __v_57, __v_58, __v_59, __v_60, __v_61, __v_62, __v_63, __v_64, __v_65, __v_66, __v_67, __v_71]; let __cu = unconstrained; if let Some(result) = record.function_queries[634].get_mut(&__args[..]) { if !__cu && *result.multiplicity == G::ZERO { aiur_fn_634(__args, record, io_buffer, false)? } else { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_634] = unsafe { *(result.output.as_ptr() as *const [G; OUT_634]) }; __ret } } else { aiur_fn_634(__args, record, io_buffer, __cu)? } }; + let __r_arr: [G; OUT_630] = { let __args: [G; IN_630] = [__v_56, __v_57, __v_58, __v_59, __v_60, __v_61, __v_62, __v_63, __v_64, __v_65, __v_66, __v_67, __v_71]; let __cu = unconstrained; if let Some(result) = record.function_queries[630].get_mut(&__args[..]) { if !__cu && *result.multiplicity == G::ZERO { aiur_fn_630(__args, record, io_buffer, false)? } else { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_630] = unsafe { *(result.output.as_ptr() as *const [G; OUT_630]) }; __ret } } else { aiur_fn_630(__args, record, io_buffer, __cu)? } }; let __v_73: G = __r_arr[0]; - let __r_arr: [G; OUT_624] = { let __args: [G; IN_624] = [__v_56, __v_57, __v_58, __v_59, __v_60, __v_61, __v_62, __v_63, __v_64, __v_65, __v_66, __v_67]; let __cu = unconstrained; if let Some(result) = record.function_queries[624].get_mut(&__args[..]) { if !__cu && *result.multiplicity == G::ZERO { aiur_fn_624(__args, record, io_buffer, false)? } else { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_624] = unsafe { *(result.output.as_ptr() as *const [G; OUT_624]) }; __ret } } else { aiur_fn_624(__args, record, io_buffer, __cu)? } }; + let __r_arr: [G; OUT_620] = { let __args: [G; IN_620] = [__v_56, __v_57, __v_58, __v_59, __v_60, __v_61, __v_62, __v_63, __v_64, __v_65, __v_66, __v_67]; let __cu = unconstrained; if let Some(result) = record.function_queries[620].get_mut(&__args[..]) { if !__cu && *result.multiplicity == G::ZERO { aiur_fn_620(__args, record, io_buffer, false)? } else { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_620] = unsafe { *(result.output.as_ptr() as *const [G; OUT_620]) }; __ret } } else { aiur_fn_620(__args, record, io_buffer, __cu)? } }; let __v_74: G = __r_arr[0]; - let __r_arr: [G; OUT_630] = { let __args: [G; IN_630] = [__v_5, __v_69, __v_73]; let __cu = unconstrained; if let Some(result) = record.function_queries[630].get_mut(&__args[..]) { if !__cu && *result.multiplicity == G::ZERO { aiur_fn_630(__args, record, io_buffer, false)? } else { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_630] = unsafe { *(result.output.as_ptr() as *const [G; OUT_630]) }; __ret } } else { aiur_fn_630(__args, record, io_buffer, __cu)? } }; + let __r_arr: [G; OUT_626] = { let __args: [G; IN_626] = [__v_5, __v_69, __v_73]; let __cu = unconstrained; if let Some(result) = record.function_queries[626].get_mut(&__args[..]) { if !__cu && *result.multiplicity == G::ZERO { aiur_fn_626(__args, record, io_buffer, false)? } else { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_626] = unsafe { *(result.output.as_ptr() as *const [G; OUT_626]) }; __ret } } else { aiur_fn_626(__args, record, io_buffer, __cu)? } }; let __v_75: G = __r_arr[0]; match __v_75.as_canonical_u64() { 1u64 => { let __v_76: G = G::from_u64(1); let __v_77: G = (__v_6 + __v_76); - let __r_arr: [G; OUT_639] = { let __args: [G; IN_639] = [__v_0, __v_53, __v_2, __v_3, __v_4, __v_5, __v_77]; let __cu = unconstrained; if let Some(result) = record.function_queries[639].get_mut(&__args[..]) { if !__cu && *result.multiplicity == G::ZERO { aiur_fn_639(__args, record, io_buffer, false)? } else { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_639] = unsafe { *(result.output.as_ptr() as *const [G; OUT_639]) }; __ret } } else { aiur_fn_639(__args, record, io_buffer, __cu)? } }; + let __r_arr: [G; OUT_635] = { let __args: [G; IN_635] = [__v_0, __v_53, __v_2, __v_3, __v_4, __v_5, __v_77]; let __cu = unconstrained; if let Some(result) = record.function_queries[635].get_mut(&__args[..]) { if !__cu && *result.multiplicity == G::ZERO { aiur_fn_635(__args, record, io_buffer, false)? } else { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_635] = unsafe { *(result.output.as_ptr() as *const [G; OUT_635]) }; __ret } } else { aiur_fn_635(__args, record, io_buffer, __cu)? } }; let __v_78: G = __r_arr[0]; - let __ret: [G; OUT_639] = [__v_78]; - if let Some(result) = record.function_queries[639].get_mut(&inp[..]) { debug_assert_eq!(result.output, &__ret[..]); if !unconstrained { *result.multiplicity += G::ONE; } } else { record.function_queries[639].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained)); }; + let __ret: [G; OUT_635] = [__v_78]; + if let Some(result) = record.function_queries[635].get_mut(&inp[..]) { debug_assert_eq!(result.output, &__ret[..]); if !unconstrained { *result.multiplicity += G::ONE; } } else { record.function_queries[635].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained)); }; return Ok(__ret); }, _ => { let __v_76: G = G::from_u64(1); - let __r_arr: [G; OUT_773] = { let __args: [G; IN_773] = [__v_5, __v_69, __v_76, __v_73, __v_74]; let __cu = unconstrained; if let Some(result) = record.function_queries[773].get_mut(&__args[..]) { if !__cu && *result.multiplicity == G::ZERO { aiur_fn_773(__args, record, io_buffer, false)? } else { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_773] = unsafe { *(result.output.as_ptr() as *const [G; OUT_773]) }; __ret } } else { aiur_fn_773(__args, record, io_buffer, __cu)? } }; + let __r_arr: [G; OUT_769] = { let __args: [G; IN_769] = [__v_5, __v_69, __v_76, __v_73, __v_74]; let __cu = unconstrained; if let Some(result) = record.function_queries[769].get_mut(&__args[..]) { if !__cu && *result.multiplicity == G::ZERO { aiur_fn_769(__args, record, io_buffer, false)? } else { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_769] = unsafe { *(result.output.as_ptr() as *const [G; OUT_769]) }; __ret } } else { aiur_fn_769(__args, record, io_buffer, __cu)? } }; let __v_77: G = __r_arr[0]; let __v_78: G = G::from_u64(1); let __v_79: G = (__v_6 + __v_78); - let __r_arr: [G; OUT_639] = { let __args: [G; IN_639] = [__v_0, __v_53, __v_2, __v_3, __v_4, __v_77, __v_79]; let __cu = unconstrained; if let Some(result) = record.function_queries[639].get_mut(&__args[..]) { if !__cu && *result.multiplicity == G::ZERO { aiur_fn_639(__args, record, io_buffer, false)? } else { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_639] = unsafe { *(result.output.as_ptr() as *const [G; OUT_639]) }; __ret } } else { aiur_fn_639(__args, record, io_buffer, __cu)? } }; + let __r_arr: [G; OUT_635] = { let __args: [G; IN_635] = [__v_0, __v_53, __v_2, __v_3, __v_4, __v_77, __v_79]; let __cu = unconstrained; if let Some(result) = record.function_queries[635].get_mut(&__args[..]) { if !__cu && *result.multiplicity == G::ZERO { aiur_fn_635(__args, record, io_buffer, false)? } else { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_635] = unsafe { *(result.output.as_ptr() as *const [G; OUT_635]) }; __ret } } else { aiur_fn_635(__args, record, io_buffer, __cu)? } }; let __v_80: G = __r_arr[0]; - let __ret: [G; OUT_639] = [__v_80]; - if let Some(result) = record.function_queries[639].get_mut(&inp[..]) { debug_assert_eq!(result.output, &__ret[..]); if !unconstrained { *result.multiplicity += G::ONE; } } else { record.function_queries[639].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained)); }; + let __ret: [G; OUT_635] = [__v_80]; + if let Some(result) = record.function_queries[635].get_mut(&inp[..]) { debug_assert_eq!(result.output, &__ret[..]); if !unconstrained { *result.multiplicity += G::ONE; } } else { record.function_queries[635].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained)); }; return Ok(__ret); }, } @@ -54606,10 +54322,10 @@ fn aiur_fn_639( _ => { let __v_54: G = G::from_u64(1); let __v_55: G = (__v_6 + __v_54); - let __r_arr: [G; OUT_639] = { let __args: [G; IN_639] = [__v_0, __v_53, __v_2, __v_3, __v_4, __v_5, __v_55]; let __cu = unconstrained; if let Some(result) = record.function_queries[639].get_mut(&__args[..]) { if !__cu && *result.multiplicity == G::ZERO { aiur_fn_639(__args, record, io_buffer, false)? } else { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_639] = unsafe { *(result.output.as_ptr() as *const [G; OUT_639]) }; __ret } } else { aiur_fn_639(__args, record, io_buffer, __cu)? } }; + let __r_arr: [G; OUT_635] = { let __args: [G; IN_635] = [__v_0, __v_53, __v_2, __v_3, __v_4, __v_5, __v_55]; let __cu = unconstrained; if let Some(result) = record.function_queries[635].get_mut(&__args[..]) { if !__cu && *result.multiplicity == G::ZERO { aiur_fn_635(__args, record, io_buffer, false)? } else { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_635] = unsafe { *(result.output.as_ptr() as *const [G; OUT_635]) }; __ret } } else { aiur_fn_635(__args, record, io_buffer, __cu)? } }; let __v_56: G = __r_arr[0]; - let __ret: [G; OUT_639] = [__v_56]; - if let Some(result) = record.function_queries[639].get_mut(&inp[..]) { debug_assert_eq!(result.output, &__ret[..]); if !unconstrained { *result.multiplicity += G::ONE; } } else { record.function_queries[639].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained)); }; + let __ret: [G; OUT_635] = [__v_56]; + if let Some(result) = record.function_queries[635].get_mut(&inp[..]) { debug_assert_eq!(result.output, &__ret[..]); if !unconstrained { *result.multiplicity += G::ONE; } } else { record.function_queries[635].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained)); }; return Ok(__ret); }, } @@ -54621,15 +54337,15 @@ fn aiur_fn_639( }) } -const INPUT_SIZE_640: usize = 3; -const IN_640: usize = 3; -const OUT_640: usize = 2; -fn aiur_fn_640( - inp: [G; IN_640], +const INPUT_SIZE_636: usize = 3; +const IN_636: usize = 3; +const OUT_636: usize = 2; +fn aiur_fn_636( + inp: [G; IN_636], record: &mut QueryRecord, io_buffer: &mut IOBuffer, unconstrained: bool, -) -> Result<[G; OUT_640], ExecError> { +) -> Result<[G; OUT_636], ExecError> { stacker::maybe_grow(64 * 1024, 4 * 1024 * 1024, || { let __v_0: G = inp[0]; let __v_1: G = inp[1]; @@ -54645,8 +54361,8 @@ fn aiur_fn_640( 1u64 => { let __v_9: G = G::from_u64(0); let __v_10: G = G::from_u64(0); - let __ret: [G; OUT_640] = [__v_9, __v_10]; - if let Some(result) = record.function_queries[640].get_mut(&inp[..]) { debug_assert_eq!(result.output, &__ret[..]); if !unconstrained { *result.multiplicity += G::ONE; } } else { record.function_queries[640].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained)); }; + let __ret: [G; OUT_636] = [__v_9, __v_10]; + if let Some(result) = record.function_queries[636].get_mut(&inp[..]) { debug_assert_eq!(result.output, &__ret[..]); if !unconstrained { *result.multiplicity += G::ONE; } } else { record.function_queries[636].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained)); }; return Ok(__ret); }, 0u64 => { @@ -54655,18 +54371,18 @@ fn aiur_fn_640( match __v_9.as_canonical_u64() { 1u64 => { let __v_10: G = G::from_u64(1); - let __ret: [G; OUT_640] = [__v_10, __v_2]; - if let Some(result) = record.function_queries[640].get_mut(&inp[..]) { debug_assert_eq!(result.output, &__ret[..]); if !unconstrained { *result.multiplicity += G::ONE; } } else { record.function_queries[640].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained)); }; + let __ret: [G; OUT_636] = [__v_10, __v_2]; + if let Some(result) = record.function_queries[636].get_mut(&inp[..]) { debug_assert_eq!(result.output, &__ret[..]); if !unconstrained { *result.multiplicity += G::ONE; } } else { record.function_queries[636].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained)); }; return Ok(__ret); }, _ => { let __v_10: G = G::from_u64(1); let __v_11: G = (__v_2 + __v_10); - let __r_arr: [G; OUT_640] = { let __args: [G; IN_640] = [__v_8, __v_1, __v_11]; let __cu = unconstrained; if let Some(result) = record.function_queries[640].get_mut(&__args[..]) { if !__cu && *result.multiplicity == G::ZERO { aiur_fn_640(__args, record, io_buffer, false)? } else { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_640] = unsafe { *(result.output.as_ptr() as *const [G; OUT_640]) }; __ret } } else { aiur_fn_640(__args, record, io_buffer, __cu)? } }; + let __r_arr: [G; OUT_636] = { let __args: [G; IN_636] = [__v_8, __v_1, __v_11]; let __cu = unconstrained; if let Some(result) = record.function_queries[636].get_mut(&__args[..]) { if !__cu && *result.multiplicity == G::ZERO { aiur_fn_636(__args, record, io_buffer, false)? } else { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_636] = unsafe { *(result.output.as_ptr() as *const [G; OUT_636]) }; __ret } } else { aiur_fn_636(__args, record, io_buffer, __cu)? } }; let __v_12: G = __r_arr[0]; let __v_13: G = __r_arr[1]; - let __ret: [G; OUT_640] = [__v_12, __v_13]; - if let Some(result) = record.function_queries[640].get_mut(&inp[..]) { debug_assert_eq!(result.output, &__ret[..]); if !unconstrained { *result.multiplicity += G::ONE; } } else { record.function_queries[640].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained)); }; + let __ret: [G; OUT_636] = [__v_12, __v_13]; + if let Some(result) = record.function_queries[636].get_mut(&inp[..]) { debug_assert_eq!(result.output, &__ret[..]); if !unconstrained { *result.multiplicity += G::ONE; } } else { record.function_queries[636].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained)); }; return Ok(__ret); }, } @@ -54678,15 +54394,15 @@ fn aiur_fn_640( }) } -const INPUT_SIZE_641: usize = 5; -const IN_641: usize = 5; -const OUT_641: usize = 2; -fn aiur_fn_641( - inp: [G; IN_641], +const INPUT_SIZE_637: usize = 5; +const IN_637: usize = 5; +const OUT_637: usize = 2; +fn aiur_fn_637( + inp: [G; IN_637], record: &mut QueryRecord, io_buffer: &mut IOBuffer, unconstrained: bool, -) -> Result<[G; OUT_641], ExecError> { +) -> Result<[G; OUT_637], ExecError> { stacker::maybe_grow(64 * 1024, 4 * 1024 * 1024, || { let __v_0: G = inp[0]; let __v_1: G = inp[1]; @@ -54704,8 +54420,8 @@ fn aiur_fn_641( 1u64 => { let __v_11: G = G::from_u64(0); let __v_12: G = G::from_u64(0); - let __ret: [G; OUT_641] = [__v_11, __v_12]; - if let Some(result) = record.function_queries[641].get_mut(&inp[..]) { debug_assert_eq!(result.output, &__ret[..]); if !unconstrained { *result.multiplicity += G::ONE; } } else { record.function_queries[641].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained)); }; + let __ret: [G; OUT_637] = [__v_11, __v_12]; + if let Some(result) = record.function_queries[637].get_mut(&inp[..]) { debug_assert_eq!(result.output, &__ret[..]); if !unconstrained { *result.multiplicity += G::ONE; } } else { record.function_queries[637].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained)); }; return Ok(__ret); }, 0u64 => { @@ -54726,7 +54442,7 @@ fn aiur_fn_641( let __v_13: G = __mc_out___mc_0[0]; let __mc_out___mc_1: [G; 1] = '__mc_1: { match __v_2.as_canonical_u64() { 1u64 => { - let __r_arr: [G; OUT_633] = { let __args: [G; IN_633] = [__v_8, __v_3]; let __cu = unconstrained; if let Some(result) = record.function_queries[633].get_mut(&__args[..]) { if !__cu && *result.multiplicity == G::ZERO { aiur_fn_633(__args, record, io_buffer, false)? } else { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_633] = unsafe { *(result.output.as_ptr() as *const [G; OUT_633]) }; __ret } } else { aiur_fn_633(__args, record, io_buffer, __cu)? } }; + let __r_arr: [G; OUT_629] = { let __args: [G; IN_629] = [__v_8, __v_3]; let __cu = unconstrained; if let Some(result) = record.function_queries[629].get_mut(&__args[..]) { if !__cu && *result.multiplicity == G::ZERO { aiur_fn_629(__args, record, io_buffer, false)? } else { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_629] = unsafe { *(result.output.as_ptr() as *const [G; OUT_629]) }; __ret } } else { aiur_fn_629(__args, record, io_buffer, __cu)? } }; let __v_14: G = __r_arr[0]; break '__mc_1 [__v_14]; }, @@ -54742,18 +54458,18 @@ fn aiur_fn_641( match __v_16.as_canonical_u64() { 1u64 => { let __v_17: G = G::from_u64(1); - let __ret: [G; OUT_641] = [__v_17, __v_4]; - if let Some(result) = record.function_queries[641].get_mut(&inp[..]) { debug_assert_eq!(result.output, &__ret[..]); if !unconstrained { *result.multiplicity += G::ONE; } } else { record.function_queries[641].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained)); }; + let __ret: [G; OUT_637] = [__v_17, __v_4]; + if let Some(result) = record.function_queries[637].get_mut(&inp[..]) { debug_assert_eq!(result.output, &__ret[..]); if !unconstrained { *result.multiplicity += G::ONE; } } else { record.function_queries[637].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained)); }; return Ok(__ret); }, _ => { let __v_17: G = G::from_u64(1); let __v_18: G = (__v_4 + __v_17); - let __r_arr: [G; OUT_641] = { let __args: [G; IN_641] = [__v_10, __v_1, __v_2, __v_3, __v_18]; let __cu = unconstrained; if let Some(result) = record.function_queries[641].get_mut(&__args[..]) { if !__cu && *result.multiplicity == G::ZERO { aiur_fn_641(__args, record, io_buffer, false)? } else { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_641] = unsafe { *(result.output.as_ptr() as *const [G; OUT_641]) }; __ret } } else { aiur_fn_641(__args, record, io_buffer, __cu)? } }; + let __r_arr: [G; OUT_637] = { let __args: [G; IN_637] = [__v_10, __v_1, __v_2, __v_3, __v_18]; let __cu = unconstrained; if let Some(result) = record.function_queries[637].get_mut(&__args[..]) { if !__cu && *result.multiplicity == G::ZERO { aiur_fn_637(__args, record, io_buffer, false)? } else { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_637] = unsafe { *(result.output.as_ptr() as *const [G; OUT_637]) }; __ret } } else { aiur_fn_637(__args, record, io_buffer, __cu)? } }; let __v_19: G = __r_arr[0]; let __v_20: G = __r_arr[1]; - let __ret: [G; OUT_641] = [__v_19, __v_20]; - if let Some(result) = record.function_queries[641].get_mut(&inp[..]) { debug_assert_eq!(result.output, &__ret[..]); if !unconstrained { *result.multiplicity += G::ONE; } } else { record.function_queries[641].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained)); }; + let __ret: [G; OUT_637] = [__v_19, __v_20]; + if let Some(result) = record.function_queries[637].get_mut(&inp[..]) { debug_assert_eq!(result.output, &__ret[..]); if !unconstrained { *result.multiplicity += G::ONE; } } else { record.function_queries[637].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained)); }; return Ok(__ret); }, } @@ -54765,15 +54481,15 @@ fn aiur_fn_641( }) } -const INPUT_SIZE_642: usize = 2; -const IN_642: usize = 2; -const OUT_642: usize = 4; -fn aiur_fn_642( - inp: [G; IN_642], +const INPUT_SIZE_638: usize = 2; +const IN_638: usize = 2; +const OUT_638: usize = 4; +fn aiur_fn_638( + inp: [G; IN_638], record: &mut QueryRecord, io_buffer: &mut IOBuffer, unconstrained: bool, -) -> Result<[G; OUT_642], ExecError> { +) -> Result<[G; OUT_638], ExecError> { stacker::maybe_grow(64 * 1024, 4 * 1024 * 1024, || { let __v_0: G = inp[0]; let __v_1: G = inp[1]; @@ -54826,27 +54542,27 @@ fn aiur_fn_642( let __v_45: G = G::from_u64(1); let __v_46: G = G::from_u64(1); let __v_47: G = { let __values: [G; 3] = [__v_45, __v_46, __v_46]; let __mq = record.memory_queries.get_mut(&3).ok_or(ExecError::InvalidMemorySize(3))?; if let Some(result) = __mq.get_mut(&__values[..]) { if !unconstrained { *result.multiplicity += G::ONE; } result.output[0] } else { let __ptr = G::from_usize(__mq.len()); __mq.insert(&__values[..], &[__ptr], G::from_bool(!unconstrained)); __ptr } }; - let __ret: [G; OUT_642] = [__v_40, __v_41, __v_44, __v_47]; - if let Some(result) = record.function_queries[642].get_mut(&inp[..]) { debug_assert_eq!(result.output, &__ret[..]); if !unconstrained { *result.multiplicity += G::ONE; } } else { record.function_queries[642].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained)); }; + let __ret: [G; OUT_638] = [__v_40, __v_41, __v_44, __v_47]; + if let Some(result) = record.function_queries[638].get_mut(&inp[..]) { debug_assert_eq!(result.output, &__ret[..]); if !unconstrained { *result.multiplicity += G::ONE; } } else { record.function_queries[638].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained)); }; return Ok(__ret); }, 0u64 => { match __v_1.as_canonical_u64() { 0u64 => { - let __ret: [G; OUT_642] = [__v_3, __v_4, __v_5, __v_6]; - if let Some(result) = record.function_queries[642].get_mut(&inp[..]) { debug_assert_eq!(result.output, &__ret[..]); if !unconstrained { *result.multiplicity += G::ONE; } } else { record.function_queries[642].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained)); }; + let __ret: [G; OUT_638] = [__v_3, __v_4, __v_5, __v_6]; + if let Some(result) = record.function_queries[638].get_mut(&inp[..]) { debug_assert_eq!(result.output, &__ret[..]); if !unconstrained { *result.multiplicity += G::ONE; } } else { record.function_queries[638].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained)); }; return Ok(__ret); }, _ => { let __v_8: G = G::from_u64(1); let __v_9: G = (__v_1 - __v_8); - let __r_arr: [G; OUT_642] = { let __args: [G; IN_642] = [__v_7, __v_9]; let __cu = unconstrained; if let Some(result) = record.function_queries[642].get_mut(&__args[..]) { if !__cu && *result.multiplicity == G::ZERO { aiur_fn_642(__args, record, io_buffer, false)? } else { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_642] = unsafe { *(result.output.as_ptr() as *const [G; OUT_642]) }; __ret } } else { aiur_fn_642(__args, record, io_buffer, __cu)? } }; + let __r_arr: [G; OUT_638] = { let __args: [G; IN_638] = [__v_7, __v_9]; let __cu = unconstrained; if let Some(result) = record.function_queries[638].get_mut(&__args[..]) { if !__cu && *result.multiplicity == G::ZERO { aiur_fn_638(__args, record, io_buffer, false)? } else { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_638] = unsafe { *(result.output.as_ptr() as *const [G; OUT_638]) }; __ret } } else { aiur_fn_638(__args, record, io_buffer, __cu)? } }; let __v_10: G = __r_arr[0]; let __v_11: G = __r_arr[1]; let __v_12: G = __r_arr[2]; let __v_13: G = __r_arr[3]; - let __ret: [G; OUT_642] = [__v_10, __v_11, __v_12, __v_13]; - if let Some(result) = record.function_queries[642].get_mut(&inp[..]) { debug_assert_eq!(result.output, &__ret[..]); if !unconstrained { *result.multiplicity += G::ONE; } } else { record.function_queries[642].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained)); }; + let __ret: [G; OUT_638] = [__v_10, __v_11, __v_12, __v_13]; + if let Some(result) = record.function_queries[638].get_mut(&inp[..]) { debug_assert_eq!(result.output, &__ret[..]); if !unconstrained { *result.multiplicity += G::ONE; } } else { record.function_queries[638].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained)); }; return Ok(__ret); }, } @@ -54858,15 +54574,15 @@ fn aiur_fn_642( }) } -const INPUT_SIZE_643: usize = 4; -const IN_643: usize = 4; -const OUT_643: usize = 1; -fn aiur_fn_643( - inp: [G; IN_643], +const INPUT_SIZE_639: usize = 4; +const IN_639: usize = 4; +const OUT_639: usize = 1; +fn aiur_fn_639( + inp: [G; IN_639], record: &mut QueryRecord, io_buffer: &mut IOBuffer, unconstrained: bool, -) -> Result<[G; OUT_643], ExecError> { +) -> Result<[G; OUT_639], ExecError> { stacker::maybe_grow(64 * 1024, 4 * 1024 * 1024, || { let __v_0: G = inp[0]; let __v_1: G = inp[1]; @@ -54880,20 +54596,20 @@ fn aiur_fn_643( let __v_7: G = (__v_6 - __v_0); let __v_8: G = G::from_u64(0); let __v_9: G = { let __values: [G; 4] = [__v_4, __v_7, __v_8, __v_8]; let __mq = record.memory_queries.get_mut(&4).ok_or(ExecError::InvalidMemorySize(4))?; if let Some(result) = __mq.get_mut(&__values[..]) { if !unconstrained { *result.multiplicity += G::ONE; } result.output[0] } else { let __ptr = G::from_usize(__mq.len()); __mq.insert(&__values[..], &[__ptr], G::from_bool(!unconstrained)); __ptr } }; - let __ret: [G; OUT_643] = [__v_9]; - if let Some(result) = record.function_queries[643].get_mut(&inp[..]) { debug_assert_eq!(result.output, &__ret[..]); if !unconstrained { *result.multiplicity += G::ONE; } } else { record.function_queries[643].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained)); }; + let __ret: [G; OUT_639] = [__v_9]; + if let Some(result) = record.function_queries[639].get_mut(&inp[..]) { debug_assert_eq!(result.output, &__ret[..]); if !unconstrained { *result.multiplicity += G::ONE; } } else { record.function_queries[639].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained)); }; return Ok(__ret); }, _ => { - let __r_arr: [G; OUT_764] = { let __args: [G; IN_764] = [__v_3]; let __cu = unconstrained; if let Some(result) = record.function_queries[764].get_mut(&__args[..]) { if !__cu && *result.multiplicity == G::ZERO { aiur_fn_764(__args, record, io_buffer, false)? } else { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_764] = unsafe { *(result.output.as_ptr() as *const [G; OUT_764]) }; __ret } } else { aiur_fn_764(__args, record, io_buffer, __cu)? } }; + let __r_arr: [G; OUT_760] = { let __args: [G; IN_760] = [__v_3]; let __cu = unconstrained; if let Some(result) = record.function_queries[760].get_mut(&__args[..]) { if !__cu && *result.multiplicity == G::ZERO { aiur_fn_760(__args, record, io_buffer, false)? } else { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_760] = unsafe { *(result.output.as_ptr() as *const [G; OUT_760]) }; __ret } } else { aiur_fn_760(__args, record, io_buffer, __cu)? } }; let __v_4: G = __r_arr[0]; let __v_5: G = { let __a_val = __v_0.as_canonical_u64(); let __b_val = __v_4.as_canonical_u64(); let __a_u32 = u32::try_from(__a_val).ok().ok_or(ExecError::U32OutOfRange(__a_val))?; let __b_u32 = u32::try_from(__b_val).ok().ok_or(ExecError::U32OutOfRange(__b_val))?; let __result = G::from_bool(__a_u32 < __b_u32); if !unconstrained { let __x_bytes = __a_u32.to_le_bytes(); let __z_bytes = __b_u32.to_le_bytes(); let __c_u32 = __b_u32.wrapping_sub(__a_u32).wrapping_sub(1); let __y_bytes = __c_u32.to_le_bytes(); record.bytes2_queries.bump_range_check(&G::from_u8(__x_bytes[0]), &G::from_u8(__x_bytes[1])); record.bytes2_queries.bump_range_check(&G::from_u8(__x_bytes[2]), &G::from_u8(__x_bytes[3])); record.bytes2_queries.bump_range_check(&G::from_u8(__y_bytes[0]), &G::from_u8(__y_bytes[1])); record.bytes2_queries.bump_range_check(&G::from_u8(__y_bytes[2]), &G::from_u8(__y_bytes[3])); record.bytes2_queries.bump_range_check(&G::from_u8(__z_bytes[0]), &G::from_u8(__z_bytes[1])); record.bytes2_queries.bump_range_check(&G::from_u8(__z_bytes[2]), &G::from_u8(__z_bytes[3])); } __result }; match __v_5.as_canonical_u64() { 1u64 => { - let __r_arr: [G; OUT_766] = { let __args: [G; IN_766] = [__v_3, __v_0]; let __cu = unconstrained; if let Some(result) = record.function_queries[766].get_mut(&__args[..]) { if !__cu && *result.multiplicity == G::ZERO { aiur_fn_766(__args, record, io_buffer, false)? } else { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_766] = unsafe { *(result.output.as_ptr() as *const [G; OUT_766]) }; __ret } } else { aiur_fn_766(__args, record, io_buffer, __cu)? } }; + let __r_arr: [G; OUT_762] = { let __args: [G; IN_762] = [__v_3, __v_0]; let __cu = unconstrained; if let Some(result) = record.function_queries[762].get_mut(&__args[..]) { if !__cu && *result.multiplicity == G::ZERO { aiur_fn_762(__args, record, io_buffer, false)? } else { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_762] = unsafe { *(result.output.as_ptr() as *const [G; OUT_762]) }; __ret } } else { aiur_fn_762(__args, record, io_buffer, __cu)? } }; let __v_6: G = __r_arr[0]; - let __ret: [G; OUT_643] = [__v_6]; - if let Some(result) = record.function_queries[643].get_mut(&inp[..]) { debug_assert_eq!(result.output, &__ret[..]); if !unconstrained { *result.multiplicity += G::ONE; } } else { record.function_queries[643].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained)); }; + let __ret: [G; OUT_639] = [__v_6]; + if let Some(result) = record.function_queries[639].get_mut(&inp[..]) { debug_assert_eq!(result.output, &__ret[..]); if !unconstrained { *result.multiplicity += G::ONE; } } else { record.function_queries[639].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained)); }; return Ok(__ret); }, _ => { @@ -54903,8 +54619,8 @@ fn aiur_fn_643( let __v_9: G = (__v_8 - __v_0); let __v_10: G = G::from_u64(0); let __v_11: G = { let __values: [G; 4] = [__v_6, __v_9, __v_10, __v_10]; let __mq = record.memory_queries.get_mut(&4).ok_or(ExecError::InvalidMemorySize(4))?; if let Some(result) = __mq.get_mut(&__values[..]) { if !unconstrained { *result.multiplicity += G::ONE; } result.output[0] } else { let __ptr = G::from_usize(__mq.len()); __mq.insert(&__values[..], &[__ptr], G::from_bool(!unconstrained)); __ptr } }; - let __ret: [G; OUT_643] = [__v_11]; - if let Some(result) = record.function_queries[643].get_mut(&inp[..]) { debug_assert_eq!(result.output, &__ret[..]); if !unconstrained { *result.multiplicity += G::ONE; } } else { record.function_queries[643].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained)); }; + let __ret: [G; OUT_639] = [__v_11]; + if let Some(result) = record.function_queries[639].get_mut(&inp[..]) { debug_assert_eq!(result.output, &__ret[..]); if !unconstrained { *result.multiplicity += G::ONE; } } else { record.function_queries[639].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained)); }; return Ok(__ret); }, } @@ -54913,15 +54629,15 @@ fn aiur_fn_643( }) } -const INPUT_SIZE_644: usize = 6; -const IN_644: usize = 6; -const OUT_644: usize = 1; -fn aiur_fn_644( - inp: [G; IN_644], +const INPUT_SIZE_640: usize = 6; +const IN_640: usize = 6; +const OUT_640: usize = 1; +fn aiur_fn_640( + inp: [G; IN_640], record: &mut QueryRecord, io_buffer: &mut IOBuffer, unconstrained: bool, -) -> Result<[G; OUT_644], ExecError> { +) -> Result<[G; OUT_640], ExecError> { stacker::maybe_grow(64 * 1024, 4 * 1024 * 1024, || { let __v_0: G = inp[0]; let __v_1: G = inp[1]; @@ -54931,8 +54647,8 @@ fn aiur_fn_644( let __v_5: G = inp[5]; match __v_1.as_canonical_u64() { 0u64 => { - let __ret: [G; OUT_644] = [__v_0]; - if let Some(result) = record.function_queries[644].get_mut(&inp[..]) { debug_assert_eq!(result.output, &__ret[..]); if !unconstrained { *result.multiplicity += G::ONE; } } else { record.function_queries[644].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained)); }; + let __ret: [G; OUT_640] = [__v_0]; + if let Some(result) = record.function_queries[640].get_mut(&inp[..]) { debug_assert_eq!(result.output, &__ret[..]); if !unconstrained { *result.multiplicity += G::ONE; } } else { record.function_queries[640].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained)); }; return Ok(__ret); }, _ => { @@ -54943,19 +54659,19 @@ fn aiur_fn_644( let __v_9: G = __loaded[3]; match __v_6.as_canonical_u64() { 5u64 => { - let __r_arr: [G; OUT_643] = { let __args: [G; IN_643] = [__v_5, __v_2, __v_3, __v_4]; let __cu = unconstrained; if let Some(result) = record.function_queries[643].get_mut(&__args[..]) { if !__cu && *result.multiplicity == G::ZERO { aiur_fn_643(__args, record, io_buffer, false)? } else { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_643] = unsafe { *(result.output.as_ptr() as *const [G; OUT_643]) }; __ret } } else { aiur_fn_643(__args, record, io_buffer, __cu)? } }; + let __r_arr: [G; OUT_639] = { let __args: [G; IN_639] = [__v_5, __v_2, __v_3, __v_4]; let __cu = unconstrained; if let Some(result) = record.function_queries[639].get_mut(&__args[..]) { if !__cu && *result.multiplicity == G::ZERO { aiur_fn_639(__args, record, io_buffer, false)? } else { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_639] = unsafe { *(result.output.as_ptr() as *const [G; OUT_639]) }; __ret } } else { aiur_fn_639(__args, record, io_buffer, __cu)? } }; let __v_10: G = __r_arr[0]; let __v_11: G = G::from_u64(0); - let __r_arr: [G; OUT_368] = { let __args: [G; IN_368] = [__v_8, __v_10, __v_11]; let __cu = unconstrained; if let Some(result) = record.function_queries[368].get_mut(&__args[..]) { if !__cu && *result.multiplicity == G::ZERO { aiur_fn_368(__args, record, io_buffer, false)? } else { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_368] = unsafe { *(result.output.as_ptr() as *const [G; OUT_368]) }; __ret } } else { aiur_fn_368(__args, record, io_buffer, __cu)? } }; + let __r_arr: [G; OUT_364] = { let __args: [G; IN_364] = [__v_8, __v_10, __v_11]; let __cu = unconstrained; if let Some(result) = record.function_queries[364].get_mut(&__args[..]) { if !__cu && *result.multiplicity == G::ZERO { aiur_fn_364(__args, record, io_buffer, false)? } else { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_364] = unsafe { *(result.output.as_ptr() as *const [G; OUT_364]) }; __ret } } else { aiur_fn_364(__args, record, io_buffer, __cu)? } }; let __v_12: G = __r_arr[0]; let __v_13: G = G::from_u64(1); let __v_14: G = (__v_1 - __v_13); let __v_15: G = G::from_u64(1); let __v_16: G = (__v_5 + __v_15); - let __r_arr: [G; OUT_644] = { let __args: [G; IN_644] = [__v_12, __v_14, __v_2, __v_3, __v_4, __v_16]; let __cu = unconstrained; if let Some(result) = record.function_queries[644].get_mut(&__args[..]) { if !__cu && *result.multiplicity == G::ZERO { aiur_fn_644(__args, record, io_buffer, false)? } else { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_644] = unsafe { *(result.output.as_ptr() as *const [G; OUT_644]) }; __ret } } else { aiur_fn_644(__args, record, io_buffer, __cu)? } }; + let __r_arr: [G; OUT_640] = { let __args: [G; IN_640] = [__v_12, __v_14, __v_2, __v_3, __v_4, __v_16]; let __cu = unconstrained; if let Some(result) = record.function_queries[640].get_mut(&__args[..]) { if !__cu && *result.multiplicity == G::ZERO { aiur_fn_640(__args, record, io_buffer, false)? } else { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_640] = unsafe { *(result.output.as_ptr() as *const [G; OUT_640]) }; __ret } } else { aiur_fn_640(__args, record, io_buffer, __cu)? } }; let __v_17: G = __r_arr[0]; - let __ret: [G; OUT_644] = [__v_17]; - if let Some(result) = record.function_queries[644].get_mut(&inp[..]) { debug_assert_eq!(result.output, &__ret[..]); if !unconstrained { *result.multiplicity += G::ONE; } } else { record.function_queries[644].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained)); }; + let __ret: [G; OUT_640] = [__v_17]; + if let Some(result) = record.function_queries[640].get_mut(&inp[..]) { debug_assert_eq!(result.output, &__ret[..]); if !unconstrained { *result.multiplicity += G::ONE; } } else { record.function_queries[640].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained)); }; return Ok(__ret); }, _ => { @@ -54967,15 +54683,15 @@ fn aiur_fn_644( }) } -const INPUT_SIZE_645: usize = 2; -const IN_645: usize = 2; -const OUT_645: usize = 1; -fn aiur_fn_645( - inp: [G; IN_645], +const INPUT_SIZE_641: usize = 2; +const IN_641: usize = 2; +const OUT_641: usize = 1; +fn aiur_fn_641( + inp: [G; IN_641], record: &mut QueryRecord, io_buffer: &mut IOBuffer, unconstrained: bool, -) -> Result<[G; OUT_645], ExecError> { +) -> Result<[G; OUT_641], ExecError> { stacker::maybe_grow(64 * 1024, 4 * 1024 * 1024, || { let __v_0: G = inp[0]; let __v_1: G = inp[1]; @@ -54984,8 +54700,8 @@ fn aiur_fn_645( let __v_2: G = G::from_u64(1); let __v_3: G = G::from_u64(1); let __v_4: G = { let __values: [G; 3] = [__v_2, __v_3, __v_3]; let __mq = record.memory_queries.get_mut(&3).ok_or(ExecError::InvalidMemorySize(3))?; if let Some(result) = __mq.get_mut(&__values[..]) { if !unconstrained { *result.multiplicity += G::ONE; } result.output[0] } else { let __ptr = G::from_usize(__mq.len()); __mq.insert(&__values[..], &[__ptr], G::from_bool(!unconstrained)); __ptr } }; - let __ret: [G; OUT_645] = [__v_4]; - if let Some(result) = record.function_queries[645].get_mut(&inp[..]) { debug_assert_eq!(result.output, &__ret[..]); if !unconstrained { *result.multiplicity += G::ONE; } } else { record.function_queries[645].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained)); }; + let __ret: [G; OUT_641] = [__v_4]; + if let Some(result) = record.function_queries[641].get_mut(&inp[..]) { debug_assert_eq!(result.output, &__ret[..]); if !unconstrained { *result.multiplicity += G::ONE; } } else { record.function_queries[641].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained)); }; return Ok(__ret); }, _ => { @@ -54999,18 +54715,18 @@ fn aiur_fn_645( let __v_6: G = G::from_u64(0); let __v_7: G = G::from_u64(1); let __v_8: G = (__v_1 - __v_7); - let __r_arr: [G; OUT_645] = { let __args: [G; IN_645] = [__v_4, __v_8]; let __cu = unconstrained; if let Some(result) = record.function_queries[645].get_mut(&__args[..]) { if !__cu && *result.multiplicity == G::ZERO { aiur_fn_645(__args, record, io_buffer, false)? } else { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_645] = unsafe { *(result.output.as_ptr() as *const [G; OUT_645]) }; __ret } } else { aiur_fn_645(__args, record, io_buffer, __cu)? } }; + let __r_arr: [G; OUT_641] = { let __args: [G; IN_641] = [__v_4, __v_8]; let __cu = unconstrained; if let Some(result) = record.function_queries[641].get_mut(&__args[..]) { if !__cu && *result.multiplicity == G::ZERO { aiur_fn_641(__args, record, io_buffer, false)? } else { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_641] = unsafe { *(result.output.as_ptr() as *const [G; OUT_641]) }; __ret } } else { aiur_fn_641(__args, record, io_buffer, __cu)? } }; let __v_9: G = __r_arr[0]; let __v_10: G = { let __values: [G; 3] = [__v_6, __v_3, __v_9]; let __mq = record.memory_queries.get_mut(&3).ok_or(ExecError::InvalidMemorySize(3))?; if let Some(result) = __mq.get_mut(&__values[..]) { if !unconstrained { *result.multiplicity += G::ONE; } result.output[0] } else { let __ptr = G::from_usize(__mq.len()); __mq.insert(&__values[..], &[__ptr], G::from_bool(!unconstrained)); __ptr } }; - let __ret: [G; OUT_645] = [__v_10]; - if let Some(result) = record.function_queries[645].get_mut(&inp[..]) { debug_assert_eq!(result.output, &__ret[..]); if !unconstrained { *result.multiplicity += G::ONE; } } else { record.function_queries[645].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained)); }; + let __ret: [G; OUT_641] = [__v_10]; + if let Some(result) = record.function_queries[641].get_mut(&inp[..]) { debug_assert_eq!(result.output, &__ret[..]); if !unconstrained { *result.multiplicity += G::ONE; } } else { record.function_queries[641].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained)); }; return Ok(__ret); }, _ => { let __v_6: G = G::from_u64(1); let __v_7: G = G::from_u64(1); let __v_8: G = { let __values: [G; 3] = [__v_6, __v_7, __v_7]; let __mq = record.memory_queries.get_mut(&3).ok_or(ExecError::InvalidMemorySize(3))?; if let Some(result) = __mq.get_mut(&__values[..]) { if !unconstrained { *result.multiplicity += G::ONE; } result.output[0] } else { let __ptr = G::from_usize(__mq.len()); __mq.insert(&__values[..], &[__ptr], G::from_bool(!unconstrained)); __ptr } }; - let __r_arr: [G; OUT_418] = { let __args: [G; IN_418] = [__v_0, __v_8]; let __cu = unconstrained; if let Some(result) = record.function_queries[418].get_mut(&__args[..]) { if !__cu && *result.multiplicity == G::ZERO { aiur_fn_418(__args, record, io_buffer, false)? } else { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_418] = unsafe { *(result.output.as_ptr() as *const [G; OUT_418]) }; __ret } } else { aiur_fn_418(__args, record, io_buffer, __cu)? } }; + let __r_arr: [G; OUT_414] = { let __args: [G; IN_414] = [__v_0, __v_8]; let __cu = unconstrained; if let Some(result) = record.function_queries[414].get_mut(&__args[..]) { if !__cu && *result.multiplicity == G::ZERO { aiur_fn_414(__args, record, io_buffer, false)? } else { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_414] = unsafe { *(result.output.as_ptr() as *const [G; OUT_414]) }; __ret } } else { aiur_fn_414(__args, record, io_buffer, __cu)? } }; let __v_9: G = __r_arr[0]; let __loaded: [G; 4] = { let __mq = record.memory_queries.get_mut(&4).ok_or(ExecError::InvalidMemorySize(4))?; let __ptr_u64 = __v_9.as_canonical_u64(); let __ptr_usize = usize::try_from(__ptr_u64).ok().ok_or(ExecError::PointerTooLarge(__ptr_u64))?; let (__args, __mult) = __mq.get_index_mut(__ptr_usize).ok_or(ExecError::UnboundPointer { ptr: __ptr_u64, size: 4 })?; if !unconstrained { *__mult += G::ONE; } let __arr: [G; 4] = __args[..4].try_into().unwrap(); __arr }; let __v_10: G = __loaded[0]; @@ -55022,19 +54738,19 @@ fn aiur_fn_645( let __v_14: G = G::from_u64(0); let __v_15: G = G::from_u64(1); let __v_16: G = (__v_1 - __v_15); - let __r_arr: [G; OUT_645] = { let __args: [G; IN_645] = [__v_12, __v_16]; let __cu = unconstrained; if let Some(result) = record.function_queries[645].get_mut(&__args[..]) { if !__cu && *result.multiplicity == G::ZERO { aiur_fn_645(__args, record, io_buffer, false)? } else { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_645] = unsafe { *(result.output.as_ptr() as *const [G; OUT_645]) }; __ret } } else { aiur_fn_645(__args, record, io_buffer, __cu)? } }; + let __r_arr: [G; OUT_641] = { let __args: [G; IN_641] = [__v_12, __v_16]; let __cu = unconstrained; if let Some(result) = record.function_queries[641].get_mut(&__args[..]) { if !__cu && *result.multiplicity == G::ZERO { aiur_fn_641(__args, record, io_buffer, false)? } else { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_641] = unsafe { *(result.output.as_ptr() as *const [G; OUT_641]) }; __ret } } else { aiur_fn_641(__args, record, io_buffer, __cu)? } }; let __v_17: G = __r_arr[0]; let __v_18: G = { let __values: [G; 3] = [__v_14, __v_11, __v_17]; let __mq = record.memory_queries.get_mut(&3).ok_or(ExecError::InvalidMemorySize(3))?; if let Some(result) = __mq.get_mut(&__values[..]) { if !unconstrained { *result.multiplicity += G::ONE; } result.output[0] } else { let __ptr = G::from_usize(__mq.len()); __mq.insert(&__values[..], &[__ptr], G::from_bool(!unconstrained)); __ptr } }; - let __ret: [G; OUT_645] = [__v_18]; - if let Some(result) = record.function_queries[645].get_mut(&inp[..]) { debug_assert_eq!(result.output, &__ret[..]); if !unconstrained { *result.multiplicity += G::ONE; } } else { record.function_queries[645].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained)); }; + let __ret: [G; OUT_641] = [__v_18]; + if let Some(result) = record.function_queries[641].get_mut(&inp[..]) { debug_assert_eq!(result.output, &__ret[..]); if !unconstrained { *result.multiplicity += G::ONE; } } else { record.function_queries[641].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained)); }; return Ok(__ret); }, _ => { let __v_14: G = G::from_u64(1); let __v_15: G = G::from_u64(1); let __v_16: G = { let __values: [G; 3] = [__v_14, __v_15, __v_15]; let __mq = record.memory_queries.get_mut(&3).ok_or(ExecError::InvalidMemorySize(3))?; if let Some(result) = __mq.get_mut(&__values[..]) { if !unconstrained { *result.multiplicity += G::ONE; } result.output[0] } else { let __ptr = G::from_usize(__mq.len()); __mq.insert(&__values[..], &[__ptr], G::from_bool(!unconstrained)); __ptr } }; - let __ret: [G; OUT_645] = [__v_16]; - if let Some(result) = record.function_queries[645].get_mut(&inp[..]) { debug_assert_eq!(result.output, &__ret[..]); if !unconstrained { *result.multiplicity += G::ONE; } } else { record.function_queries[645].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained)); }; + let __ret: [G; OUT_641] = [__v_16]; + if let Some(result) = record.function_queries[641].get_mut(&inp[..]) { debug_assert_eq!(result.output, &__ret[..]); if !unconstrained { *result.multiplicity += G::ONE; } } else { record.function_queries[641].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained)); }; return Ok(__ret); }, } @@ -55045,15 +54761,15 @@ fn aiur_fn_645( }) } -const INPUT_SIZE_646: usize = 4; -const IN_646: usize = 4; -const OUT_646: usize = 1; -fn aiur_fn_646( - inp: [G; IN_646], +const INPUT_SIZE_642: usize = 4; +const IN_642: usize = 4; +const OUT_642: usize = 1; +fn aiur_fn_642( + inp: [G; IN_642], record: &mut QueryRecord, io_buffer: &mut IOBuffer, unconstrained: bool, -) -> Result<[G; OUT_646], ExecError> { +) -> Result<[G; OUT_642], ExecError> { stacker::maybe_grow(64 * 1024, 4 * 1024 * 1024, || { let __v_0: G = inp[0]; let __v_1: G = inp[1]; @@ -55062,8 +54778,8 @@ fn aiur_fn_646( let __v_4: G = (__v_1 - __v_3); match __v_4.as_canonical_u64() { 0u64 => { - let __ret: [G; OUT_646] = [__v_0]; - if let Some(result) = record.function_queries[646].get_mut(&inp[..]) { debug_assert_eq!(result.output, &__ret[..]); if !unconstrained { *result.multiplicity += G::ONE; } } else { record.function_queries[646].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained)); }; + let __ret: [G; OUT_642] = [__v_0]; + if let Some(result) = record.function_queries[642].get_mut(&inp[..]) { debug_assert_eq!(result.output, &__ret[..]); if !unconstrained { *result.multiplicity += G::ONE; } } else { record.function_queries[642].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained)); }; return Ok(__ret); }, _ => { @@ -55079,25 +54795,25 @@ fn aiur_fn_646( let __v_14: G = { let __values: [G; 4] = [__v_12, __v_0, __v_11, __v_13]; let __mq = record.memory_queries.get_mut(&4).ok_or(ExecError::InvalidMemorySize(4))?; if let Some(result) = __mq.get_mut(&__values[..]) { if !unconstrained { *result.multiplicity += G::ONE; } result.output[0] } else { let __ptr = G::from_usize(__mq.len()); __mq.insert(&__values[..], &[__ptr], G::from_bool(!unconstrained)); __ptr } }; let __v_15: G = G::from_u64(1); let __v_16: G = (__v_3 + __v_15); - let __r_arr: [G; OUT_646] = { let __args: [G; IN_646] = [__v_14, __v_1, __v_2, __v_16]; let __cu = unconstrained; if let Some(result) = record.function_queries[646].get_mut(&__args[..]) { if !__cu && *result.multiplicity == G::ZERO { aiur_fn_646(__args, record, io_buffer, false)? } else { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_646] = unsafe { *(result.output.as_ptr() as *const [G; OUT_646]) }; __ret } } else { aiur_fn_646(__args, record, io_buffer, __cu)? } }; + let __r_arr: [G; OUT_642] = { let __args: [G; IN_642] = [__v_14, __v_1, __v_2, __v_16]; let __cu = unconstrained; if let Some(result) = record.function_queries[642].get_mut(&__args[..]) { if !__cu && *result.multiplicity == G::ZERO { aiur_fn_642(__args, record, io_buffer, false)? } else { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_642] = unsafe { *(result.output.as_ptr() as *const [G; OUT_642]) }; __ret } } else { aiur_fn_642(__args, record, io_buffer, __cu)? } }; let __v_17: G = __r_arr[0]; - let __ret: [G; OUT_646] = [__v_17]; - if let Some(result) = record.function_queries[646].get_mut(&inp[..]) { debug_assert_eq!(result.output, &__ret[..]); if !unconstrained { *result.multiplicity += G::ONE; } } else { record.function_queries[646].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained)); }; + let __ret: [G; OUT_642] = [__v_17]; + if let Some(result) = record.function_queries[642].get_mut(&inp[..]) { debug_assert_eq!(result.output, &__ret[..]); if !unconstrained { *result.multiplicity += G::ONE; } } else { record.function_queries[642].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained)); }; return Ok(__ret); }, } }) } -const INPUT_SIZE_647: usize = 3; -const IN_647: usize = 3; -const OUT_647: usize = 1; -fn aiur_fn_647( - inp: [G; IN_647], +const INPUT_SIZE_643: usize = 3; +const IN_643: usize = 3; +const OUT_643: usize = 1; +fn aiur_fn_643( + inp: [G; IN_643], record: &mut QueryRecord, io_buffer: &mut IOBuffer, unconstrained: bool, -) -> Result<[G; OUT_647], ExecError> { +) -> Result<[G; OUT_643], ExecError> { stacker::maybe_grow(64 * 1024, 4 * 1024 * 1024, || { let __v_0: G = inp[0]; let __v_1: G = inp[1]; @@ -55108,21 +54824,21 @@ fn aiur_fn_647( let __v_5: G = __loaded[2]; match __v_3.as_canonical_u64() { 1u64 => { - let __ret: [G; OUT_647] = [__v_0]; - if let Some(result) = record.function_queries[647].get_mut(&inp[..]) { debug_assert_eq!(result.output, &__ret[..]); if !unconstrained { *result.multiplicity += G::ONE; } } else { record.function_queries[647].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained)); }; + let __ret: [G; OUT_643] = [__v_0]; + if let Some(result) = record.function_queries[643].get_mut(&inp[..]) { debug_assert_eq!(result.output, &__ret[..]); if !unconstrained { *result.multiplicity += G::ONE; } } else { record.function_queries[643].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained)); }; return Ok(__ret); }, 0u64 => { let __v_6: G = G::from_u64(0); - let __r_arr: [G; OUT_359] = { let __args: [G; IN_359] = [__v_4, __v_2, __v_6]; let __cu = unconstrained; if let Some(result) = record.function_queries[359].get_mut(&__args[..]) { if !__cu && *result.multiplicity == G::ZERO { aiur_fn_359(__args, record, io_buffer, false)? } else { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_359] = unsafe { *(result.output.as_ptr() as *const [G; OUT_359]) }; __ret } } else { aiur_fn_359(__args, record, io_buffer, __cu)? } }; + let __r_arr: [G; OUT_355] = { let __args: [G; IN_355] = [__v_4, __v_2, __v_6]; let __cu = unconstrained; if let Some(result) = record.function_queries[355].get_mut(&__args[..]) { if !__cu && *result.multiplicity == G::ZERO { aiur_fn_355(__args, record, io_buffer, false)? } else { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_355] = unsafe { *(result.output.as_ptr() as *const [G; OUT_355]) }; __ret } } else { aiur_fn_355(__args, record, io_buffer, __cu)? } }; let __v_7: G = __r_arr[0]; let __v_8: G = G::from_u64(3); let __v_9: G = G::from_u64(0); let __v_10: G = { let __values: [G; 4] = [__v_8, __v_0, __v_7, __v_9]; let __mq = record.memory_queries.get_mut(&4).ok_or(ExecError::InvalidMemorySize(4))?; if let Some(result) = __mq.get_mut(&__values[..]) { if !unconstrained { *result.multiplicity += G::ONE; } result.output[0] } else { let __ptr = G::from_usize(__mq.len()); __mq.insert(&__values[..], &[__ptr], G::from_bool(!unconstrained)); __ptr } }; - let __r_arr: [G; OUT_647] = { let __args: [G; IN_647] = [__v_10, __v_5, __v_2]; let __cu = unconstrained; if let Some(result) = record.function_queries[647].get_mut(&__args[..]) { if !__cu && *result.multiplicity == G::ZERO { aiur_fn_647(__args, record, io_buffer, false)? } else { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_647] = unsafe { *(result.output.as_ptr() as *const [G; OUT_647]) }; __ret } } else { aiur_fn_647(__args, record, io_buffer, __cu)? } }; + let __r_arr: [G; OUT_643] = { let __args: [G; IN_643] = [__v_10, __v_5, __v_2]; let __cu = unconstrained; if let Some(result) = record.function_queries[643].get_mut(&__args[..]) { if !__cu && *result.multiplicity == G::ZERO { aiur_fn_643(__args, record, io_buffer, false)? } else { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_643] = unsafe { *(result.output.as_ptr() as *const [G; OUT_643]) }; __ret } } else { aiur_fn_643(__args, record, io_buffer, __cu)? } }; let __v_11: G = __r_arr[0]; - let __ret: [G; OUT_647] = [__v_11]; - if let Some(result) = record.function_queries[647].get_mut(&inp[..]) { debug_assert_eq!(result.output, &__ret[..]); if !unconstrained { *result.multiplicity += G::ONE; } } else { record.function_queries[647].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained)); }; + let __ret: [G; OUT_643] = [__v_11]; + if let Some(result) = record.function_queries[643].get_mut(&inp[..]) { debug_assert_eq!(result.output, &__ret[..]); if !unconstrained { *result.multiplicity += G::ONE; } } else { record.function_queries[643].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained)); }; return Ok(__ret); }, _ => { @@ -55132,15 +54848,15 @@ fn aiur_fn_647( }) } -const INPUT_SIZE_648: usize = 5; -const IN_648: usize = 5; -const OUT_648: usize = 1; -fn aiur_fn_648( - inp: [G; IN_648], +const INPUT_SIZE_644: usize = 5; +const IN_644: usize = 5; +const OUT_644: usize = 1; +fn aiur_fn_644( + inp: [G; IN_644], record: &mut QueryRecord, io_buffer: &mut IOBuffer, unconstrained: bool, -) -> Result<[G; OUT_648], ExecError> { +) -> Result<[G; OUT_644], ExecError> { stacker::maybe_grow(64 * 1024, 4 * 1024 * 1024, || { let __v_0: G = inp[0]; let __v_1: G = inp[1]; @@ -55150,32 +54866,32 @@ fn aiur_fn_648( match __v_3.as_canonical_u64() { 0u64 => { let __v_5: G = G::from_u64(0); - let __r_arr: [G; OUT_646] = { let __args: [G; IN_646] = [__v_0, __v_1, __v_2, __v_5]; let __cu = unconstrained; if let Some(result) = record.function_queries[646].get_mut(&__args[..]) { if !__cu && *result.multiplicity == G::ZERO { aiur_fn_646(__args, record, io_buffer, false)? } else { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_646] = unsafe { *(result.output.as_ptr() as *const [G; OUT_646]) }; __ret } } else { aiur_fn_646(__args, record, io_buffer, __cu)? } }; + let __r_arr: [G; OUT_642] = { let __args: [G; IN_642] = [__v_0, __v_1, __v_2, __v_5]; let __cu = unconstrained; if let Some(result) = record.function_queries[642].get_mut(&__args[..]) { if !__cu && *result.multiplicity == G::ZERO { aiur_fn_642(__args, record, io_buffer, false)? } else { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_642] = unsafe { *(result.output.as_ptr() as *const [G; OUT_642]) }; __ret } } else { aiur_fn_642(__args, record, io_buffer, __cu)? } }; let __v_6: G = __r_arr[0]; - let __ret: [G; OUT_648] = [__v_6]; - if let Some(result) = record.function_queries[648].get_mut(&inp[..]) { debug_assert_eq!(result.output, &__ret[..]); if !unconstrained { *result.multiplicity += G::ONE; } } else { record.function_queries[648].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained)); }; + let __ret: [G; OUT_644] = [__v_6]; + if let Some(result) = record.function_queries[644].get_mut(&inp[..]) { debug_assert_eq!(result.output, &__ret[..]); if !unconstrained { *result.multiplicity += G::ONE; } } else { record.function_queries[644].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained)); }; return Ok(__ret); }, _ => { - let __r_arr: [G; OUT_647] = { let __args: [G; IN_647] = [__v_0, __v_4, __v_2]; let __cu = unconstrained; if let Some(result) = record.function_queries[647].get_mut(&__args[..]) { if !__cu && *result.multiplicity == G::ZERO { aiur_fn_647(__args, record, io_buffer, false)? } else { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_647] = unsafe { *(result.output.as_ptr() as *const [G; OUT_647]) }; __ret } } else { aiur_fn_647(__args, record, io_buffer, __cu)? } }; + let __r_arr: [G; OUT_643] = { let __args: [G; IN_643] = [__v_0, __v_4, __v_2]; let __cu = unconstrained; if let Some(result) = record.function_queries[643].get_mut(&__args[..]) { if !__cu && *result.multiplicity == G::ZERO { aiur_fn_643(__args, record, io_buffer, false)? } else { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_643] = unsafe { *(result.output.as_ptr() as *const [G; OUT_643]) }; __ret } } else { aiur_fn_643(__args, record, io_buffer, __cu)? } }; let __v_5: G = __r_arr[0]; - let __ret: [G; OUT_648] = [__v_5]; - if let Some(result) = record.function_queries[648].get_mut(&inp[..]) { debug_assert_eq!(result.output, &__ret[..]); if !unconstrained { *result.multiplicity += G::ONE; } } else { record.function_queries[648].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained)); }; + let __ret: [G; OUT_644] = [__v_5]; + if let Some(result) = record.function_queries[644].get_mut(&inp[..]) { debug_assert_eq!(result.output, &__ret[..]); if !unconstrained { *result.multiplicity += G::ONE; } } else { record.function_queries[644].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained)); }; return Ok(__ret); }, } }) } -const INPUT_SIZE_649: usize = 3; -const IN_649: usize = 3; -const OUT_649: usize = 1; -fn aiur_fn_649( - inp: [G; IN_649], +const INPUT_SIZE_645: usize = 3; +const IN_645: usize = 3; +const OUT_645: usize = 1; +fn aiur_fn_645( + inp: [G; IN_645], record: &mut QueryRecord, io_buffer: &mut IOBuffer, unconstrained: bool, -) -> Result<[G; OUT_649], ExecError> { +) -> Result<[G; OUT_645], ExecError> { stacker::maybe_grow(64 * 1024, 4 * 1024 * 1024, || { let __v_0: G = inp[0]; let __v_1: G = inp[1]; @@ -55183,8 +54899,8 @@ fn aiur_fn_649( let __v_3: G = (__v_1 - __v_2); match __v_3.as_canonical_u64() { 0u64 => { - let __ret: [G; OUT_649] = [__v_0]; - if let Some(result) = record.function_queries[649].get_mut(&inp[..]) { debug_assert_eq!(result.output, &__ret[..]); if !unconstrained { *result.multiplicity += G::ONE; } } else { record.function_queries[649].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained)); }; + let __ret: [G; OUT_645] = [__v_0]; + if let Some(result) = record.function_queries[645].get_mut(&inp[..]) { debug_assert_eq!(result.output, &__ret[..]); if !unconstrained { *result.multiplicity += G::ONE; } } else { record.function_queries[645].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained)); }; return Ok(__ret); }, _ => { @@ -55199,25 +54915,25 @@ fn aiur_fn_649( let __v_12: G = { let __values: [G; 4] = [__v_10, __v_0, __v_9, __v_11]; let __mq = record.memory_queries.get_mut(&4).ok_or(ExecError::InvalidMemorySize(4))?; if let Some(result) = __mq.get_mut(&__values[..]) { if !unconstrained { *result.multiplicity += G::ONE; } result.output[0] } else { let __ptr = G::from_usize(__mq.len()); __mq.insert(&__values[..], &[__ptr], G::from_bool(!unconstrained)); __ptr } }; let __v_13: G = G::from_u64(1); let __v_14: G = (__v_2 + __v_13); - let __r_arr: [G; OUT_649] = { let __args: [G; IN_649] = [__v_12, __v_1, __v_14]; let __cu = unconstrained; if let Some(result) = record.function_queries[649].get_mut(&__args[..]) { if !__cu && *result.multiplicity == G::ZERO { aiur_fn_649(__args, record, io_buffer, false)? } else { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_649] = unsafe { *(result.output.as_ptr() as *const [G; OUT_649]) }; __ret } } else { aiur_fn_649(__args, record, io_buffer, __cu)? } }; + let __r_arr: [G; OUT_645] = { let __args: [G; IN_645] = [__v_12, __v_1, __v_14]; let __cu = unconstrained; if let Some(result) = record.function_queries[645].get_mut(&__args[..]) { if !__cu && *result.multiplicity == G::ZERO { aiur_fn_645(__args, record, io_buffer, false)? } else { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_645] = unsafe { *(result.output.as_ptr() as *const [G; OUT_645]) }; __ret } } else { aiur_fn_645(__args, record, io_buffer, __cu)? } }; let __v_15: G = __r_arr[0]; - let __ret: [G; OUT_649] = [__v_15]; - if let Some(result) = record.function_queries[649].get_mut(&inp[..]) { debug_assert_eq!(result.output, &__ret[..]); if !unconstrained { *result.multiplicity += G::ONE; } } else { record.function_queries[649].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained)); }; + let __ret: [G; OUT_645] = [__v_15]; + if let Some(result) = record.function_queries[645].get_mut(&inp[..]) { debug_assert_eq!(result.output, &__ret[..]); if !unconstrained { *result.multiplicity += G::ONE; } } else { record.function_queries[645].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained)); }; return Ok(__ret); }, } }) } -const INPUT_SIZE_650: usize = 2; -const IN_650: usize = 2; -const OUT_650: usize = 1; -fn aiur_fn_650( - inp: [G; IN_650], +const INPUT_SIZE_646: usize = 2; +const IN_646: usize = 2; +const OUT_646: usize = 1; +fn aiur_fn_646( + inp: [G; IN_646], record: &mut QueryRecord, io_buffer: &mut IOBuffer, unconstrained: bool, -) -> Result<[G; OUT_650], ExecError> { +) -> Result<[G; OUT_646], ExecError> { stacker::maybe_grow(64 * 1024, 4 * 1024 * 1024, || { let __v_0: G = inp[0]; let __v_1: G = inp[1]; @@ -55227,18 +54943,18 @@ fn aiur_fn_650( let __v_4: G = __loaded[2]; match __v_2.as_canonical_u64() { 1u64 => { - let __ret: [G; OUT_650] = [__v_0]; - if let Some(result) = record.function_queries[650].get_mut(&inp[..]) { debug_assert_eq!(result.output, &__ret[..]); if !unconstrained { *result.multiplicity += G::ONE; } } else { record.function_queries[650].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained)); }; + let __ret: [G; OUT_646] = [__v_0]; + if let Some(result) = record.function_queries[646].get_mut(&inp[..]) { debug_assert_eq!(result.output, &__ret[..]); if !unconstrained { *result.multiplicity += G::ONE; } } else { record.function_queries[646].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained)); }; return Ok(__ret); }, 0u64 => { let __v_5: G = G::from_u64(5); - let __r_arr: [G; OUT_650] = { let __args: [G; IN_650] = [__v_0, __v_4]; let __cu = unconstrained; if let Some(result) = record.function_queries[650].get_mut(&__args[..]) { if !__cu && *result.multiplicity == G::ZERO { aiur_fn_650(__args, record, io_buffer, false)? } else { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_650] = unsafe { *(result.output.as_ptr() as *const [G; OUT_650]) }; __ret } } else { aiur_fn_650(__args, record, io_buffer, __cu)? } }; + let __r_arr: [G; OUT_646] = { let __args: [G; IN_646] = [__v_0, __v_4]; let __cu = unconstrained; if let Some(result) = record.function_queries[646].get_mut(&__args[..]) { if !__cu && *result.multiplicity == G::ZERO { aiur_fn_646(__args, record, io_buffer, false)? } else { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_646] = unsafe { *(result.output.as_ptr() as *const [G; OUT_646]) }; __ret } } else { aiur_fn_646(__args, record, io_buffer, __cu)? } }; let __v_6: G = __r_arr[0]; let __v_7: G = G::from_u64(0); let __v_8: G = { let __values: [G; 4] = [__v_5, __v_3, __v_6, __v_7]; let __mq = record.memory_queries.get_mut(&4).ok_or(ExecError::InvalidMemorySize(4))?; if let Some(result) = __mq.get_mut(&__values[..]) { if !unconstrained { *result.multiplicity += G::ONE; } result.output[0] } else { let __ptr = G::from_usize(__mq.len()); __mq.insert(&__values[..], &[__ptr], G::from_bool(!unconstrained)); __ptr } }; - let __ret: [G; OUT_650] = [__v_8]; - if let Some(result) = record.function_queries[650].get_mut(&inp[..]) { debug_assert_eq!(result.output, &__ret[..]); if !unconstrained { *result.multiplicity += G::ONE; } } else { record.function_queries[650].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained)); }; + let __ret: [G; OUT_646] = [__v_8]; + if let Some(result) = record.function_queries[646].get_mut(&inp[..]) { debug_assert_eq!(result.output, &__ret[..]); if !unconstrained { *result.multiplicity += G::ONE; } } else { record.function_queries[646].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained)); }; return Ok(__ret); }, _ => { @@ -55248,15 +54964,15 @@ fn aiur_fn_650( }) } -const INPUT_SIZE_651: usize = 2; -const IN_651: usize = 2; -const OUT_651: usize = 2; -fn aiur_fn_651( - inp: [G; IN_651], +const INPUT_SIZE_647: usize = 2; +const IN_647: usize = 2; +const OUT_647: usize = 2; +fn aiur_fn_647( + inp: [G; IN_647], record: &mut QueryRecord, io_buffer: &mut IOBuffer, unconstrained: bool, -) -> Result<[G; OUT_651], ExecError> { +) -> Result<[G; OUT_647], ExecError> { stacker::maybe_grow(64 * 1024, 4 * 1024 * 1024, || { let __v_0: G = inp[0]; let __v_1: G = inp[1]; @@ -55265,8 +54981,8 @@ fn aiur_fn_651( let __v_2: G = G::from_u64(1); let __v_3: G = G::from_u64(1); let __v_4: G = { let __values: [G; 3] = [__v_2, __v_3, __v_3]; let __mq = record.memory_queries.get_mut(&3).ok_or(ExecError::InvalidMemorySize(3))?; if let Some(result) = __mq.get_mut(&__values[..]) { if !unconstrained { *result.multiplicity += G::ONE; } result.output[0] } else { let __ptr = G::from_usize(__mq.len()); __mq.insert(&__values[..], &[__ptr], G::from_bool(!unconstrained)); __ptr } }; - let __ret: [G; OUT_651] = [__v_4, __v_0]; - if let Some(result) = record.function_queries[651].get_mut(&inp[..]) { debug_assert_eq!(result.output, &__ret[..]); if !unconstrained { *result.multiplicity += G::ONE; } } else { record.function_queries[651].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained)); }; + let __ret: [G; OUT_647] = [__v_4, __v_0]; + if let Some(result) = record.function_queries[647].get_mut(&inp[..]) { debug_assert_eq!(result.output, &__ret[..]); if !unconstrained { *result.multiplicity += G::ONE; } } else { record.function_queries[647].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained)); }; return Ok(__ret); }, _ => { @@ -55279,20 +54995,20 @@ fn aiur_fn_651( 5u64 => { let __v_6: G = G::from_u64(1); let __v_7: G = (__v_1 - __v_6); - let __r_arr: [G; OUT_651] = { let __args: [G; IN_651] = [__v_4, __v_7]; let __cu = unconstrained; if let Some(result) = record.function_queries[651].get_mut(&__args[..]) { if !__cu && *result.multiplicity == G::ZERO { aiur_fn_651(__args, record, io_buffer, false)? } else { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_651] = unsafe { *(result.output.as_ptr() as *const [G; OUT_651]) }; __ret } } else { aiur_fn_651(__args, record, io_buffer, __cu)? } }; + let __r_arr: [G; OUT_647] = { let __args: [G; IN_647] = [__v_4, __v_7]; let __cu = unconstrained; if let Some(result) = record.function_queries[647].get_mut(&__args[..]) { if !__cu && *result.multiplicity == G::ZERO { aiur_fn_647(__args, record, io_buffer, false)? } else { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_647] = unsafe { *(result.output.as_ptr() as *const [G; OUT_647]) }; __ret } } else { aiur_fn_647(__args, record, io_buffer, __cu)? } }; let __v_8: G = __r_arr[0]; let __v_9: G = __r_arr[1]; let __v_10: G = G::from_u64(0); let __v_11: G = { let __values: [G; 3] = [__v_10, __v_3, __v_8]; let __mq = record.memory_queries.get_mut(&3).ok_or(ExecError::InvalidMemorySize(3))?; if let Some(result) = __mq.get_mut(&__values[..]) { if !unconstrained { *result.multiplicity += G::ONE; } result.output[0] } else { let __ptr = G::from_usize(__mq.len()); __mq.insert(&__values[..], &[__ptr], G::from_bool(!unconstrained)); __ptr } }; - let __ret: [G; OUT_651] = [__v_11, __v_9]; - if let Some(result) = record.function_queries[651].get_mut(&inp[..]) { debug_assert_eq!(result.output, &__ret[..]); if !unconstrained { *result.multiplicity += G::ONE; } } else { record.function_queries[651].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained)); }; + let __ret: [G; OUT_647] = [__v_11, __v_9]; + if let Some(result) = record.function_queries[647].get_mut(&inp[..]) { debug_assert_eq!(result.output, &__ret[..]); if !unconstrained { *result.multiplicity += G::ONE; } } else { record.function_queries[647].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained)); }; return Ok(__ret); }, _ => { let __v_6: G = G::from_u64(1); let __v_7: G = G::from_u64(1); let __v_8: G = { let __values: [G; 3] = [__v_6, __v_7, __v_7]; let __mq = record.memory_queries.get_mut(&3).ok_or(ExecError::InvalidMemorySize(3))?; if let Some(result) = __mq.get_mut(&__values[..]) { if !unconstrained { *result.multiplicity += G::ONE; } result.output[0] } else { let __ptr = G::from_usize(__mq.len()); __mq.insert(&__values[..], &[__ptr], G::from_bool(!unconstrained)); __ptr } }; - let __r_arr: [G; OUT_418] = { let __args: [G; IN_418] = [__v_0, __v_8]; let __cu = unconstrained; if let Some(result) = record.function_queries[418].get_mut(&__args[..]) { if !__cu && *result.multiplicity == G::ZERO { aiur_fn_418(__args, record, io_buffer, false)? } else { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_418] = unsafe { *(result.output.as_ptr() as *const [G; OUT_418]) }; __ret } } else { aiur_fn_418(__args, record, io_buffer, __cu)? } }; + let __r_arr: [G; OUT_414] = { let __args: [G; IN_414] = [__v_0, __v_8]; let __cu = unconstrained; if let Some(result) = record.function_queries[414].get_mut(&__args[..]) { if !__cu && *result.multiplicity == G::ZERO { aiur_fn_414(__args, record, io_buffer, false)? } else { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_414] = unsafe { *(result.output.as_ptr() as *const [G; OUT_414]) }; __ret } } else { aiur_fn_414(__args, record, io_buffer, __cu)? } }; let __v_9: G = __r_arr[0]; let __loaded: [G; 4] = { let __mq = record.memory_queries.get_mut(&4).ok_or(ExecError::InvalidMemorySize(4))?; let __ptr_u64 = __v_9.as_canonical_u64(); let __ptr_usize = usize::try_from(__ptr_u64).ok().ok_or(ExecError::PointerTooLarge(__ptr_u64))?; let (__args, __mult) = __mq.get_index_mut(__ptr_usize).ok_or(ExecError::UnboundPointer { ptr: __ptr_u64, size: 4 })?; if !unconstrained { *__mult += G::ONE; } let __arr: [G; 4] = __args[..4].try_into().unwrap(); __arr }; let __v_10: G = __loaded[0]; @@ -55303,21 +55019,21 @@ fn aiur_fn_651( 5u64 => { let __v_14: G = G::from_u64(1); let __v_15: G = (__v_1 - __v_14); - let __r_arr: [G; OUT_651] = { let __args: [G; IN_651] = [__v_12, __v_15]; let __cu = unconstrained; if let Some(result) = record.function_queries[651].get_mut(&__args[..]) { if !__cu && *result.multiplicity == G::ZERO { aiur_fn_651(__args, record, io_buffer, false)? } else { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_651] = unsafe { *(result.output.as_ptr() as *const [G; OUT_651]) }; __ret } } else { aiur_fn_651(__args, record, io_buffer, __cu)? } }; + let __r_arr: [G; OUT_647] = { let __args: [G; IN_647] = [__v_12, __v_15]; let __cu = unconstrained; if let Some(result) = record.function_queries[647].get_mut(&__args[..]) { if !__cu && *result.multiplicity == G::ZERO { aiur_fn_647(__args, record, io_buffer, false)? } else { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_647] = unsafe { *(result.output.as_ptr() as *const [G; OUT_647]) }; __ret } } else { aiur_fn_647(__args, record, io_buffer, __cu)? } }; let __v_16: G = __r_arr[0]; let __v_17: G = __r_arr[1]; let __v_18: G = G::from_u64(0); let __v_19: G = { let __values: [G; 3] = [__v_18, __v_11, __v_16]; let __mq = record.memory_queries.get_mut(&3).ok_or(ExecError::InvalidMemorySize(3))?; if let Some(result) = __mq.get_mut(&__values[..]) { if !unconstrained { *result.multiplicity += G::ONE; } result.output[0] } else { let __ptr = G::from_usize(__mq.len()); __mq.insert(&__values[..], &[__ptr], G::from_bool(!unconstrained)); __ptr } }; - let __ret: [G; OUT_651] = [__v_19, __v_17]; - if let Some(result) = record.function_queries[651].get_mut(&inp[..]) { debug_assert_eq!(result.output, &__ret[..]); if !unconstrained { *result.multiplicity += G::ONE; } } else { record.function_queries[651].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained)); }; + let __ret: [G; OUT_647] = [__v_19, __v_17]; + if let Some(result) = record.function_queries[647].get_mut(&inp[..]) { debug_assert_eq!(result.output, &__ret[..]); if !unconstrained { *result.multiplicity += G::ONE; } } else { record.function_queries[647].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained)); }; return Ok(__ret); }, _ => { let __v_14: G = G::from_u64(1); let __v_15: G = G::from_u64(1); let __v_16: G = { let __values: [G; 3] = [__v_14, __v_15, __v_15]; let __mq = record.memory_queries.get_mut(&3).ok_or(ExecError::InvalidMemorySize(3))?; if let Some(result) = __mq.get_mut(&__values[..]) { if !unconstrained { *result.multiplicity += G::ONE; } result.output[0] } else { let __ptr = G::from_usize(__mq.len()); __mq.insert(&__values[..], &[__ptr], G::from_bool(!unconstrained)); __ptr } }; - let __ret: [G; OUT_651] = [__v_16, __v_0]; - if let Some(result) = record.function_queries[651].get_mut(&inp[..]) { debug_assert_eq!(result.output, &__ret[..]); if !unconstrained { *result.multiplicity += G::ONE; } } else { record.function_queries[651].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained)); }; + let __ret: [G; OUT_647] = [__v_16, __v_0]; + if let Some(result) = record.function_queries[647].get_mut(&inp[..]) { debug_assert_eq!(result.output, &__ret[..]); if !unconstrained { *result.multiplicity += G::ONE; } } else { record.function_queries[647].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained)); }; return Ok(__ret); }, } @@ -55328,15 +55044,15 @@ fn aiur_fn_651( }) } -const INPUT_SIZE_652: usize = 3; -const IN_652: usize = 3; -const OUT_652: usize = 1; -fn aiur_fn_652( - inp: [G; IN_652], +const INPUT_SIZE_648: usize = 3; +const IN_648: usize = 3; +const OUT_648: usize = 1; +fn aiur_fn_648( + inp: [G; IN_648], record: &mut QueryRecord, io_buffer: &mut IOBuffer, unconstrained: bool, -) -> Result<[G; OUT_652], ExecError> { +) -> Result<[G; OUT_648], ExecError> { stacker::maybe_grow(64 * 1024, 4 * 1024 * 1024, || { let __v_0: G = inp[0]; let __v_1: G = inp[1]; @@ -55350,21 +55066,21 @@ fn aiur_fn_652( let __v_6: G = G::from_u64(1); let __v_7: G = G::from_u64(1); let __v_8: G = { let __values: [G; 3] = [__v_6, __v_7, __v_7]; let __mq = record.memory_queries.get_mut(&3).ok_or(ExecError::InvalidMemorySize(3))?; if let Some(result) = __mq.get_mut(&__values[..]) { if !unconstrained { *result.multiplicity += G::ONE; } result.output[0] } else { let __ptr = G::from_usize(__mq.len()); __mq.insert(&__values[..], &[__ptr], G::from_bool(!unconstrained)); __ptr } }; - let __ret: [G; OUT_652] = [__v_8]; - if let Some(result) = record.function_queries[652].get_mut(&inp[..]) { debug_assert_eq!(result.output, &__ret[..]); if !unconstrained { *result.multiplicity += G::ONE; } } else { record.function_queries[652].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained)); }; + let __ret: [G; OUT_648] = [__v_8]; + if let Some(result) = record.function_queries[648].get_mut(&inp[..]) { debug_assert_eq!(result.output, &__ret[..]); if !unconstrained { *result.multiplicity += G::ONE; } } else { record.function_queries[648].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained)); }; return Ok(__ret); }, 0u64 => { let __v_6: G = G::from_u64(0); - let __r_arr: [G; OUT_359] = { let __args: [G; IN_359] = [__v_4, __v_1, __v_2]; let __cu = unconstrained; if let Some(result) = record.function_queries[359].get_mut(&__args[..]) { if !__cu && *result.multiplicity == G::ZERO { aiur_fn_359(__args, record, io_buffer, false)? } else { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_359] = unsafe { *(result.output.as_ptr() as *const [G; OUT_359]) }; __ret } } else { aiur_fn_359(__args, record, io_buffer, __cu)? } }; + let __r_arr: [G; OUT_355] = { let __args: [G; IN_355] = [__v_4, __v_1, __v_2]; let __cu = unconstrained; if let Some(result) = record.function_queries[355].get_mut(&__args[..]) { if !__cu && *result.multiplicity == G::ZERO { aiur_fn_355(__args, record, io_buffer, false)? } else { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_355] = unsafe { *(result.output.as_ptr() as *const [G; OUT_355]) }; __ret } } else { aiur_fn_355(__args, record, io_buffer, __cu)? } }; let __v_7: G = __r_arr[0]; let __v_8: G = G::from_u64(1); let __v_9: G = (__v_2 + __v_8); - let __r_arr: [G; OUT_652] = { let __args: [G; IN_652] = [__v_5, __v_1, __v_9]; let __cu = unconstrained; if let Some(result) = record.function_queries[652].get_mut(&__args[..]) { if !__cu && *result.multiplicity == G::ZERO { aiur_fn_652(__args, record, io_buffer, false)? } else { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_652] = unsafe { *(result.output.as_ptr() as *const [G; OUT_652]) }; __ret } } else { aiur_fn_652(__args, record, io_buffer, __cu)? } }; + let __r_arr: [G; OUT_648] = { let __args: [G; IN_648] = [__v_5, __v_1, __v_9]; let __cu = unconstrained; if let Some(result) = record.function_queries[648].get_mut(&__args[..]) { if !__cu && *result.multiplicity == G::ZERO { aiur_fn_648(__args, record, io_buffer, false)? } else { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_648] = unsafe { *(result.output.as_ptr() as *const [G; OUT_648]) }; __ret } } else { aiur_fn_648(__args, record, io_buffer, __cu)? } }; let __v_10: G = __r_arr[0]; let __v_11: G = { let __values: [G; 3] = [__v_6, __v_7, __v_10]; let __mq = record.memory_queries.get_mut(&3).ok_or(ExecError::InvalidMemorySize(3))?; if let Some(result) = __mq.get_mut(&__values[..]) { if !unconstrained { *result.multiplicity += G::ONE; } result.output[0] } else { let __ptr = G::from_usize(__mq.len()); __mq.insert(&__values[..], &[__ptr], G::from_bool(!unconstrained)); __ptr } }; - let __ret: [G; OUT_652] = [__v_11]; - if let Some(result) = record.function_queries[652].get_mut(&inp[..]) { debug_assert_eq!(result.output, &__ret[..]); if !unconstrained { *result.multiplicity += G::ONE; } } else { record.function_queries[652].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained)); }; + let __ret: [G; OUT_648] = [__v_11]; + if let Some(result) = record.function_queries[648].get_mut(&inp[..]) { debug_assert_eq!(result.output, &__ret[..]); if !unconstrained { *result.multiplicity += G::ONE; } } else { record.function_queries[648].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained)); }; return Ok(__ret); }, _ => { @@ -55374,15 +55090,15 @@ fn aiur_fn_652( }) } -const INPUT_SIZE_653: usize = 6; -const IN_653: usize = 6; -const OUT_653: usize = 1; -fn aiur_fn_653( - inp: [G; IN_653], +const INPUT_SIZE_649: usize = 6; +const IN_649: usize = 6; +const OUT_649: usize = 1; +fn aiur_fn_649( + inp: [G; IN_649], record: &mut QueryRecord, io_buffer: &mut IOBuffer, unconstrained: bool, -) -> Result<[G; OUT_653], ExecError> { +) -> Result<[G; OUT_649], ExecError> { stacker::maybe_grow(64 * 1024, 4 * 1024 * 1024, || { let __v_0: G = inp[0]; let __v_1: G = inp[1]; @@ -55392,33 +55108,33 @@ fn aiur_fn_653( let __v_5: G = inp[5]; match __v_4.as_canonical_u64() { 1u64 => { - let __r_arr: [G; OUT_647] = { let __args: [G; IN_647] = [__v_0, __v_5, __v_3]; let __cu = unconstrained; if let Some(result) = record.function_queries[647].get_mut(&__args[..]) { if !__cu && *result.multiplicity == G::ZERO { aiur_fn_647(__args, record, io_buffer, false)? } else { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_647] = unsafe { *(result.output.as_ptr() as *const [G; OUT_647]) }; __ret } } else { aiur_fn_647(__args, record, io_buffer, __cu)? } }; + let __r_arr: [G; OUT_643] = { let __args: [G; IN_643] = [__v_0, __v_5, __v_3]; let __cu = unconstrained; if let Some(result) = record.function_queries[643].get_mut(&__args[..]) { if !__cu && *result.multiplicity == G::ZERO { aiur_fn_643(__args, record, io_buffer, false)? } else { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_643] = unsafe { *(result.output.as_ptr() as *const [G; OUT_643]) }; __ret } } else { aiur_fn_643(__args, record, io_buffer, __cu)? } }; let __v_6: G = __r_arr[0]; - let __ret: [G; OUT_653] = [__v_6]; - if let Some(result) = record.function_queries[653].get_mut(&inp[..]) { debug_assert_eq!(result.output, &__ret[..]); if !unconstrained { *result.multiplicity += G::ONE; } } else { record.function_queries[653].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained)); }; + let __ret: [G; OUT_649] = [__v_6]; + if let Some(result) = record.function_queries[649].get_mut(&inp[..]) { debug_assert_eq!(result.output, &__ret[..]); if !unconstrained { *result.multiplicity += G::ONE; } } else { record.function_queries[649].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained)); }; return Ok(__ret); }, _ => { let __v_6: G = G::from_u64(0); - let __r_arr: [G; OUT_657] = { let __args: [G; IN_657] = [__v_0, __v_1, __v_2, __v_6]; let __cu = unconstrained; if let Some(result) = record.function_queries[657].get_mut(&__args[..]) { if !__cu && *result.multiplicity == G::ZERO { aiur_fn_657(__args, record, io_buffer, false)? } else { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_657] = unsafe { *(result.output.as_ptr() as *const [G; OUT_657]) }; __ret } } else { aiur_fn_657(__args, record, io_buffer, __cu)? } }; + let __r_arr: [G; OUT_653] = { let __args: [G; IN_653] = [__v_0, __v_1, __v_2, __v_6]; let __cu = unconstrained; if let Some(result) = record.function_queries[653].get_mut(&__args[..]) { if !__cu && *result.multiplicity == G::ZERO { aiur_fn_653(__args, record, io_buffer, false)? } else { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_653] = unsafe { *(result.output.as_ptr() as *const [G; OUT_653]) }; __ret } } else { aiur_fn_653(__args, record, io_buffer, __cu)? } }; let __v_7: G = __r_arr[0]; - let __ret: [G; OUT_653] = [__v_7]; - if let Some(result) = record.function_queries[653].get_mut(&inp[..]) { debug_assert_eq!(result.output, &__ret[..]); if !unconstrained { *result.multiplicity += G::ONE; } } else { record.function_queries[653].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained)); }; + let __ret: [G; OUT_649] = [__v_7]; + if let Some(result) = record.function_queries[649].get_mut(&inp[..]) { debug_assert_eq!(result.output, &__ret[..]); if !unconstrained { *result.multiplicity += G::ONE; } } else { record.function_queries[649].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained)); }; return Ok(__ret); }, } }) } -const INPUT_SIZE_654: usize = 3; -const IN_654: usize = 3; -const OUT_654: usize = 1; -fn aiur_fn_654( - inp: [G; IN_654], +const INPUT_SIZE_650: usize = 3; +const IN_650: usize = 3; +const OUT_650: usize = 1; +fn aiur_fn_650( + inp: [G; IN_650], record: &mut QueryRecord, io_buffer: &mut IOBuffer, unconstrained: bool, -) -> Result<[G; OUT_654], ExecError> { +) -> Result<[G; OUT_650], ExecError> { stacker::maybe_grow(64 * 1024, 4 * 1024 * 1024, || { let __v_0: G = inp[0]; let __v_1: G = inp[1]; @@ -55426,8 +55142,8 @@ fn aiur_fn_654( let __v_3: G = (__v_1 - __v_2); match __v_3.as_canonical_u64() { 0u64 => { - let __ret: [G; OUT_654] = [__v_0]; - if let Some(result) = record.function_queries[654].get_mut(&inp[..]) { debug_assert_eq!(result.output, &__ret[..]); if !unconstrained { *result.multiplicity += G::ONE; } } else { record.function_queries[654].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained)); }; + let __ret: [G; OUT_650] = [__v_0]; + if let Some(result) = record.function_queries[650].get_mut(&inp[..]) { debug_assert_eq!(result.output, &__ret[..]); if !unconstrained { *result.multiplicity += G::ONE; } } else { record.function_queries[650].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained)); }; return Ok(__ret); }, _ => { @@ -55440,25 +55156,25 @@ fn aiur_fn_654( let __v_10: G = { let __values: [G; 4] = [__v_8, __v_0, __v_7, __v_9]; let __mq = record.memory_queries.get_mut(&4).ok_or(ExecError::InvalidMemorySize(4))?; if let Some(result) = __mq.get_mut(&__values[..]) { if !unconstrained { *result.multiplicity += G::ONE; } result.output[0] } else { let __ptr = G::from_usize(__mq.len()); __mq.insert(&__values[..], &[__ptr], G::from_bool(!unconstrained)); __ptr } }; let __v_11: G = G::from_u64(1); let __v_12: G = (__v_2 + __v_11); - let __r_arr: [G; OUT_654] = { let __args: [G; IN_654] = [__v_10, __v_1, __v_12]; let __cu = unconstrained; if let Some(result) = record.function_queries[654].get_mut(&__args[..]) { if !__cu && *result.multiplicity == G::ZERO { aiur_fn_654(__args, record, io_buffer, false)? } else { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_654] = unsafe { *(result.output.as_ptr() as *const [G; OUT_654]) }; __ret } } else { aiur_fn_654(__args, record, io_buffer, __cu)? } }; + let __r_arr: [G; OUT_650] = { let __args: [G; IN_650] = [__v_10, __v_1, __v_12]; let __cu = unconstrained; if let Some(result) = record.function_queries[650].get_mut(&__args[..]) { if !__cu && *result.multiplicity == G::ZERO { aiur_fn_650(__args, record, io_buffer, false)? } else { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_650] = unsafe { *(result.output.as_ptr() as *const [G; OUT_650]) }; __ret } } else { aiur_fn_650(__args, record, io_buffer, __cu)? } }; let __v_13: G = __r_arr[0]; - let __ret: [G; OUT_654] = [__v_13]; - if let Some(result) = record.function_queries[654].get_mut(&inp[..]) { debug_assert_eq!(result.output, &__ret[..]); if !unconstrained { *result.multiplicity += G::ONE; } } else { record.function_queries[654].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained)); }; + let __ret: [G; OUT_650] = [__v_13]; + if let Some(result) = record.function_queries[650].get_mut(&inp[..]) { debug_assert_eq!(result.output, &__ret[..]); if !unconstrained { *result.multiplicity += G::ONE; } } else { record.function_queries[650].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained)); }; return Ok(__ret); }, } }) } -const INPUT_SIZE_655: usize = 9; -const IN_655: usize = 9; -const OUT_655: usize = 1; -fn aiur_fn_655( - inp: [G; IN_655], +const INPUT_SIZE_651: usize = 9; +const IN_651: usize = 9; +const OUT_651: usize = 1; +fn aiur_fn_651( + inp: [G; IN_651], record: &mut QueryRecord, io_buffer: &mut IOBuffer, unconstrained: bool, -) -> Result<[G; OUT_655], ExecError> { +) -> Result<[G; OUT_651], ExecError> { stacker::maybe_grow(64 * 1024, 4 * 1024 * 1024, || { let __v_0: G = inp[0]; let __v_1: G = inp[1]; @@ -55469,12 +55185,12 @@ fn aiur_fn_655( let __v_6: G = inp[6]; let __v_7: G = inp[7]; let __v_8: G = inp[8]; - let __r_arr: [G; OUT_336] = { let __args: [G; IN_336] = [__v_1, __v_4]; let __cu = unconstrained; if let Some(result) = record.function_queries[336].get_mut(&__args[..]) { if !__cu && *result.multiplicity == G::ZERO { aiur_fn_336(__args, record, io_buffer, false)? } else { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_336] = unsafe { *(result.output.as_ptr() as *const [G; OUT_336]) }; __ret } } else { aiur_fn_336(__args, record, io_buffer, __cu)? } }; + let __r_arr: [G; OUT_332] = { let __args: [G; IN_332] = [__v_1, __v_4]; let __cu = unconstrained; if let Some(result) = record.function_queries[332].get_mut(&__args[..]) { if !__cu && *result.multiplicity == G::ZERO { aiur_fn_332(__args, record, io_buffer, false)? } else { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_332] = unsafe { *(result.output.as_ptr() as *const [G; OUT_332]) }; __ret } } else { aiur_fn_332(__args, record, io_buffer, __cu)? } }; let __v_9: G = __r_arr[0]; let __v_10: G = G::from_u64(0); - let __r_arr: [G; OUT_644] = { let __args: [G; IN_644] = [__v_9, __v_2, __v_6, __v_7, __v_8, __v_10]; let __cu = unconstrained; if let Some(result) = record.function_queries[644].get_mut(&__args[..]) { if !__cu && *result.multiplicity == G::ZERO { aiur_fn_644(__args, record, io_buffer, false)? } else { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_644] = unsafe { *(result.output.as_ptr() as *const [G; OUT_644]) }; __ret } } else { aiur_fn_644(__args, record, io_buffer, __cu)? } }; + let __r_arr: [G; OUT_640] = { let __args: [G; IN_640] = [__v_9, __v_2, __v_6, __v_7, __v_8, __v_10]; let __cu = unconstrained; if let Some(result) = record.function_queries[640].get_mut(&__args[..]) { if !__cu && *result.multiplicity == G::ZERO { aiur_fn_640(__args, record, io_buffer, false)? } else { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_640] = unsafe { *(result.output.as_ptr() as *const [G; OUT_640]) }; __ret } } else { aiur_fn_640(__args, record, io_buffer, __cu)? } }; let __v_11: G = __r_arr[0]; - let __r_arr: [G; OUT_645] = { let __args: [G; IN_645] = [__v_11, __v_3]; let __cu = unconstrained; if let Some(result) = record.function_queries[645].get_mut(&__args[..]) { if !__cu && *result.multiplicity == G::ZERO { aiur_fn_645(__args, record, io_buffer, false)? } else { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_645] = unsafe { *(result.output.as_ptr() as *const [G; OUT_645]) }; __ret } } else { aiur_fn_645(__args, record, io_buffer, __cu)? } }; + let __r_arr: [G; OUT_641] = { let __args: [G; IN_641] = [__v_11, __v_3]; let __cu = unconstrained; if let Some(result) = record.function_queries[641].get_mut(&__args[..]) { if !__cu && *result.multiplicity == G::ZERO { aiur_fn_641(__args, record, io_buffer, false)? } else { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_641] = unsafe { *(result.output.as_ptr() as *const [G; OUT_641]) }; __ret } } else { aiur_fn_641(__args, record, io_buffer, __cu)? } }; let __v_12: G = __r_arr[0]; let __v_13: G = G::from_u64(2); let __v_14: G = G::from_u64(0); @@ -55482,12 +55198,12 @@ fn aiur_fn_655( let __mc_out___mc_0: [G; 1] = '__mc_0: { match __v_7.as_canonical_u64() { 0u64 => { let __v_16: G = G::from_u64(0); - let __r_arr: [G; OUT_646] = { let __args: [G; IN_646] = [__v_15, __v_6, __v_3, __v_16]; let __cu = unconstrained; if let Some(result) = record.function_queries[646].get_mut(&__args[..]) { if !__cu && *result.multiplicity == G::ZERO { aiur_fn_646(__args, record, io_buffer, false)? } else { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_646] = unsafe { *(result.output.as_ptr() as *const [G; OUT_646]) }; __ret } } else { aiur_fn_646(__args, record, io_buffer, __cu)? } }; + let __r_arr: [G; OUT_642] = { let __args: [G; IN_642] = [__v_15, __v_6, __v_3, __v_16]; let __cu = unconstrained; if let Some(result) = record.function_queries[642].get_mut(&__args[..]) { if !__cu && *result.multiplicity == G::ZERO { aiur_fn_642(__args, record, io_buffer, false)? } else { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_642] = unsafe { *(result.output.as_ptr() as *const [G; OUT_642]) }; __ret } } else { aiur_fn_642(__args, record, io_buffer, __cu)? } }; let __v_17: G = __r_arr[0]; break '__mc_0 [__v_17]; }, _ => { - let __r_arr: [G; OUT_647] = { let __args: [G; IN_647] = [__v_15, __v_8, __v_3]; let __cu = unconstrained; if let Some(result) = record.function_queries[647].get_mut(&__args[..]) { if !__cu && *result.multiplicity == G::ZERO { aiur_fn_647(__args, record, io_buffer, false)? } else { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_647] = unsafe { *(result.output.as_ptr() as *const [G; OUT_647]) }; __ret } } else { aiur_fn_647(__args, record, io_buffer, __cu)? } }; + let __r_arr: [G; OUT_643] = { let __args: [G; IN_643] = [__v_15, __v_8, __v_3]; let __cu = unconstrained; if let Some(result) = record.function_queries[643].get_mut(&__args[..]) { if !__cu && *result.multiplicity == G::ZERO { aiur_fn_643(__args, record, io_buffer, false)? } else { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_643] = unsafe { *(result.output.as_ptr() as *const [G; OUT_643]) }; __ret } } else { aiur_fn_643(__args, record, io_buffer, __cu)? } }; let __v_16: G = __r_arr[0]; break '__mc_0 [__v_16]; }, @@ -55495,7 +55211,7 @@ fn aiur_fn_655( }; let __v_16: G = __mc_out___mc_0[0]; let __v_17: G = G::from_u64(0); - let __r_arr: [G; OUT_649] = { let __args: [G; IN_649] = [__v_16, __v_3, __v_17]; let __cu = unconstrained; if let Some(result) = record.function_queries[649].get_mut(&__args[..]) { if !__cu && *result.multiplicity == G::ZERO { aiur_fn_649(__args, record, io_buffer, false)? } else { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_649] = unsafe { *(result.output.as_ptr() as *const [G; OUT_649]) }; __ret } } else { aiur_fn_649(__args, record, io_buffer, __cu)? } }; + let __r_arr: [G; OUT_645] = { let __args: [G; IN_645] = [__v_16, __v_3, __v_17]; let __cu = unconstrained; if let Some(result) = record.function_queries[645].get_mut(&__args[..]) { if !__cu && *result.multiplicity == G::ZERO { aiur_fn_645(__args, record, io_buffer, false)? } else { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_645] = unsafe { *(result.output.as_ptr() as *const [G; OUT_645]) }; __ret } } else { aiur_fn_645(__args, record, io_buffer, __cu)? } }; let __v_18: G = __r_arr[0]; let __v_19: G = G::from_u64(1); let __v_20: G = G::from_u64(0); @@ -55503,45 +55219,45 @@ fn aiur_fn_655( let __v_22: G = G::from_u64(5); let __v_23: G = G::from_u64(0); let __v_24: G = { let __values: [G; 4] = [__v_22, __v_18, __v_21, __v_23]; let __mq = record.memory_queries.get_mut(&4).ok_or(ExecError::InvalidMemorySize(4))?; if let Some(result) = __mq.get_mut(&__values[..]) { if !unconstrained { *result.multiplicity += G::ONE; } result.output[0] } else { let __ptr = G::from_usize(__mq.len()); __mq.insert(&__values[..], &[__ptr], G::from_bool(!unconstrained)); __ptr } }; - let __r_arr: [G; OUT_650] = { let __args: [G; IN_650] = [__v_24, __v_12]; let __cu = unconstrained; if let Some(result) = record.function_queries[650].get_mut(&__args[..]) { if !__cu && *result.multiplicity == G::ZERO { aiur_fn_650(__args, record, io_buffer, false)? } else { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_650] = unsafe { *(result.output.as_ptr() as *const [G; OUT_650]) }; __ret } } else { aiur_fn_650(__args, record, io_buffer, __cu)? } }; + let __r_arr: [G; OUT_646] = { let __args: [G; IN_646] = [__v_24, __v_12]; let __cu = unconstrained; if let Some(result) = record.function_queries[646].get_mut(&__args[..]) { if !__cu && *result.multiplicity == G::ZERO { aiur_fn_646(__args, record, io_buffer, false)? } else { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_646] = unsafe { *(result.output.as_ptr() as *const [G; OUT_646]) }; __ret } } else { aiur_fn_646(__args, record, io_buffer, __cu)? } }; let __v_25: G = __r_arr[0]; - let __ret: [G; OUT_655] = [__v_25]; - if let Some(result) = record.function_queries[655].get_mut(&inp[..]) { debug_assert_eq!(result.output, &__ret[..]); if !unconstrained { *result.multiplicity += G::ONE; } } else { record.function_queries[655].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained)); }; + let __ret: [G; OUT_651] = [__v_25]; + if let Some(result) = record.function_queries[651].get_mut(&inp[..]) { debug_assert_eq!(result.output, &__ret[..]); if !unconstrained { *result.multiplicity += G::ONE; } } else { record.function_queries[651].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained)); }; return Ok(__ret); }) } -const INPUT_SIZE_656: usize = 3; -const IN_656: usize = 3; -const OUT_656: usize = 1; -fn aiur_fn_656( - inp: [G; IN_656], +const INPUT_SIZE_652: usize = 3; +const IN_652: usize = 3; +const OUT_652: usize = 1; +fn aiur_fn_652( + inp: [G; IN_652], record: &mut QueryRecord, io_buffer: &mut IOBuffer, unconstrained: bool, -) -> Result<[G; OUT_656], ExecError> { +) -> Result<[G; OUT_652], ExecError> { stacker::maybe_grow(64 * 1024, 4 * 1024 * 1024, || { let __v_0: G = inp[0]; let __v_1: G = inp[1]; let __v_2: G = inp[2]; let __v_3: G = G::from_u64(0); - let __r_arr: [G; OUT_691] = { let __args: [G; IN_691] = [__v_0, __v_1, __v_2, __v_3]; let __cu = unconstrained; if let Some(result) = record.function_queries[691].get_mut(&__args[..]) { if !__cu && *result.multiplicity == G::ZERO { aiur_fn_691(__args, record, io_buffer, false)? } else { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_691] = unsafe { *(result.output.as_ptr() as *const [G; OUT_691]) }; __ret } } else { aiur_fn_691(__args, record, io_buffer, __cu)? } }; + let __r_arr: [G; OUT_687] = { let __args: [G; IN_687] = [__v_0, __v_1, __v_2, __v_3]; let __cu = unconstrained; if let Some(result) = record.function_queries[687].get_mut(&__args[..]) { if !__cu && *result.multiplicity == G::ZERO { aiur_fn_687(__args, record, io_buffer, false)? } else { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_687] = unsafe { *(result.output.as_ptr() as *const [G; OUT_687]) }; __ret } } else { aiur_fn_687(__args, record, io_buffer, __cu)? } }; let __v_4: G = __r_arr[0]; - let __ret: [G; OUT_656] = [__v_4]; - if let Some(result) = record.function_queries[656].get_mut(&inp[..]) { debug_assert_eq!(result.output, &__ret[..]); if !unconstrained { *result.multiplicity += G::ONE; } } else { record.function_queries[656].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained)); }; + let __ret: [G; OUT_652] = [__v_4]; + if let Some(result) = record.function_queries[652].get_mut(&inp[..]) { debug_assert_eq!(result.output, &__ret[..]); if !unconstrained { *result.multiplicity += G::ONE; } } else { record.function_queries[652].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained)); }; return Ok(__ret); }) } -const INPUT_SIZE_657: usize = 4; -const IN_657: usize = 4; -const OUT_657: usize = 1; -fn aiur_fn_657( - inp: [G; IN_657], +const INPUT_SIZE_653: usize = 4; +const IN_653: usize = 4; +const OUT_653: usize = 1; +fn aiur_fn_653( + inp: [G; IN_653], record: &mut QueryRecord, io_buffer: &mut IOBuffer, unconstrained: bool, -) -> Result<[G; OUT_657], ExecError> { +) -> Result<[G; OUT_653], ExecError> { stacker::maybe_grow(64 * 1024, 4 * 1024 * 1024, || { let __v_0: G = inp[0]; let __v_1: G = inp[1]; @@ -55550,8 +55266,8 @@ fn aiur_fn_657( let __v_4: G = (__v_1 - __v_3); match __v_4.as_canonical_u64() { 0u64 => { - let __ret: [G; OUT_657] = [__v_0]; - if let Some(result) = record.function_queries[657].get_mut(&inp[..]) { debug_assert_eq!(result.output, &__ret[..]); if !unconstrained { *result.multiplicity += G::ONE; } } else { record.function_queries[657].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained)); }; + let __ret: [G; OUT_653] = [__v_0]; + if let Some(result) = record.function_queries[653].get_mut(&inp[..]) { debug_assert_eq!(result.output, &__ret[..]); if !unconstrained { *result.multiplicity += G::ONE; } } else { record.function_queries[653].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained)); }; return Ok(__ret); }, _ => { @@ -55564,25 +55280,25 @@ fn aiur_fn_657( let __v_11: G = { let __values: [G; 4] = [__v_9, __v_0, __v_8, __v_10]; let __mq = record.memory_queries.get_mut(&4).ok_or(ExecError::InvalidMemorySize(4))?; if let Some(result) = __mq.get_mut(&__values[..]) { if !unconstrained { *result.multiplicity += G::ONE; } result.output[0] } else { let __ptr = G::from_usize(__mq.len()); __mq.insert(&__values[..], &[__ptr], G::from_bool(!unconstrained)); __ptr } }; let __v_12: G = G::from_u64(1); let __v_13: G = (__v_3 + __v_12); - let __r_arr: [G; OUT_657] = { let __args: [G; IN_657] = [__v_11, __v_1, __v_2, __v_13]; let __cu = unconstrained; if let Some(result) = record.function_queries[657].get_mut(&__args[..]) { if !__cu && *result.multiplicity == G::ZERO { aiur_fn_657(__args, record, io_buffer, false)? } else { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_657] = unsafe { *(result.output.as_ptr() as *const [G; OUT_657]) }; __ret } } else { aiur_fn_657(__args, record, io_buffer, __cu)? } }; + let __r_arr: [G; OUT_653] = { let __args: [G; IN_653] = [__v_11, __v_1, __v_2, __v_13]; let __cu = unconstrained; if let Some(result) = record.function_queries[653].get_mut(&__args[..]) { if !__cu && *result.multiplicity == G::ZERO { aiur_fn_653(__args, record, io_buffer, false)? } else { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_653] = unsafe { *(result.output.as_ptr() as *const [G; OUT_653]) }; __ret } } else { aiur_fn_653(__args, record, io_buffer, __cu)? } }; let __v_14: G = __r_arr[0]; - let __ret: [G; OUT_657] = [__v_14]; - if let Some(result) = record.function_queries[657].get_mut(&inp[..]) { debug_assert_eq!(result.output, &__ret[..]); if !unconstrained { *result.multiplicity += G::ONE; } } else { record.function_queries[657].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained)); }; + let __ret: [G; OUT_653] = [__v_14]; + if let Some(result) = record.function_queries[653].get_mut(&inp[..]) { debug_assert_eq!(result.output, &__ret[..]); if !unconstrained { *result.multiplicity += G::ONE; } } else { record.function_queries[653].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained)); }; return Ok(__ret); }, } }) } -const INPUT_SIZE_658: usize = 2; -const IN_658: usize = 2; -const OUT_658: usize = 1; -fn aiur_fn_658( - inp: [G; IN_658], +const INPUT_SIZE_654: usize = 2; +const IN_654: usize = 2; +const OUT_654: usize = 1; +fn aiur_fn_654( + inp: [G; IN_654], record: &mut QueryRecord, io_buffer: &mut IOBuffer, unconstrained: bool, -) -> Result<[G; OUT_658], ExecError> { +) -> Result<[G; OUT_654], ExecError> { stacker::maybe_grow(64 * 1024, 4 * 1024 * 1024, || { let __v_0: G = inp[0]; let __v_1: G = inp[1]; @@ -55592,18 +55308,18 @@ fn aiur_fn_658( let __v_4: G = __loaded[2]; match __v_2.as_canonical_u64() { 1u64 => { - let __ret: [G; OUT_658] = [__v_0]; - if let Some(result) = record.function_queries[658].get_mut(&inp[..]) { debug_assert_eq!(result.output, &__ret[..]); if !unconstrained { *result.multiplicity += G::ONE; } } else { record.function_queries[658].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained)); }; + let __ret: [G; OUT_654] = [__v_0]; + if let Some(result) = record.function_queries[654].get_mut(&inp[..]) { debug_assert_eq!(result.output, &__ret[..]); if !unconstrained { *result.multiplicity += G::ONE; } } else { record.function_queries[654].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained)); }; return Ok(__ret); }, 0u64 => { let __v_5: G = G::from_u64(4); - let __r_arr: [G; OUT_658] = { let __args: [G; IN_658] = [__v_0, __v_4]; let __cu = unconstrained; if let Some(result) = record.function_queries[658].get_mut(&__args[..]) { if !__cu && *result.multiplicity == G::ZERO { aiur_fn_658(__args, record, io_buffer, false)? } else { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_658] = unsafe { *(result.output.as_ptr() as *const [G; OUT_658]) }; __ret } } else { aiur_fn_658(__args, record, io_buffer, __cu)? } }; + let __r_arr: [G; OUT_654] = { let __args: [G; IN_654] = [__v_0, __v_4]; let __cu = unconstrained; if let Some(result) = record.function_queries[654].get_mut(&__args[..]) { if !__cu && *result.multiplicity == G::ZERO { aiur_fn_654(__args, record, io_buffer, false)? } else { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_654] = unsafe { *(result.output.as_ptr() as *const [G; OUT_654]) }; __ret } } else { aiur_fn_654(__args, record, io_buffer, __cu)? } }; let __v_6: G = __r_arr[0]; let __v_7: G = G::from_u64(0); let __v_8: G = { let __values: [G; 4] = [__v_5, __v_3, __v_6, __v_7]; let __mq = record.memory_queries.get_mut(&4).ok_or(ExecError::InvalidMemorySize(4))?; if let Some(result) = __mq.get_mut(&__values[..]) { if !unconstrained { *result.multiplicity += G::ONE; } result.output[0] } else { let __ptr = G::from_usize(__mq.len()); __mq.insert(&__values[..], &[__ptr], G::from_bool(!unconstrained)); __ptr } }; - let __ret: [G; OUT_658] = [__v_8]; - if let Some(result) = record.function_queries[658].get_mut(&inp[..]) { debug_assert_eq!(result.output, &__ret[..]); if !unconstrained { *result.multiplicity += G::ONE; } } else { record.function_queries[658].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained)); }; + let __ret: [G; OUT_654] = [__v_8]; + if let Some(result) = record.function_queries[654].get_mut(&inp[..]) { debug_assert_eq!(result.output, &__ret[..]); if !unconstrained { *result.multiplicity += G::ONE; } } else { record.function_queries[654].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained)); }; return Ok(__ret); }, _ => { @@ -55613,15 +55329,15 @@ fn aiur_fn_658( }) } -const INPUT_SIZE_659: usize = 9; -const IN_659: usize = 9; -const OUT_659: usize = 1; -fn aiur_fn_659( - inp: [G; IN_659], +const INPUT_SIZE_655: usize = 9; +const IN_655: usize = 9; +const OUT_655: usize = 1; +fn aiur_fn_655( + inp: [G; IN_655], record: &mut QueryRecord, io_buffer: &mut IOBuffer, unconstrained: bool, -) -> Result<[G; OUT_659], ExecError> { +) -> Result<[G; OUT_655], ExecError> { stacker::maybe_grow(64 * 1024, 4 * 1024 * 1024, || { let __v_0: G = inp[0]; let __v_1: G = inp[1]; @@ -55633,12 +55349,12 @@ fn aiur_fn_659( let __v_7: G = inp[7]; let __v_8: G = inp[8]; let __v_9: G = G::from_u64(0); - let __r_arr: [G; OUT_642] = { let __args: [G; IN_642] = [__v_6, __v_9]; let __cu = unconstrained; if let Some(result) = record.function_queries[642].get_mut(&__args[..]) { if !__cu && *result.multiplicity == G::ZERO { aiur_fn_642(__args, record, io_buffer, false)? } else { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_642] = unsafe { *(result.output.as_ptr() as *const [G; OUT_642]) }; __ret } } else { aiur_fn_642(__args, record, io_buffer, __cu)? } }; + let __r_arr: [G; OUT_638] = { let __args: [G; IN_638] = [__v_6, __v_9]; let __cu = unconstrained; if let Some(result) = record.function_queries[638].get_mut(&__args[..]) { if !__cu && *result.multiplicity == G::ZERO { aiur_fn_638(__args, record, io_buffer, false)? } else { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_638] = unsafe { *(result.output.as_ptr() as *const [G; OUT_638]) }; __ret } } else { aiur_fn_638(__args, record, io_buffer, __cu)? } }; let __v_10: G = __r_arr[0]; let __v_11: G = __r_arr[1]; let __v_12: G = __r_arr[2]; let __v_13: G = __r_arr[3]; - let __r_arr: [G; OUT_287] = { let __args: [G; IN_287] = [__v_10]; let __cu = unconstrained; if let Some(result) = record.function_queries[287].get_mut(&__args[..]) { if !__cu && *result.multiplicity == G::ZERO { aiur_fn_287(__args, record, io_buffer, false)? } else { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_287] = unsafe { *(result.output.as_ptr() as *const [G; OUT_287]) }; __ret } } else { aiur_fn_287(__args, record, io_buffer, __cu)? } }; + let __r_arr: [G; OUT_283] = { let __args: [G; IN_283] = [__v_10]; let __cu = unconstrained; if let Some(result) = record.function_queries[283].get_mut(&__args[..]) { if !__cu && *result.multiplicity == G::ZERO { aiur_fn_283(__args, record, io_buffer, false)? } else { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_283] = unsafe { *(result.output.as_ptr() as *const [G; OUT_283]) }; __ret } } else { aiur_fn_283(__args, record, io_buffer, __cu)? } }; let __v_14: G = __r_arr[0]; let __loaded: [G; 12] = { let __mq = record.memory_queries.get_mut(&12).ok_or(ExecError::InvalidMemorySize(12))?; let __ptr_u64 = __v_14.as_canonical_u64(); let __ptr_usize = usize::try_from(__ptr_u64).ok().ok_or(ExecError::PointerTooLarge(__ptr_u64))?; let (__args, __mult) = __mq.get_index_mut(__ptr_usize).ok_or(ExecError::UnboundPointer { ptr: __ptr_u64, size: 12 })?; if !unconstrained { *__mult += G::ONE; } let __arr: [G; 12] = __args[..12].try_into().unwrap(); __arr }; let __v_15: G = __loaded[0]; @@ -55655,32 +55371,32 @@ fn aiur_fn_659( let __v_26: G = __loaded[11]; match __v_15.as_canonical_u64() { 5u64 => { - let __r_arr: [G; OUT_660] = { let __args: [G; IN_660] = [__v_17, __v_16, __v_0, __v_1, __v_2, __v_3, __v_4, __v_5, __v_6, __v_7, __v_8]; let __cu = unconstrained; if let Some(result) = record.function_queries[660].get_mut(&__args[..]) { if !__cu && *result.multiplicity == G::ZERO { aiur_fn_660(__args, record, io_buffer, false)? } else { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_660] = unsafe { *(result.output.as_ptr() as *const [G; OUT_660]) }; __ret } } else { aiur_fn_660(__args, record, io_buffer, __cu)? } }; + let __r_arr: [G; OUT_656] = { let __args: [G; IN_656] = [__v_17, __v_16, __v_0, __v_1, __v_2, __v_3, __v_4, __v_5, __v_6, __v_7, __v_8]; let __cu = unconstrained; if let Some(result) = record.function_queries[656].get_mut(&__args[..]) { if !__cu && *result.multiplicity == G::ZERO { aiur_fn_656(__args, record, io_buffer, false)? } else { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_656] = unsafe { *(result.output.as_ptr() as *const [G; OUT_656]) }; __ret } } else { aiur_fn_656(__args, record, io_buffer, __cu)? } }; let __v_27: G = __r_arr[0]; - let __ret: [G; OUT_659] = [__v_27]; - if let Some(result) = record.function_queries[659].get_mut(&inp[..]) { debug_assert_eq!(result.output, &__ret[..]); if !unconstrained { *result.multiplicity += G::ONE; } } else { record.function_queries[659].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained)); }; + let __ret: [G; OUT_655] = [__v_27]; + if let Some(result) = record.function_queries[655].get_mut(&inp[..]) { debug_assert_eq!(result.output, &__ret[..]); if !unconstrained { *result.multiplicity += G::ONE; } } else { record.function_queries[655].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained)); }; return Ok(__ret); }, _ => { - let __r_arr: [G; OUT_660] = { let __args: [G; IN_660] = [__v_0, __v_1, __v_0, __v_1, __v_2, __v_3, __v_4, __v_5, __v_6, __v_7, __v_8]; let __cu = unconstrained; if let Some(result) = record.function_queries[660].get_mut(&__args[..]) { if !__cu && *result.multiplicity == G::ZERO { aiur_fn_660(__args, record, io_buffer, false)? } else { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_660] = unsafe { *(result.output.as_ptr() as *const [G; OUT_660]) }; __ret } } else { aiur_fn_660(__args, record, io_buffer, __cu)? } }; + let __r_arr: [G; OUT_656] = { let __args: [G; IN_656] = [__v_0, __v_1, __v_0, __v_1, __v_2, __v_3, __v_4, __v_5, __v_6, __v_7, __v_8]; let __cu = unconstrained; if let Some(result) = record.function_queries[656].get_mut(&__args[..]) { if !__cu && *result.multiplicity == G::ZERO { aiur_fn_656(__args, record, io_buffer, false)? } else { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_656] = unsafe { *(result.output.as_ptr() as *const [G; OUT_656]) }; __ret } } else { aiur_fn_656(__args, record, io_buffer, __cu)? } }; let __v_27: G = __r_arr[0]; - let __ret: [G; OUT_659] = [__v_27]; - if let Some(result) = record.function_queries[659].get_mut(&inp[..]) { debug_assert_eq!(result.output, &__ret[..]); if !unconstrained { *result.multiplicity += G::ONE; } } else { record.function_queries[659].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained)); }; + let __ret: [G; OUT_655] = [__v_27]; + if let Some(result) = record.function_queries[655].get_mut(&inp[..]) { debug_assert_eq!(result.output, &__ret[..]); if !unconstrained { *result.multiplicity += G::ONE; } } else { record.function_queries[655].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained)); }; return Ok(__ret); }, } }) } -const INPUT_SIZE_660: usize = 11; -const IN_660: usize = 11; -const OUT_660: usize = 1; -fn aiur_fn_660( - inp: [G; IN_660], +const INPUT_SIZE_656: usize = 11; +const IN_656: usize = 11; +const OUT_656: usize = 1; +fn aiur_fn_656( + inp: [G; IN_656], record: &mut QueryRecord, io_buffer: &mut IOBuffer, unconstrained: bool, -) -> Result<[G; OUT_660], ExecError> { +) -> Result<[G; OUT_656], ExecError> { stacker::maybe_grow(64 * 1024, 4 * 1024 * 1024, || { let __v_0: G = inp[0]; let __v_1: G = inp[1]; @@ -55693,28 +55409,28 @@ fn aiur_fn_660( let __v_8: G = inp[8]; let __v_9: G = inp[9]; let __v_10: G = inp[10]; - let __r_arr: [G; OUT_779] = { let __args: [G; IN_779] = [__v_8]; let __cu = unconstrained; if let Some(result) = record.function_queries[779].get_mut(&__args[..]) { if !__cu && *result.multiplicity == G::ZERO { aiur_fn_779(__args, record, io_buffer, false)? } else { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_779] = unsafe { *(result.output.as_ptr() as *const [G; OUT_779]) }; __ret } } else { aiur_fn_779(__args, record, io_buffer, __cu)? } }; + let __r_arr: [G; OUT_775] = { let __args: [G; IN_775] = [__v_8]; let __cu = unconstrained; if let Some(result) = record.function_queries[775].get_mut(&__args[..]) { if !__cu && *result.multiplicity == G::ZERO { aiur_fn_775(__args, record, io_buffer, false)? } else { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_775] = unsafe { *(result.output.as_ptr() as *const [G; OUT_775]) }; __ret } } else { aiur_fn_775(__args, record, io_buffer, __cu)? } }; let __v_11: G = __r_arr[0]; let __v_12: G = G::from_u64(0); - let __r_arr: [G; OUT_627] = { let __args: [G; IN_627] = [__v_7, __v_1, __v_12]; let __cu = unconstrained; if let Some(result) = record.function_queries[627].get_mut(&__args[..]) { if !__cu && *result.multiplicity == G::ZERO { aiur_fn_627(__args, record, io_buffer, false)? } else { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_627] = unsafe { *(result.output.as_ptr() as *const [G; OUT_627]) }; __ret } } else { aiur_fn_627(__args, record, io_buffer, __cu)? } }; + let __r_arr: [G; OUT_623] = { let __args: [G; IN_623] = [__v_7, __v_1, __v_12]; let __cu = unconstrained; if let Some(result) = record.function_queries[623].get_mut(&__args[..]) { if !__cu && *result.multiplicity == G::ZERO { aiur_fn_623(__args, record, io_buffer, false)? } else { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_623] = unsafe { *(result.output.as_ptr() as *const [G; OUT_623]) }; __ret } } else { aiur_fn_623(__args, record, io_buffer, __cu)? } }; let __v_13: G = __r_arr[0]; - let __r_arr: [G; OUT_336] = { let __args: [G; IN_336] = [__v_0, __v_13]; let __cu = unconstrained; if let Some(result) = record.function_queries[336].get_mut(&__args[..]) { if !__cu && *result.multiplicity == G::ZERO { aiur_fn_336(__args, record, io_buffer, false)? } else { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_336] = unsafe { *(result.output.as_ptr() as *const [G; OUT_336]) }; __ret } } else { aiur_fn_336(__args, record, io_buffer, __cu)? } }; + let __r_arr: [G; OUT_332] = { let __args: [G; IN_332] = [__v_0, __v_13]; let __cu = unconstrained; if let Some(result) = record.function_queries[332].get_mut(&__args[..]) { if !__cu && *result.multiplicity == G::ZERO { aiur_fn_332(__args, record, io_buffer, false)? } else { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_332] = unsafe { *(result.output.as_ptr() as *const [G; OUT_332]) }; __ret } } else { aiur_fn_332(__args, record, io_buffer, __cu)? } }; let __v_14: G = __r_arr[0]; - let __r_arr: [G; OUT_651] = { let __args: [G; IN_651] = [__v_14, __v_4]; let __cu = unconstrained; if let Some(result) = record.function_queries[651].get_mut(&__args[..]) { if !__cu && *result.multiplicity == G::ZERO { aiur_fn_651(__args, record, io_buffer, false)? } else { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_651] = unsafe { *(result.output.as_ptr() as *const [G; OUT_651]) }; __ret } } else { aiur_fn_651(__args, record, io_buffer, __cu)? } }; + let __r_arr: [G; OUT_647] = { let __args: [G; IN_647] = [__v_14, __v_4]; let __cu = unconstrained; if let Some(result) = record.function_queries[647].get_mut(&__args[..]) { if !__cu && *result.multiplicity == G::ZERO { aiur_fn_647(__args, record, io_buffer, false)? } else { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_647] = unsafe { *(result.output.as_ptr() as *const [G; OUT_647]) }; __ret } } else { aiur_fn_647(__args, record, io_buffer, __cu)? } }; let __v_15: G = __r_arr[0]; let __v_16: G = __r_arr[1]; - let __r_arr: [G; OUT_656] = { let __args: [G; IN_656] = [__v_8, __v_6, __v_4]; let __cu = unconstrained; if let Some(result) = record.function_queries[656].get_mut(&__args[..]) { if !__cu && *result.multiplicity == G::ZERO { aiur_fn_656(__args, record, io_buffer, false)? } else { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_656] = unsafe { *(result.output.as_ptr() as *const [G; OUT_656]) }; __ret } } else { aiur_fn_656(__args, record, io_buffer, __cu)? } }; + let __r_arr: [G; OUT_652] = { let __args: [G; IN_652] = [__v_8, __v_6, __v_4]; let __cu = unconstrained; if let Some(result) = record.function_queries[652].get_mut(&__args[..]) { if !__cu && *result.multiplicity == G::ZERO { aiur_fn_652(__args, record, io_buffer, false)? } else { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_652] = unsafe { *(result.output.as_ptr() as *const [G; OUT_652]) }; __ret } } else { aiur_fn_652(__args, record, io_buffer, __cu)? } }; let __v_17: G = __r_arr[0]; - let __r_arr: [G; OUT_674] = { let __args: [G; IN_674] = [__v_8, __v_9, __v_4, __v_11, __v_4]; let __cu = unconstrained; if let Some(result) = record.function_queries[674].get_mut(&__args[..]) { if !__cu && *result.multiplicity == G::ZERO { aiur_fn_674(__args, record, io_buffer, false)? } else { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_674] = unsafe { *(result.output.as_ptr() as *const [G; OUT_674]) }; __ret } } else { aiur_fn_674(__args, record, io_buffer, __cu)? } }; + let __r_arr: [G; OUT_670] = { let __args: [G; IN_670] = [__v_8, __v_9, __v_4, __v_11, __v_4]; let __cu = unconstrained; if let Some(result) = record.function_queries[670].get_mut(&__args[..]) { if !__cu && *result.multiplicity == G::ZERO { aiur_fn_670(__args, record, io_buffer, false)? } else { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_670] = unsafe { *(result.output.as_ptr() as *const [G; OUT_670]) }; __ret } } else { aiur_fn_670(__args, record, io_buffer, __cu)? } }; let __v_18: G = __r_arr[0]; - let __r_arr: [G; OUT_764] = { let __args: [G; IN_764] = [__v_18]; let __cu = unconstrained; if let Some(result) = record.function_queries[764].get_mut(&__args[..]) { if !__cu && *result.multiplicity == G::ZERO { aiur_fn_764(__args, record, io_buffer, false)? } else { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_764] = unsafe { *(result.output.as_ptr() as *const [G; OUT_764]) }; __ret } } else { aiur_fn_764(__args, record, io_buffer, __cu)? } }; + let __r_arr: [G; OUT_760] = { let __args: [G; IN_760] = [__v_18]; let __cu = unconstrained; if let Some(result) = record.function_queries[760].get_mut(&__args[..]) { if !__cu && *result.multiplicity == G::ZERO { aiur_fn_760(__args, record, io_buffer, false)? } else { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_760] = unsafe { *(result.output.as_ptr() as *const [G; OUT_760]) }; __ret } } else { aiur_fn_760(__args, record, io_buffer, __cu)? } }; let __v_19: G = __r_arr[0]; - let __r_arr: [G; OUT_642] = { let __args: [G; IN_642] = [__v_8, __v_10]; let __cu = unconstrained; if let Some(result) = record.function_queries[642].get_mut(&__args[..]) { if !__cu && *result.multiplicity == G::ZERO { aiur_fn_642(__args, record, io_buffer, false)? } else { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_642] = unsafe { *(result.output.as_ptr() as *const [G; OUT_642]) }; __ret } } else { aiur_fn_642(__args, record, io_buffer, __cu)? } }; + let __r_arr: [G; OUT_638] = { let __args: [G; IN_638] = [__v_8, __v_10]; let __cu = unconstrained; if let Some(result) = record.function_queries[638].get_mut(&__args[..]) { if !__cu && *result.multiplicity == G::ZERO { aiur_fn_638(__args, record, io_buffer, false)? } else { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_638] = unsafe { *(result.output.as_ptr() as *const [G; OUT_638]) }; __ret } } else { aiur_fn_638(__args, record, io_buffer, __cu)? } }; let __v_20: G = __r_arr[0]; let __v_21: G = __r_arr[1]; let __v_22: G = __r_arr[2]; let __v_23: G = __r_arr[3]; - let __r_arr: [G; OUT_287] = { let __args: [G; IN_287] = [__v_20]; let __cu = unconstrained; if let Some(result) = record.function_queries[287].get_mut(&__args[..]) { if !__cu && *result.multiplicity == G::ZERO { aiur_fn_287(__args, record, io_buffer, false)? } else { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_287] = unsafe { *(result.output.as_ptr() as *const [G; OUT_287]) }; __ret } } else { aiur_fn_287(__args, record, io_buffer, __cu)? } }; + let __r_arr: [G; OUT_283] = { let __args: [G; IN_283] = [__v_20]; let __cu = unconstrained; if let Some(result) = record.function_queries[283].get_mut(&__args[..]) { if !__cu && *result.multiplicity == G::ZERO { aiur_fn_283(__args, record, io_buffer, false)? } else { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_283] = unsafe { *(result.output.as_ptr() as *const [G; OUT_283]) }; __ret } } else { aiur_fn_283(__args, record, io_buffer, __cu)? } }; let __v_24: G = __r_arr[0]; let __loaded: [G; 12] = { let __mq = record.memory_queries.get_mut(&12).ok_or(ExecError::InvalidMemorySize(12))?; let __ptr_u64 = __v_24.as_canonical_u64(); let __ptr_usize = usize::try_from(__ptr_u64).ok().ok_or(ExecError::PointerTooLarge(__ptr_u64))?; let (__args, __mult) = __mq.get_index_mut(__ptr_usize).ok_or(ExecError::UnboundPointer { ptr: __ptr_u64, size: 12 })?; if !unconstrained { *__mult += G::ONE; } let __arr: [G; 12] = __args[..12].try_into().unwrap(); __arr }; let __v_25: G = __loaded[0]; @@ -55731,16 +55447,16 @@ fn aiur_fn_660( let __v_36: G = __loaded[11]; match __v_25.as_canonical_u64() { 5u64 => { - let __r_arr: [G; OUT_336] = { let __args: [G; IN_336] = [__v_27, __v_23]; let __cu = unconstrained; if let Some(result) = record.function_queries[336].get_mut(&__args[..]) { if !__cu && *result.multiplicity == G::ZERO { aiur_fn_336(__args, record, io_buffer, false)? } else { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_336] = unsafe { *(result.output.as_ptr() as *const [G; OUT_336]) }; __ret } } else { aiur_fn_336(__args, record, io_buffer, __cu)? } }; + let __r_arr: [G; OUT_332] = { let __args: [G; IN_332] = [__v_27, __v_23]; let __cu = unconstrained; if let Some(result) = record.function_queries[332].get_mut(&__args[..]) { if !__cu && *result.multiplicity == G::ZERO { aiur_fn_332(__args, record, io_buffer, false)? } else { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_332] = unsafe { *(result.output.as_ptr() as *const [G; OUT_332]) }; __ret } } else { aiur_fn_332(__args, record, io_buffer, __cu)? } }; let __v_37: G = __r_arr[0]; let __v_38: G = G::from_u64(0); - let __r_arr: [G; OUT_644] = { let __args: [G; IN_644] = [__v_37, __v_28, __v_4, __v_21, __v_22, __v_38]; let __cu = unconstrained; if let Some(result) = record.function_queries[644].get_mut(&__args[..]) { if !__cu && *result.multiplicity == G::ZERO { aiur_fn_644(__args, record, io_buffer, false)? } else { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_644] = unsafe { *(result.output.as_ptr() as *const [G; OUT_644]) }; __ret } } else { aiur_fn_644(__args, record, io_buffer, __cu)? } }; + let __r_arr: [G; OUT_640] = { let __args: [G; IN_640] = [__v_37, __v_28, __v_4, __v_21, __v_22, __v_38]; let __cu = unconstrained; if let Some(result) = record.function_queries[640].get_mut(&__args[..]) { if !__cu && *result.multiplicity == G::ZERO { aiur_fn_640(__args, record, io_buffer, false)? } else { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_640] = unsafe { *(result.output.as_ptr() as *const [G; OUT_640]) }; __ret } } else { aiur_fn_640(__args, record, io_buffer, __cu)? } }; let __v_39: G = __r_arr[0]; - let __r_arr: [G; OUT_645] = { let __args: [G; IN_645] = [__v_39, __v_5]; let __cu = unconstrained; if let Some(result) = record.function_queries[645].get_mut(&__args[..]) { if !__cu && *result.multiplicity == G::ZERO { aiur_fn_645(__args, record, io_buffer, false)? } else { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_645] = unsafe { *(result.output.as_ptr() as *const [G; OUT_645]) }; __ret } } else { aiur_fn_645(__args, record, io_buffer, __cu)? } }; + let __r_arr: [G; OUT_641] = { let __args: [G; IN_641] = [__v_39, __v_5]; let __cu = unconstrained; if let Some(result) = record.function_queries[641].get_mut(&__args[..]) { if !__cu && *result.multiplicity == G::ZERO { aiur_fn_641(__args, record, io_buffer, false)? } else { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_641] = unsafe { *(result.output.as_ptr() as *const [G; OUT_641]) }; __ret } } else { aiur_fn_641(__args, record, io_buffer, __cu)? } }; let __v_40: G = __r_arr[0]; let __v_41: G = (__v_11 + __v_19); let __v_42: G = G::from_u64(0); - let __r_arr: [G; OUT_652] = { let __args: [G; IN_652] = [__v_40, __v_41, __v_42]; let __cu = unconstrained; if let Some(result) = record.function_queries[652].get_mut(&__args[..]) { if !__cu && *result.multiplicity == G::ZERO { aiur_fn_652(__args, record, io_buffer, false)? } else { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_652] = unsafe { *(result.output.as_ptr() as *const [G; OUT_652]) }; __ret } } else { aiur_fn_652(__args, record, io_buffer, __cu)? } }; + let __r_arr: [G; OUT_648] = { let __args: [G; IN_648] = [__v_40, __v_41, __v_42]; let __cu = unconstrained; if let Some(result) = record.function_queries[648].get_mut(&__args[..]) { if !__cu && *result.multiplicity == G::ZERO { aiur_fn_648(__args, record, io_buffer, false)? } else { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_648] = unsafe { *(result.output.as_ptr() as *const [G; OUT_648]) }; __ret } } else { aiur_fn_648(__args, record, io_buffer, __cu)? } }; let __v_43: G = __r_arr[0]; let __v_44: G = G::from_u64(2); let __v_45: G = G::from_u64(0); @@ -55754,13 +55470,13 @@ fn aiur_fn_660( let __v_53: G = (__v_52 + __v_5); let __mc_out___mc_0: [G; 1] = '__mc_0: { match __v_21.as_canonical_u64() { 1u64 => { - let __r_arr: [G; OUT_647] = { let __args: [G; IN_647] = [__v_46, __v_22, __v_53]; let __cu = unconstrained; if let Some(result) = record.function_queries[647].get_mut(&__args[..]) { if !__cu && *result.multiplicity == G::ZERO { aiur_fn_647(__args, record, io_buffer, false)? } else { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_647] = unsafe { *(result.output.as_ptr() as *const [G; OUT_647]) }; __ret } } else { aiur_fn_647(__args, record, io_buffer, __cu)? } }; + let __r_arr: [G; OUT_643] = { let __args: [G; IN_643] = [__v_46, __v_22, __v_53]; let __cu = unconstrained; if let Some(result) = record.function_queries[643].get_mut(&__args[..]) { if !__cu && *result.multiplicity == G::ZERO { aiur_fn_643(__args, record, io_buffer, false)? } else { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_643] = unsafe { *(result.output.as_ptr() as *const [G; OUT_643]) }; __ret } } else { aiur_fn_643(__args, record, io_buffer, __cu)? } }; let __v_54: G = __r_arr[0]; break '__mc_0 [__v_54]; }, _ => { let __v_54: G = G::from_u64(0); - let __r_arr: [G; OUT_657] = { let __args: [G; IN_657] = [__v_46, __v_4, __v_51, __v_54]; let __cu = unconstrained; if let Some(result) = record.function_queries[657].get_mut(&__args[..]) { if !__cu && *result.multiplicity == G::ZERO { aiur_fn_657(__args, record, io_buffer, false)? } else { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_657] = unsafe { *(result.output.as_ptr() as *const [G; OUT_657]) }; __ret } } else { aiur_fn_657(__args, record, io_buffer, __cu)? } }; + let __r_arr: [G; OUT_653] = { let __args: [G; IN_653] = [__v_46, __v_4, __v_51, __v_54]; let __cu = unconstrained; if let Some(result) = record.function_queries[653].get_mut(&__args[..]) { if !__cu && *result.multiplicity == G::ZERO { aiur_fn_653(__args, record, io_buffer, false)? } else { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_653] = unsafe { *(result.output.as_ptr() as *const [G; OUT_653]) }; __ret } } else { aiur_fn_653(__args, record, io_buffer, __cu)? } }; let __v_55: G = __r_arr[0]; break '__mc_0 [__v_55]; }, @@ -55768,7 +55484,7 @@ fn aiur_fn_660( }; let __v_54: G = __mc_out___mc_0[0]; let __v_55: G = G::from_u64(0); - let __r_arr: [G; OUT_649] = { let __args: [G; IN_649] = [__v_54, __v_5, __v_55]; let __cu = unconstrained; if let Some(result) = record.function_queries[649].get_mut(&__args[..]) { if !__cu && *result.multiplicity == G::ZERO { aiur_fn_649(__args, record, io_buffer, false)? } else { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_649] = unsafe { *(result.output.as_ptr() as *const [G; OUT_649]) }; __ret } } else { aiur_fn_649(__args, record, io_buffer, __cu)? } }; + let __r_arr: [G; OUT_645] = { let __args: [G; IN_645] = [__v_54, __v_5, __v_55]; let __cu = unconstrained; if let Some(result) = record.function_queries[645].get_mut(&__args[..]) { if !__cu && *result.multiplicity == G::ZERO { aiur_fn_645(__args, record, io_buffer, false)? } else { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_645] = unsafe { *(result.output.as_ptr() as *const [G; OUT_645]) }; __ret } } else { aiur_fn_645(__args, record, io_buffer, __cu)? } }; let __v_56: G = __r_arr[0]; let __v_57: G = G::from_u64(1); let __v_58: G = (__v_49 + __v_57); @@ -55780,7 +55496,7 @@ fn aiur_fn_660( let __v_64: G = G::from_u64(0); let __v_65: G = { let __values: [G; 4] = [__v_63, __v_62, __v_64, __v_64]; let __mq = record.memory_queries.get_mut(&4).ok_or(ExecError::InvalidMemorySize(4))?; if let Some(result) = __mq.get_mut(&__values[..]) { if !unconstrained { *result.multiplicity += G::ONE; } result.output[0] } else { let __ptr = G::from_usize(__mq.len()); __mq.insert(&__values[..], &[__ptr], G::from_bool(!unconstrained)); __ptr } }; let __v_66: G = G::from_u64(0); - let __r_arr: [G; OUT_654] = { let __args: [G; IN_654] = [__v_65, __v_5, __v_66]; let __cu = unconstrained; if let Some(result) = record.function_queries[654].get_mut(&__args[..]) { if !__cu && *result.multiplicity == G::ZERO { aiur_fn_654(__args, record, io_buffer, false)? } else { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_654] = unsafe { *(result.output.as_ptr() as *const [G; OUT_654]) }; __ret } } else { aiur_fn_654(__args, record, io_buffer, __cu)? } }; + let __r_arr: [G; OUT_650] = { let __args: [G; IN_650] = [__v_65, __v_5, __v_66]; let __cu = unconstrained; if let Some(result) = record.function_queries[650].get_mut(&__args[..]) { if !__cu && *result.multiplicity == G::ZERO { aiur_fn_650(__args, record, io_buffer, false)? } else { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_650] = unsafe { *(result.output.as_ptr() as *const [G; OUT_650]) }; __ret } } else { aiur_fn_650(__args, record, io_buffer, __cu)? } }; let __v_67: G = __r_arr[0]; let __v_68: G = G::from_u64(3); let __v_69: G = G::from_u64(0); @@ -55792,16 +55508,16 @@ fn aiur_fn_660( let __v_75: G = G::from_u64(5); let __v_76: G = G::from_u64(0); let __v_77: G = { let __values: [G; 4] = [__v_75, __v_56, __v_74, __v_76]; let __mq = record.memory_queries.get_mut(&4).ok_or(ExecError::InvalidMemorySize(4))?; if let Some(result) = __mq.get_mut(&__values[..]) { if !unconstrained { *result.multiplicity += G::ONE; } result.output[0] } else { let __ptr = G::from_usize(__mq.len()); __mq.insert(&__values[..], &[__ptr], G::from_bool(!unconstrained)); __ptr } }; - let __r_arr: [G; OUT_650] = { let __args: [G; IN_650] = [__v_77, __v_43]; let __cu = unconstrained; if let Some(result) = record.function_queries[650].get_mut(&__args[..]) { if !__cu && *result.multiplicity == G::ZERO { aiur_fn_650(__args, record, io_buffer, false)? } else { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_650] = unsafe { *(result.output.as_ptr() as *const [G; OUT_650]) }; __ret } } else { aiur_fn_650(__args, record, io_buffer, __cu)? } }; + let __r_arr: [G; OUT_646] = { let __args: [G; IN_646] = [__v_77, __v_43]; let __cu = unconstrained; if let Some(result) = record.function_queries[646].get_mut(&__args[..]) { if !__cu && *result.multiplicity == G::ZERO { aiur_fn_646(__args, record, io_buffer, false)? } else { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_646] = unsafe { *(result.output.as_ptr() as *const [G; OUT_646]) }; __ret } } else { aiur_fn_646(__args, record, io_buffer, __cu)? } }; let __v_78: G = __r_arr[0]; - let __r_arr: [G; OUT_650] = { let __args: [G; IN_650] = [__v_78, __v_18]; let __cu = unconstrained; if let Some(result) = record.function_queries[650].get_mut(&__args[..]) { if !__cu && *result.multiplicity == G::ZERO { aiur_fn_650(__args, record, io_buffer, false)? } else { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_650] = unsafe { *(result.output.as_ptr() as *const [G; OUT_650]) }; __ret } } else { aiur_fn_650(__args, record, io_buffer, __cu)? } }; + let __r_arr: [G; OUT_646] = { let __args: [G; IN_646] = [__v_78, __v_18]; let __cu = unconstrained; if let Some(result) = record.function_queries[646].get_mut(&__args[..]) { if !__cu && *result.multiplicity == G::ZERO { aiur_fn_646(__args, record, io_buffer, false)? } else { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_646] = unsafe { *(result.output.as_ptr() as *const [G; OUT_646]) }; __ret } } else { aiur_fn_646(__args, record, io_buffer, __cu)? } }; let __v_79: G = __r_arr[0]; - let __r_arr: [G; OUT_650] = { let __args: [G; IN_650] = [__v_79, __v_17]; let __cu = unconstrained; if let Some(result) = record.function_queries[650].get_mut(&__args[..]) { if !__cu && *result.multiplicity == G::ZERO { aiur_fn_650(__args, record, io_buffer, false)? } else { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_650] = unsafe { *(result.output.as_ptr() as *const [G; OUT_650]) }; __ret } } else { aiur_fn_650(__args, record, io_buffer, __cu)? } }; + let __r_arr: [G; OUT_646] = { let __args: [G; IN_646] = [__v_79, __v_17]; let __cu = unconstrained; if let Some(result) = record.function_queries[646].get_mut(&__args[..]) { if !__cu && *result.multiplicity == G::ZERO { aiur_fn_646(__args, record, io_buffer, false)? } else { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_646] = unsafe { *(result.output.as_ptr() as *const [G; OUT_646]) }; __ret } } else { aiur_fn_646(__args, record, io_buffer, __cu)? } }; let __v_80: G = __r_arr[0]; - let __r_arr: [G; OUT_650] = { let __args: [G; IN_650] = [__v_80, __v_15]; let __cu = unconstrained; if let Some(result) = record.function_queries[650].get_mut(&__args[..]) { if !__cu && *result.multiplicity == G::ZERO { aiur_fn_650(__args, record, io_buffer, false)? } else { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_650] = unsafe { *(result.output.as_ptr() as *const [G; OUT_650]) }; __ret } } else { aiur_fn_650(__args, record, io_buffer, __cu)? } }; + let __r_arr: [G; OUT_646] = { let __args: [G; IN_646] = [__v_80, __v_15]; let __cu = unconstrained; if let Some(result) = record.function_queries[646].get_mut(&__args[..]) { if !__cu && *result.multiplicity == G::ZERO { aiur_fn_646(__args, record, io_buffer, false)? } else { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_646] = unsafe { *(result.output.as_ptr() as *const [G; OUT_646]) }; __ret } } else { aiur_fn_646(__args, record, io_buffer, __cu)? } }; let __v_81: G = __r_arr[0]; - let __ret: [G; OUT_660] = [__v_81]; - if let Some(result) = record.function_queries[660].get_mut(&inp[..]) { debug_assert_eq!(result.output, &__ret[..]); if !unconstrained { *result.multiplicity += G::ONE; } } else { record.function_queries[660].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained)); }; + let __ret: [G; OUT_656] = [__v_81]; + if let Some(result) = record.function_queries[656].get_mut(&inp[..]) { debug_assert_eq!(result.output, &__ret[..]); if !unconstrained { *result.multiplicity += G::ONE; } } else { record.function_queries[656].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained)); }; return Ok(__ret); }, _ => { @@ -55811,15 +55527,15 @@ fn aiur_fn_660( }) } -const INPUT_SIZE_661: usize = 26; -const IN_661: usize = 26; -const OUT_661: usize = 0; -fn aiur_fn_661( - inp: [G; IN_661], +const INPUT_SIZE_657: usize = 26; +const IN_657: usize = 26; +const OUT_657: usize = 0; +fn aiur_fn_657( + inp: [G; IN_657], record: &mut QueryRecord, io_buffer: &mut IOBuffer, unconstrained: bool, -) -> Result<[G; OUT_661], ExecError> { +) -> Result<[G; OUT_657], ExecError> { stacker::maybe_grow(64 * 1024, 4 * 1024 * 1024, || { let __v_0: G = inp[0]; let __v_1: G = inp[1]; @@ -55854,7 +55570,7 @@ fn aiur_fn_661( let __mc_out___mc_0: [G; 13] = '__mc_0: { match __v_18.as_canonical_u64() { 1u64 => { let __v_26: G = G::from_u64(0); - let __r_arr: [G; OUT_290] = { let __args: [G; IN_290] = [__v_20, __v_21, __v_26]; let __cu = unconstrained; if let Some(result) = record.function_queries[290].get_mut(&__args[..]) { if !__cu && *result.multiplicity == G::ZERO { aiur_fn_290(__args, record, io_buffer, false)? } else { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_290] = unsafe { *(result.output.as_ptr() as *const [G; OUT_290]) }; __ret } } else { aiur_fn_290(__args, record, io_buffer, __cu)? } }; + let __r_arr: [G; OUT_286] = { let __args: [G; IN_286] = [__v_20, __v_21, __v_26]; let __cu = unconstrained; if let Some(result) = record.function_queries[286].get_mut(&__args[..]) { if !__cu && *result.multiplicity == G::ZERO { aiur_fn_286(__args, record, io_buffer, false)? } else { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_286] = unsafe { *(result.output.as_ptr() as *const [G; OUT_286]) }; __ret } } else { aiur_fn_286(__args, record, io_buffer, __cu)? } }; let __v_27: G = __r_arr[0]; let __loaded: [G; 12] = { let __mq = record.memory_queries.get_mut(&12).ok_or(ExecError::InvalidMemorySize(12))?; let __ptr_u64 = __v_27.as_canonical_u64(); let __ptr_usize = usize::try_from(__ptr_u64).ok().ok_or(ExecError::PointerTooLarge(__ptr_u64))?; let (__args, __mult) = __mq.get_index_mut(__ptr_usize).ok_or(ExecError::UnboundPointer { ptr: __ptr_u64, size: 12 })?; if !unconstrained { *__mult += G::ONE; } let __arr: [G; 12] = __args[..12].try_into().unwrap(); __arr }; let __v_28: G = __loaded[0]; @@ -55905,11 +55621,11 @@ fn aiur_fn_661( let __v_40: G = G::from_u64(1); let __v_41: G = G::from_u64(1); let __v_42: G = { let __values: [G; 3] = [__v_40, __v_41, __v_41]; let __mq = record.memory_queries.get_mut(&3).ok_or(ExecError::InvalidMemorySize(3))?; if let Some(result) = __mq.get_mut(&__values[..]) { if !unconstrained { *result.multiplicity += G::ONE; } result.output[0] } else { let __ptr = G::from_usize(__mq.len()); __mq.insert(&__values[..], &[__ptr], G::from_bool(!unconstrained)); __ptr } }; - let __r_arr: [G; OUT_593] = { let __args: [G; IN_593] = [__v_15, __v_39, __v_42]; let __cu = unconstrained; if let Some(result) = record.function_queries[593].get_mut(&__args[..]) { if !__cu && *result.multiplicity == G::ZERO { aiur_fn_593(__args, record, io_buffer, false)? } else { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_593] = unsafe { *(result.output.as_ptr() as *const [G; OUT_593]) }; __ret } } else { aiur_fn_593(__args, record, io_buffer, __cu)? } }; + let __r_arr: [G; OUT_589] = { let __args: [G; IN_589] = [__v_15, __v_39, __v_42]; let __cu = unconstrained; if let Some(result) = record.function_queries[589].get_mut(&__args[..]) { if !__cu && *result.multiplicity == G::ZERO { aiur_fn_589(__args, record, io_buffer, false)? } else { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_589] = unsafe { *(result.output.as_ptr() as *const [G; OUT_589]) }; __ret } } else { aiur_fn_589(__args, record, io_buffer, __cu)? } }; let __v_43: G = __r_arr[0]; - let __r_arr: [G; OUT_620] = { let __args: [G; IN_620] = [__v_20, __v_25]; let __cu = unconstrained; if let Some(result) = record.function_queries[620].get_mut(&__args[..]) { if !__cu && *result.multiplicity == G::ZERO { aiur_fn_620(__args, record, io_buffer, false)? } else { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_620] = unsafe { *(result.output.as_ptr() as *const [G; OUT_620]) }; __ret } } else { aiur_fn_620(__args, record, io_buffer, __cu)? } }; + let __r_arr: [G; OUT_616] = { let __args: [G; IN_616] = [__v_20, __v_25]; let __cu = unconstrained; if let Some(result) = record.function_queries[616].get_mut(&__args[..]) { if !__cu && *result.multiplicity == G::ZERO { aiur_fn_616(__args, record, io_buffer, false)? } else { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_616] = unsafe { *(result.output.as_ptr() as *const [G; OUT_616]) }; __ret } } else { aiur_fn_616(__args, record, io_buffer, __cu)? } }; let __v_44: G = __r_arr[0]; - let __r_arr: [G; OUT_614] = { let __args: [G; IN_614] = [__v_43, __v_18, __v_26, __v_27, __v_28, __v_29, __v_30, __v_31, __v_32, __v_33, __v_34, __v_35, __v_36, __v_37, __v_38, __v_44]; let __cu = unconstrained; if let Some(result) = record.function_queries[614].get_mut(&__args[..]) { if !__cu && *result.multiplicity == G::ZERO { aiur_fn_614(__args, record, io_buffer, false)? } else { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_614] = unsafe { *(result.output.as_ptr() as *const [G; OUT_614]) }; __ret } } else { aiur_fn_614(__args, record, io_buffer, __cu)? } }; + let __r_arr: [G; OUT_610] = { let __args: [G; IN_610] = [__v_43, __v_18, __v_26, __v_27, __v_28, __v_29, __v_30, __v_31, __v_32, __v_33, __v_34, __v_35, __v_36, __v_37, __v_38, __v_44]; let __cu = unconstrained; if let Some(result) = record.function_queries[610].get_mut(&__args[..]) { if !__cu && *result.multiplicity == G::ZERO { aiur_fn_610(__args, record, io_buffer, false)? } else { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_610] = unsafe { *(result.output.as_ptr() as *const [G; OUT_610]) }; __ret } } else { aiur_fn_610(__args, record, io_buffer, __cu)? } }; let __v_45: G = __r_arr[0]; let __mc_out___mc_1: [G; 1] = '__mc_1: { match __v_45.as_canonical_u64() { 1u64 => { @@ -55929,17 +55645,17 @@ fn aiur_fn_661( }; let __v_46: G = __mc_out___mc_1[0]; let __v_47: G = G::from_u64(0); - let __r_arr: [G; OUT_694] = { let __args: [G; IN_694] = [__v_1, __v_47]; let __cu = unconstrained; if let Some(result) = record.function_queries[694].get_mut(&__args[..]) { if !__cu && *result.multiplicity == G::ZERO { aiur_fn_694(__args, record, io_buffer, false)? } else { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_694] = unsafe { *(result.output.as_ptr() as *const [G; OUT_694]) }; __ret } } else { aiur_fn_694(__args, record, io_buffer, __cu)? } }; + let __r_arr: [G; OUT_690] = { let __args: [G; IN_690] = [__v_1, __v_47]; let __cu = unconstrained; if let Some(result) = record.function_queries[690].get_mut(&__args[..]) { if !__cu && *result.multiplicity == G::ZERO { aiur_fn_690(__args, record, io_buffer, false)? } else { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_690] = unsafe { *(result.output.as_ptr() as *const [G; OUT_690]) }; __ret } } else { aiur_fn_690(__args, record, io_buffer, __cu)? } }; let __v_48: G = __r_arr[0]; - let __r_arr: [G; OUT_637] = { let __args: [G; IN_637] = [__v_10, __v_20, __v_45]; let __cu = unconstrained; if let Some(result) = record.function_queries[637].get_mut(&__args[..]) { if !__cu && *result.multiplicity == G::ZERO { aiur_fn_637(__args, record, io_buffer, false)? } else { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_637] = unsafe { *(result.output.as_ptr() as *const [G; OUT_637]) }; __ret } } else { aiur_fn_637(__args, record, io_buffer, __cu)? } }; + let __r_arr: [G; OUT_633] = { let __args: [G; IN_633] = [__v_10, __v_20, __v_45]; let __cu = unconstrained; if let Some(result) = record.function_queries[633].get_mut(&__args[..]) { if !__cu && *result.multiplicity == G::ZERO { aiur_fn_633(__args, record, io_buffer, false)? } else { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_633] = unsafe { *(result.output.as_ptr() as *const [G; OUT_633]) }; __ret } } else { aiur_fn_633(__args, record, io_buffer, __cu)? } }; let __v_49: G = __r_arr[0]; - let __r_arr: [G; OUT_668] = { let __args: [G; IN_668] = [__v_49, __v_10, __v_12]; let __cu = unconstrained; if let Some(result) = record.function_queries[668].get_mut(&__args[..]) { if !__cu && *result.multiplicity == G::ZERO { aiur_fn_668(__args, record, io_buffer, false)? } else { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_668] = unsafe { *(result.output.as_ptr() as *const [G; OUT_668]) }; __ret } } else { aiur_fn_668(__args, record, io_buffer, __cu)? } }; + let __r_arr: [G; OUT_664] = { let __args: [G; IN_664] = [__v_49, __v_10, __v_12]; let __cu = unconstrained; if let Some(result) = record.function_queries[664].get_mut(&__args[..]) { if !__cu && *result.multiplicity == G::ZERO { aiur_fn_664(__args, record, io_buffer, false)? } else { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_664] = unsafe { *(result.output.as_ptr() as *const [G; OUT_664]) }; __ret } } else { aiur_fn_664(__args, record, io_buffer, __cu)? } }; let __v_50: G = __r_arr[0]; - let __r_arr: [G; OUT_671] = { let __args: [G; IN_671] = [__v_49]; let __cu = unconstrained; if let Some(result) = record.function_queries[671].get_mut(&__args[..]) { if !__cu && *result.multiplicity == G::ZERO { aiur_fn_671(__args, record, io_buffer, false)? } else { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_671] = unsafe { *(result.output.as_ptr() as *const [G; OUT_671]) }; __ret } } else { aiur_fn_671(__args, record, io_buffer, __cu)? } }; + let __r_arr: [G; OUT_667] = { let __args: [G; IN_667] = [__v_49]; let __cu = unconstrained; if let Some(result) = record.function_queries[667].get_mut(&__args[..]) { if !__cu && *result.multiplicity == G::ZERO { aiur_fn_667(__args, record, io_buffer, false)? } else { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_667] = unsafe { *(result.output.as_ptr() as *const [G; OUT_667]) }; __ret } } else { aiur_fn_667(__args, record, io_buffer, __cu)? } }; let __v_51: G = __r_arr[0]; - let __r_arr: [G; OUT_621] = { let __args: [G; IN_621] = [__v_10]; let __cu = unconstrained; if let Some(result) = record.function_queries[621].get_mut(&__args[..]) { if !__cu && *result.multiplicity == G::ZERO { aiur_fn_621(__args, record, io_buffer, false)? } else { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_621] = unsafe { *(result.output.as_ptr() as *const [G; OUT_621]) }; __ret } } else { aiur_fn_621(__args, record, io_buffer, __cu)? } }; + let __r_arr: [G; OUT_617] = { let __args: [G; IN_617] = [__v_10]; let __cu = unconstrained; if let Some(result) = record.function_queries[617].get_mut(&__args[..]) { if !__cu && *result.multiplicity == G::ZERO { aiur_fn_617(__args, record, io_buffer, false)? } else { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_617] = unsafe { *(result.output.as_ptr() as *const [G; OUT_617]) }; __ret } } else { aiur_fn_617(__args, record, io_buffer, __cu)? } }; let __v_52: G = __r_arr[0]; - let __r_arr: [G; OUT_621] = { let __args: [G; IN_621] = [__v_20]; let __cu = unconstrained; if let Some(result) = record.function_queries[621].get_mut(&__args[..]) { if !__cu && *result.multiplicity == G::ZERO { aiur_fn_621(__args, record, io_buffer, false)? } else { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_621] = unsafe { *(result.output.as_ptr() as *const [G; OUT_621]) }; __ret } } else { aiur_fn_621(__args, record, io_buffer, __cu)? } }; + let __r_arr: [G; OUT_617] = { let __args: [G; IN_617] = [__v_20]; let __cu = unconstrained; if let Some(result) = record.function_queries[617].get_mut(&__args[..]) { if !__cu && *result.multiplicity == G::ZERO { aiur_fn_617(__args, record, io_buffer, false)? } else { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_617] = unsafe { *(result.output.as_ptr() as *const [G; OUT_617]) }; __ret } } else { aiur_fn_617(__args, record, io_buffer, __cu)? } }; let __v_53: G = __r_arr[0]; let __v_54: G = G::from_u64(1); let __r_arr: [G; OUT_1] = { let __args: [G; IN_1] = [__v_10, __v_20]; let __cu = unconstrained; if let Some(result) = record.function_queries[1].get_mut(&__args[..]) { if !__cu && *result.multiplicity == G::ZERO { aiur_fn_1(__args, record, io_buffer, false)? } else { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_1] = unsafe { *(result.output.as_ptr() as *const [G; OUT_1]) }; __ret } } else { aiur_fn_1(__args, record, io_buffer, __cu)? } }; @@ -55949,7 +55665,7 @@ fn aiur_fn_661( let __v_58: G = (__v_52 * __v_57); let __mc_out___mc_2: [G; 1] = '__mc_2: { match __v_58.as_canonical_u64() { 1u64 => { - let __r_arr: [G; OUT_634] = { let __args: [G; IN_634] = [__v_0, __v_1, __v_2, __v_3, __v_4, __v_5, __v_6, __v_7, __v_8, __v_9, __v_10, __v_11, __v_16]; let __cu = unconstrained; if let Some(result) = record.function_queries[634].get_mut(&__args[..]) { if !__cu && *result.multiplicity == G::ZERO { aiur_fn_634(__args, record, io_buffer, false)? } else { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_634] = unsafe { *(result.output.as_ptr() as *const [G; OUT_634]) }; __ret } } else { aiur_fn_634(__args, record, io_buffer, __cu)? } }; + let __r_arr: [G; OUT_630] = { let __args: [G; IN_630] = [__v_0, __v_1, __v_2, __v_3, __v_4, __v_5, __v_6, __v_7, __v_8, __v_9, __v_10, __v_11, __v_16]; let __cu = unconstrained; if let Some(result) = record.function_queries[630].get_mut(&__args[..]) { if !__cu && *result.multiplicity == G::ZERO { aiur_fn_630(__args, record, io_buffer, false)? } else { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_630] = unsafe { *(result.output.as_ptr() as *const [G; OUT_630]) }; __ret } } else { aiur_fn_630(__args, record, io_buffer, __cu)? } }; let __v_59: G = __r_arr[0]; break '__mc_2 [__v_59]; }, @@ -55963,26 +55679,26 @@ fn aiur_fn_661( }; let __v_59: G = __mc_out___mc_2[0]; let __v_60: G = G::from_u64(0); - let __r_arr: [G; OUT_641] = { let __args: [G; IN_641] = [__v_49, __v_25, __v_58, __v_59, __v_60]; let __cu = unconstrained; if let Some(result) = record.function_queries[641].get_mut(&__args[..]) { if !__cu && *result.multiplicity == G::ZERO { aiur_fn_641(__args, record, io_buffer, false)? } else { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_641] = unsafe { *(result.output.as_ptr() as *const [G; OUT_641]) }; __ret } } else { aiur_fn_641(__args, record, io_buffer, __cu)? } }; + let __r_arr: [G; OUT_637] = { let __args: [G; IN_637] = [__v_49, __v_25, __v_58, __v_59, __v_60]; let __cu = unconstrained; if let Some(result) = record.function_queries[637].get_mut(&__args[..]) { if !__cu && *result.multiplicity == G::ZERO { aiur_fn_637(__args, record, io_buffer, false)? } else { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_637] = unsafe { *(result.output.as_ptr() as *const [G; OUT_637]) }; __ret } } else { aiur_fn_637(__args, record, io_buffer, __cu)? } }; let __v_61: G = __r_arr[0]; let __v_62: G = __r_arr[1]; match __v_61.as_canonical_u64() { 1u64 => { - let __r_arr: [G; OUT_662] = { let __args: [G; IN_662] = [__v_49, __v_62, __v_18, __v_20, __v_21, __v_3, __v_5, __v_6, __v_48, __v_50, __v_51, __v_7, __v_2, __v_15, __v_14, __v_17, __v_46, __v_45]; let __cu = unconstrained; if let Some(result) = record.function_queries[662].get_mut(&__args[..]) { if !__cu && *result.multiplicity == G::ZERO { aiur_fn_662(__args, record, io_buffer, false)? } else { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_662] = unsafe { *(result.output.as_ptr() as *const [G; OUT_662]) }; __ret } } else { aiur_fn_662(__args, record, io_buffer, __cu)? } }; - let __ret: [G; OUT_661] = []; - if let Some(result) = record.function_queries[661].get_mut(&inp[..]) { debug_assert_eq!(result.output, &__ret[..]); if !unconstrained { *result.multiplicity += G::ONE; } } else { record.function_queries[661].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained)); }; + let __r_arr: [G; OUT_658] = { let __args: [G; IN_658] = [__v_49, __v_62, __v_18, __v_20, __v_21, __v_3, __v_5, __v_6, __v_48, __v_50, __v_51, __v_7, __v_2, __v_15, __v_14, __v_17, __v_46, __v_45]; let __cu = unconstrained; if let Some(result) = record.function_queries[658].get_mut(&__args[..]) { if !__cu && *result.multiplicity == G::ZERO { aiur_fn_658(__args, record, io_buffer, false)? } else { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_658] = unsafe { *(result.output.as_ptr() as *const [G; OUT_658]) }; __ret } } else { aiur_fn_658(__args, record, io_buffer, __cu)? } }; + let __ret: [G; OUT_657] = []; + if let Some(result) = record.function_queries[657].get_mut(&inp[..]) { debug_assert_eq!(result.output, &__ret[..]); if !unconstrained { *result.multiplicity += G::ONE; } } else { record.function_queries[657].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained)); }; return Ok(__ret); }, _ => { let __v_63: G = G::from_u64(0); - let __r_arr: [G; OUT_640] = { let __args: [G; IN_640] = [__v_49, __v_25, __v_63]; let __cu = unconstrained; if let Some(result) = record.function_queries[640].get_mut(&__args[..]) { if !__cu && *result.multiplicity == G::ZERO { aiur_fn_640(__args, record, io_buffer, false)? } else { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_640] = unsafe { *(result.output.as_ptr() as *const [G; OUT_640]) }; __ret } } else { aiur_fn_640(__args, record, io_buffer, __cu)? } }; + let __r_arr: [G; OUT_636] = { let __args: [G; IN_636] = [__v_49, __v_25, __v_63]; let __cu = unconstrained; if let Some(result) = record.function_queries[636].get_mut(&__args[..]) { if !__cu && *result.multiplicity == G::ZERO { aiur_fn_636(__args, record, io_buffer, false)? } else { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_636] = unsafe { *(result.output.as_ptr() as *const [G; OUT_636]) }; __ret } } else { aiur_fn_636(__args, record, io_buffer, __cu)? } }; let __v_64: G = __r_arr[0]; let __v_65: G = __r_arr[1]; match __v_64.as_canonical_u64() { 1u64 => { - let __r_arr: [G; OUT_662] = { let __args: [G; IN_662] = [__v_49, __v_65, __v_18, __v_20, __v_21, __v_3, __v_5, __v_6, __v_48, __v_50, __v_51, __v_7, __v_2, __v_15, __v_14, __v_17, __v_46, __v_45]; let __cu = unconstrained; if let Some(result) = record.function_queries[662].get_mut(&__args[..]) { if !__cu && *result.multiplicity == G::ZERO { aiur_fn_662(__args, record, io_buffer, false)? } else { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_662] = unsafe { *(result.output.as_ptr() as *const [G; OUT_662]) }; __ret } } else { aiur_fn_662(__args, record, io_buffer, __cu)? } }; - let __ret: [G; OUT_661] = []; - if let Some(result) = record.function_queries[661].get_mut(&inp[..]) { debug_assert_eq!(result.output, &__ret[..]); if !unconstrained { *result.multiplicity += G::ONE; } } else { record.function_queries[661].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained)); }; + let __r_arr: [G; OUT_658] = { let __args: [G; IN_658] = [__v_49, __v_65, __v_18, __v_20, __v_21, __v_3, __v_5, __v_6, __v_48, __v_50, __v_51, __v_7, __v_2, __v_15, __v_14, __v_17, __v_46, __v_45]; let __cu = unconstrained; if let Some(result) = record.function_queries[658].get_mut(&__args[..]) { if !__cu && *result.multiplicity == G::ZERO { aiur_fn_658(__args, record, io_buffer, false)? } else { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_658] = unsafe { *(result.output.as_ptr() as *const [G; OUT_658]) }; __ret } } else { aiur_fn_658(__args, record, io_buffer, __cu)? } }; + let __ret: [G; OUT_657] = []; + if let Some(result) = record.function_queries[657].get_mut(&inp[..]) { debug_assert_eq!(result.output, &__ret[..]); if !unconstrained { *result.multiplicity += G::ONE; } } else { record.function_queries[657].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained)); }; return Ok(__ret); }, _ => { @@ -55993,8 +55709,8 @@ fn aiur_fn_661( } }, _ => { - let __ret: [G; OUT_661] = []; - if let Some(result) = record.function_queries[661].get_mut(&inp[..]) { debug_assert_eq!(result.output, &__ret[..]); if !unconstrained { *result.multiplicity += G::ONE; } } else { record.function_queries[661].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained)); }; + let __ret: [G; OUT_657] = []; + if let Some(result) = record.function_queries[657].get_mut(&inp[..]) { debug_assert_eq!(result.output, &__ret[..]); if !unconstrained { *result.multiplicity += G::ONE; } } else { record.function_queries[657].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained)); }; return Ok(__ret); }, } @@ -56006,15 +55722,15 @@ fn aiur_fn_661( }) } -const INPUT_SIZE_662: usize = 18; -const IN_662: usize = 18; -const OUT_662: usize = 0; -fn aiur_fn_662( - inp: [G; IN_662], +const INPUT_SIZE_658: usize = 18; +const IN_658: usize = 18; +const OUT_658: usize = 0; +fn aiur_fn_658( + inp: [G; IN_658], record: &mut QueryRecord, io_buffer: &mut IOBuffer, unconstrained: bool, -) -> Result<[G; OUT_662], ExecError> { +) -> Result<[G; OUT_658], ExecError> { stacker::maybe_grow(64 * 1024, 4 * 1024 * 1024, || { let __v_0: G = inp[0]; let __v_1: G = inp[1]; @@ -56034,45 +55750,57 @@ fn aiur_fn_662( let __v_15: G = inp[15]; let __v_16: G = inp[16]; let __v_17: G = inp[17]; - let __r_arr: [G; OUT_642] = { let __args: [G; IN_642] = [__v_0, __v_1]; let __cu = unconstrained; if let Some(result) = record.function_queries[642].get_mut(&__args[..]) { if !__cu && *result.multiplicity == G::ZERO { aiur_fn_642(__args, record, io_buffer, false)? } else { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_642] = unsafe { *(result.output.as_ptr() as *const [G; OUT_642]) }; __ret } } else { aiur_fn_642(__args, record, io_buffer, __cu)? } }; + let __r_arr: [G; OUT_638] = { let __args: [G; IN_638] = [__v_0, __v_1]; let __cu = unconstrained; if let Some(result) = record.function_queries[638].get_mut(&__args[..]) { if !__cu && *result.multiplicity == G::ZERO { aiur_fn_638(__args, record, io_buffer, false)? } else { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_638] = unsafe { *(result.output.as_ptr() as *const [G; OUT_638]) }; __ret } } else { aiur_fn_638(__args, record, io_buffer, __cu)? } }; let __v_18: G = __r_arr[0]; let __v_19: G = __r_arr[1]; let __v_20: G = __r_arr[2]; let __v_21: G = __r_arr[3]; - let __r_arr: [G; OUT_659] = { let __args: [G; IN_659] = [__v_13, __v_14, __v_5, __v_15, __v_16, __v_17, __v_0, __v_10, __v_1]; let __cu = unconstrained; if let Some(result) = record.function_queries[659].get_mut(&__args[..]) { if !__cu && *result.multiplicity == G::ZERO { aiur_fn_659(__args, record, io_buffer, false)? } else { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_659] = unsafe { *(result.output.as_ptr() as *const [G; OUT_659]) }; __ret } } else { aiur_fn_659(__args, record, io_buffer, __cu)? } }; + let __r_arr: [G; OUT_655] = { let __args: [G; IN_655] = [__v_13, __v_14, __v_5, __v_15, __v_16, __v_17, __v_0, __v_10, __v_1]; let __cu = unconstrained; if let Some(result) = record.function_queries[655].get_mut(&__args[..]) { if !__cu && *result.multiplicity == G::ZERO { aiur_fn_655(__args, record, io_buffer, false)? } else { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_655] = unsafe { *(result.output.as_ptr() as *const [G; OUT_655]) }; __ret } } else { aiur_fn_655(__args, record, io_buffer, __cu)? } }; let __v_22: G = __r_arr[0]; - let __v_23: G = G::from_u64(0); - let __r_arr: [G; OUT_663] = { let __args: [G; IN_663] = [__v_0, __v_1, __v_23]; let __cu = unconstrained; if let Some(result) = record.function_queries[663].get_mut(&__args[..]) { if !__cu && *result.multiplicity == G::ZERO { aiur_fn_663(__args, record, io_buffer, false)? } else { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_663] = unsafe { *(result.output.as_ptr() as *const [G; OUT_663]) }; __ret } } else { aiur_fn_663(__args, record, io_buffer, __cu)? } }; + let __r_arr: [G; OUT_775] = { let __args: [G; IN_775] = [__v_0]; let __cu = unconstrained; if let Some(result) = record.function_queries[775].get_mut(&__args[..]) { if !__cu && *result.multiplicity == G::ZERO { aiur_fn_775(__args, record, io_buffer, false)? } else { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_775] = unsafe { *(result.output.as_ptr() as *const [G; OUT_775]) }; __ret } } else { aiur_fn_775(__args, record, io_buffer, __cu)? } }; + let __v_23: G = __r_arr[0]; + let __r_arr: [G; OUT_670] = { let __args: [G; IN_670] = [__v_0, __v_10, __v_5, __v_23, __v_5]; let __cu = unconstrained; if let Some(result) = record.function_queries[670].get_mut(&__args[..]) { if !__cu && *result.multiplicity == G::ZERO { aiur_fn_670(__args, record, io_buffer, false)? } else { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_670] = unsafe { *(result.output.as_ptr() as *const [G; OUT_670]) }; __ret } } else { aiur_fn_670(__args, record, io_buffer, __cu)? } }; let __v_24: G = __r_arr[0]; - let __v_25: G = G::from_u64(0); - let __r_arr: [G; OUT_664] = { let __args: [G; IN_664] = [__v_2, __v_24, __v_3, __v_4, __v_5, __v_6, __v_7, __v_21, __v_8, __v_0, __v_9, __v_10, __v_19, __v_20, __v_25]; let __cu = unconstrained; if let Some(result) = record.function_queries[664].get_mut(&__args[..]) { if !__cu && *result.multiplicity == G::ZERO { aiur_fn_664(__args, record, io_buffer, false)? } else { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_664] = unsafe { *(result.output.as_ptr() as *const [G; OUT_664]) }; __ret } } else { aiur_fn_664(__args, record, io_buffer, __cu)? } }; - let __v_26: G = __r_arr[0]; - let __v_27: G = G::from_u64(1); - let __v_28: G = G::from_u64(1); - let __v_29: G = { let __values: [G; 3] = [__v_27, __v_28, __v_28]; let __mq = record.memory_queries.get_mut(&3).ok_or(ExecError::InvalidMemorySize(3))?; if let Some(result) = __mq.get_mut(&__values[..]) { if !unconstrained { *result.multiplicity += G::ONE; } result.output[0] } else { let __ptr = G::from_usize(__mq.len()); __mq.insert(&__values[..], &[__ptr], G::from_bool(!unconstrained)); __ptr } }; - let __r_arr: [G; OUT_439] = { let __args: [G; IN_439] = [__v_12, __v_22, __v_29]; let __cu = unconstrained; if let Some(result) = record.function_queries[439].get_mut(&__args[..]) { if !__cu && *result.multiplicity == G::ZERO { aiur_fn_439(__args, record, io_buffer, false)? } else { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_439] = unsafe { *(result.output.as_ptr() as *const [G; OUT_439]) }; __ret } } else { aiur_fn_439(__args, record, io_buffer, __cu)? } }; - let __v_30: G = __r_arr[0]; + let __r_arr: [G; OUT_760] = { let __args: [G; IN_760] = [__v_24]; let __cu = unconstrained; if let Some(result) = record.function_queries[760].get_mut(&__args[..]) { if !__cu && *result.multiplicity == G::ZERO { aiur_fn_760(__args, record, io_buffer, false)? } else { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_760] = unsafe { *(result.output.as_ptr() as *const [G; OUT_760]) }; __ret } } else { aiur_fn_760(__args, record, io_buffer, __cu)? } }; + let __v_25: G = __r_arr[0]; + let __v_26: G = G::from_u64(0); + let __r_arr: [G; OUT_659] = { let __args: [G; IN_659] = [__v_0, __v_1, __v_26]; let __cu = unconstrained; if let Some(result) = record.function_queries[659].get_mut(&__args[..]) { if !__cu && *result.multiplicity == G::ZERO { aiur_fn_659(__args, record, io_buffer, false)? } else { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_659] = unsafe { *(result.output.as_ptr() as *const [G; OUT_659]) }; __ret } } else { aiur_fn_659(__args, record, io_buffer, __cu)? } }; + let __v_27: G = __r_arr[0]; + let __v_28: G = G::from_u64(0); + let __r_arr: [G; OUT_660] = { let __args: [G; IN_660] = [__v_2, __v_27, __v_3, __v_4, __v_5, __v_6, __v_7, __v_21, __v_8, __v_0, __v_9, __v_10, __v_19, __v_20, __v_28]; let __cu = unconstrained; if let Some(result) = record.function_queries[660].get_mut(&__args[..]) { if !__cu && *result.multiplicity == G::ZERO { aiur_fn_660(__args, record, io_buffer, false)? } else { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_660] = unsafe { *(result.output.as_ptr() as *const [G; OUT_660]) }; __ret } } else { aiur_fn_660(__args, record, io_buffer, __cu)? } }; + let __v_29: G = __r_arr[0]; + let __v_30: G = G::from_u64(1); let __v_31: G = G::from_u64(1); - if (__v_30 != __v_31) { - return Err(ExecError::AssertEqMismatch { lhs: __v_30.as_canonical_u64(), rhs: __v_31.as_canonical_u64(), msg: Some("recursor's declared type is not def-eq to the canonical reconstruction".to_string()) }); + let __v_32: G = { let __values: [G; 3] = [__v_30, __v_31, __v_31]; let __mq = record.memory_queries.get_mut(&3).ok_or(ExecError::InvalidMemorySize(3))?; if let Some(result) = __mq.get_mut(&__values[..]) { if !unconstrained { *result.multiplicity += G::ONE; } result.output[0] } else { let __ptr = G::from_usize(__mq.len()); __mq.insert(&__values[..], &[__ptr], G::from_bool(!unconstrained)); __ptr } }; + let __r_arr: [G; OUT_435] = { let __args: [G; IN_435] = [__v_12, __v_22, __v_32]; let __cu = unconstrained; if let Some(result) = record.function_queries[435].get_mut(&__args[..]) { if !__cu && *result.multiplicity == G::ZERO { aiur_fn_435(__args, record, io_buffer, false)? } else { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_435] = unsafe { *(result.output.as_ptr() as *const [G; OUT_435]) }; __ret } } else { aiur_fn_435(__args, record, io_buffer, __cu)? } }; + let __v_33: G = __r_arr[0]; + let __v_34: G = G::from_u64(1); + if (__v_33 != __v_34) { + return Err(ExecError::AssertEqMismatch { lhs: __v_33.as_canonical_u64(), rhs: __v_34.as_canonical_u64(), msg: Some("recursor's declared type is not def-eq to the canonical reconstruction".to_string()) }); } - let __v_32: G = G::from_u64(0); - let __r_arr: [G; OUT_665] = { let __args: [G; IN_665] = [__v_11, __v_26, __v_5, __v_6, __v_7, __v_3, __v_4, __v_2, __v_32]; let __cu = unconstrained; if let Some(result) = record.function_queries[665].get_mut(&__args[..]) { if !__cu && *result.multiplicity == G::ZERO { aiur_fn_665(__args, record, io_buffer, false)? } else { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_665] = unsafe { *(result.output.as_ptr() as *const [G; OUT_665]) }; __ret } } else { aiur_fn_665(__args, record, io_buffer, __cu)? } }; - let __ret: [G; OUT_662] = []; - if let Some(result) = record.function_queries[662].get_mut(&inp[..]) { debug_assert_eq!(result.output, &__ret[..]); if !unconstrained { *result.multiplicity += G::ONE; } } else { record.function_queries[662].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained)); }; + if (__v_6 != __v_23) { + return Err(ExecError::AssertEqMismatch { lhs: __v_6.as_canonical_u64(), rhs: __v_23.as_canonical_u64(), msg: Some("recursor motive count disagrees with the canonical reconstruction".to_string()) }); + } + if (__v_7 != __v_25) { + return Err(ExecError::AssertEqMismatch { lhs: __v_7.as_canonical_u64(), rhs: __v_25.as_canonical_u64(), msg: Some("recursor minor count disagrees with the canonical reconstruction".to_string()) }); + } + let __v_35: G = G::from_u64(0); + let __r_arr: [G; OUT_661] = { let __args: [G; IN_661] = [__v_11, __v_29, __v_5, __v_6, __v_7, __v_3, __v_4, __v_2, __v_35]; let __cu = unconstrained; if let Some(result) = record.function_queries[661].get_mut(&__args[..]) { if !__cu && *result.multiplicity == G::ZERO { aiur_fn_661(__args, record, io_buffer, false)? } else { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_661] = unsafe { *(result.output.as_ptr() as *const [G; OUT_661]) }; __ret } } else { aiur_fn_661(__args, record, io_buffer, __cu)? } }; + let __ret: [G; OUT_658] = []; + if let Some(result) = record.function_queries[658].get_mut(&inp[..]) { debug_assert_eq!(result.output, &__ret[..]); if !unconstrained { *result.multiplicity += G::ONE; } } else { record.function_queries[658].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained)); }; return Ok(__ret); }) } -const INPUT_SIZE_663: usize = 3; -const IN_663: usize = 3; -const OUT_663: usize = 1; -fn aiur_fn_663( - inp: [G; IN_663], +const INPUT_SIZE_659: usize = 3; +const IN_659: usize = 3; +const OUT_659: usize = 1; +fn aiur_fn_659( + inp: [G; IN_659], record: &mut QueryRecord, io_buffer: &mut IOBuffer, unconstrained: bool, -) -> Result<[G; OUT_663], ExecError> { +) -> Result<[G; OUT_659], ExecError> { stacker::maybe_grow(64 * 1024, 4 * 1024 * 1024, || { let __v_0: G = inp[0]; let __v_1: G = inp[1]; @@ -56081,8 +55809,8 @@ fn aiur_fn_663( match __v_3.as_canonical_u64() { 0u64 => { let __v_4: G = G::from_u64(0); - let __ret: [G; OUT_663] = [__v_4]; - if let Some(result) = record.function_queries[663].get_mut(&inp[..]) { debug_assert_eq!(result.output, &__ret[..]); if !unconstrained { *result.multiplicity += G::ONE; } } else { record.function_queries[663].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained)); }; + let __ret: [G; OUT_659] = [__v_4]; + if let Some(result) = record.function_queries[659].get_mut(&inp[..]) { debug_assert_eq!(result.output, &__ret[..]); if !unconstrained { *result.multiplicity += G::ONE; } } else { record.function_queries[659].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained)); }; return Ok(__ret); }, _ => { @@ -56096,12 +55824,12 @@ fn aiur_fn_663( match __v_4.as_canonical_u64() { 1u64 => { let __v_10: G = G::from_u64(0); - let __ret: [G; OUT_663] = [__v_10]; - if let Some(result) = record.function_queries[663].get_mut(&inp[..]) { debug_assert_eq!(result.output, &__ret[..]); if !unconstrained { *result.multiplicity += G::ONE; } } else { record.function_queries[663].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained)); }; + let __ret: [G; OUT_659] = [__v_10]; + if let Some(result) = record.function_queries[659].get_mut(&inp[..]) { debug_assert_eq!(result.output, &__ret[..]); if !unconstrained { *result.multiplicity += G::ONE; } } else { record.function_queries[659].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained)); }; return Ok(__ret); }, 0u64 => { - let __r_arr: [G; OUT_287] = { let __args: [G; IN_287] = [__v_5]; let __cu = unconstrained; if let Some(result) = record.function_queries[287].get_mut(&__args[..]) { if !__cu && *result.multiplicity == G::ZERO { aiur_fn_287(__args, record, io_buffer, false)? } else { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_287] = unsafe { *(result.output.as_ptr() as *const [G; OUT_287]) }; __ret } } else { aiur_fn_287(__args, record, io_buffer, __cu)? } }; + let __r_arr: [G; OUT_283] = { let __args: [G; IN_283] = [__v_5]; let __cu = unconstrained; if let Some(result) = record.function_queries[283].get_mut(&__args[..]) { if !__cu && *result.multiplicity == G::ZERO { aiur_fn_283(__args, record, io_buffer, false)? } else { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_283] = unsafe { *(result.output.as_ptr() as *const [G; OUT_283]) }; __ret } } else { aiur_fn_283(__args, record, io_buffer, __cu)? } }; let __v_10: G = __r_arr[0]; let __loaded: [G; 12] = { let __mq = record.memory_queries.get_mut(&12).ok_or(ExecError::InvalidMemorySize(12))?; let __ptr_u64 = __v_10.as_canonical_u64(); let __ptr_usize = usize::try_from(__ptr_u64).ok().ok_or(ExecError::PointerTooLarge(__ptr_u64))?; let (__args, __mult) = __mq.get_index_mut(__ptr_usize).ok_or(ExecError::UnboundPointer { ptr: __ptr_u64, size: 12 })?; if !unconstrained { *__mult += G::ONE; } let __arr: [G; 12] = __args[..12].try_into().unwrap(); __arr }; let __v_11: G = __loaded[0]; @@ -56129,11 +55857,11 @@ fn aiur_fn_663( let __v_23: G = __mc_out___mc_0[0]; let __v_24: G = G::from_u64(1); let __v_25: G = (__v_2 + __v_24); - let __r_arr: [G; OUT_663] = { let __args: [G; IN_663] = [__v_9, __v_1, __v_25]; let __cu = unconstrained; if let Some(result) = record.function_queries[663].get_mut(&__args[..]) { if !__cu && *result.multiplicity == G::ZERO { aiur_fn_663(__args, record, io_buffer, false)? } else { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_663] = unsafe { *(result.output.as_ptr() as *const [G; OUT_663]) }; __ret } } else { aiur_fn_663(__args, record, io_buffer, __cu)? } }; + let __r_arr: [G; OUT_659] = { let __args: [G; IN_659] = [__v_9, __v_1, __v_25]; let __cu = unconstrained; if let Some(result) = record.function_queries[659].get_mut(&__args[..]) { if !__cu && *result.multiplicity == G::ZERO { aiur_fn_659(__args, record, io_buffer, false)? } else { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_659] = unsafe { *(result.output.as_ptr() as *const [G; OUT_659]) }; __ret } } else { aiur_fn_659(__args, record, io_buffer, __cu)? } }; let __v_26: G = __r_arr[0]; let __v_27: G = (__v_23 + __v_26); - let __ret: [G; OUT_663] = [__v_27]; - if let Some(result) = record.function_queries[663].get_mut(&inp[..]) { debug_assert_eq!(result.output, &__ret[..]); if !unconstrained { *result.multiplicity += G::ONE; } } else { record.function_queries[663].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained)); }; + let __ret: [G; OUT_659] = [__v_27]; + if let Some(result) = record.function_queries[659].get_mut(&inp[..]) { debug_assert_eq!(result.output, &__ret[..]); if !unconstrained { *result.multiplicity += G::ONE; } } else { record.function_queries[659].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained)); }; return Ok(__ret); }, _ => { @@ -56145,15 +55873,15 @@ fn aiur_fn_663( }) } -const INPUT_SIZE_664: usize = 15; -const IN_664: usize = 15; -const OUT_664: usize = 1; -fn aiur_fn_664( - inp: [G; IN_664], +const INPUT_SIZE_660: usize = 15; +const IN_660: usize = 15; +const OUT_660: usize = 1; +fn aiur_fn_660( + inp: [G; IN_660], record: &mut QueryRecord, io_buffer: &mut IOBuffer, unconstrained: bool, -) -> Result<[G; OUT_664], ExecError> { +) -> Result<[G; OUT_660], ExecError> { stacker::maybe_grow(64 * 1024, 4 * 1024 * 1024, || { let __v_0: G = inp[0]; let __v_1: G = inp[1]; @@ -56176,12 +55904,12 @@ fn aiur_fn_664( let __v_16: G = G::from_u64(1); let __v_17: G = G::from_u64(1); let __v_18: G = { let __values: [G; 3] = [__v_16, __v_17, __v_17]; let __mq = record.memory_queries.get_mut(&3).ok_or(ExecError::InvalidMemorySize(3))?; if let Some(result) = __mq.get_mut(&__values[..]) { if !unconstrained { *result.multiplicity += G::ONE; } result.output[0] } else { let __ptr = G::from_usize(__mq.len()); __mq.insert(&__values[..], &[__ptr], G::from_bool(!unconstrained)); __ptr } }; - let __ret: [G; OUT_664] = [__v_18]; - if let Some(result) = record.function_queries[664].get_mut(&inp[..]) { debug_assert_eq!(result.output, &__ret[..]); if !unconstrained { *result.multiplicity += G::ONE; } } else { record.function_queries[664].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained)); }; + let __ret: [G; OUT_660] = [__v_18]; + if let Some(result) = record.function_queries[660].get_mut(&inp[..]) { debug_assert_eq!(result.output, &__ret[..]); if !unconstrained { *result.multiplicity += G::ONE; } } else { record.function_queries[660].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained)); }; return Ok(__ret); }, _ => { - let __r_arr: [G; OUT_290] = { let __args: [G; IN_290] = [__v_2, __v_3, __v_14]; let __cu = unconstrained; if let Some(result) = record.function_queries[290].get_mut(&__args[..]) { if !__cu && *result.multiplicity == G::ZERO { aiur_fn_290(__args, record, io_buffer, false)? } else { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_290] = unsafe { *(result.output.as_ptr() as *const [G; OUT_290]) }; __ret } } else { aiur_fn_290(__args, record, io_buffer, __cu)? } }; + let __r_arr: [G; OUT_286] = { let __args: [G; IN_286] = [__v_2, __v_3, __v_14]; let __cu = unconstrained; if let Some(result) = record.function_queries[286].get_mut(&__args[..]) { if !__cu && *result.multiplicity == G::ZERO { aiur_fn_286(__args, record, io_buffer, false)? } else { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_286] = unsafe { *(result.output.as_ptr() as *const [G; OUT_286]) }; __ret } } else { aiur_fn_286(__args, record, io_buffer, __cu)? } }; let __v_16: G = __r_arr[0]; let __loaded: [G; 12] = { let __mq = record.memory_queries.get_mut(&12).ok_or(ExecError::InvalidMemorySize(12))?; let __ptr_u64 = __v_16.as_canonical_u64(); let __ptr_usize = usize::try_from(__ptr_u64).ok().ok_or(ExecError::PointerTooLarge(__ptr_u64))?; let (__args, __mult) = __mq.get_index_mut(__ptr_usize).ok_or(ExecError::UnboundPointer { ptr: __ptr_u64, size: 12 })?; if !unconstrained { *__mult += G::ONE; } let __arr: [G; 12] = __args[..12].try_into().unwrap(); __arr }; let __v_17: G = __loaded[0]; @@ -56199,24 +55927,24 @@ fn aiur_fn_664( match __v_17.as_canonical_u64() { 6u64 => { let __v_29: G = (__v_1 + __v_14); - let __r_arr: [G; OUT_667] = { let __args: [G; IN_667] = [__v_19, __v_29, __v_4, __v_5, __v_6, __v_23, __v_7, __v_8, __v_9, __v_10, __v_11, __v_12, __v_13]; let __cu = unconstrained; if let Some(result) = record.function_queries[667].get_mut(&__args[..]) { if !__cu && *result.multiplicity == G::ZERO { aiur_fn_667(__args, record, io_buffer, false)? } else { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_667] = unsafe { *(result.output.as_ptr() as *const [G; OUT_667]) }; __ret } } else { aiur_fn_667(__args, record, io_buffer, __cu)? } }; + let __r_arr: [G; OUT_663] = { let __args: [G; IN_663] = [__v_19, __v_29, __v_4, __v_5, __v_6, __v_23, __v_7, __v_8, __v_9, __v_10, __v_11, __v_12, __v_13]; let __cu = unconstrained; if let Some(result) = record.function_queries[663].get_mut(&__args[..]) { if !__cu && *result.multiplicity == G::ZERO { aiur_fn_663(__args, record, io_buffer, false)? } else { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_663] = unsafe { *(result.output.as_ptr() as *const [G; OUT_663]) }; __ret } } else { aiur_fn_663(__args, record, io_buffer, __cu)? } }; let __v_30: G = __r_arr[0]; let __v_31: G = G::from_u64(0); let __v_32: G = G::from_u64(1); let __v_33: G = (__v_14 + __v_32); - let __r_arr: [G; OUT_664] = { let __args: [G; IN_664] = [__v_0, __v_1, __v_2, __v_3, __v_4, __v_5, __v_6, __v_7, __v_8, __v_9, __v_10, __v_11, __v_12, __v_13, __v_33]; let __cu = unconstrained; if let Some(result) = record.function_queries[664].get_mut(&__args[..]) { if !__cu && *result.multiplicity == G::ZERO { aiur_fn_664(__args, record, io_buffer, false)? } else { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_664] = unsafe { *(result.output.as_ptr() as *const [G; OUT_664]) }; __ret } } else { aiur_fn_664(__args, record, io_buffer, __cu)? } }; + let __r_arr: [G; OUT_660] = { let __args: [G; IN_660] = [__v_0, __v_1, __v_2, __v_3, __v_4, __v_5, __v_6, __v_7, __v_8, __v_9, __v_10, __v_11, __v_12, __v_13, __v_33]; let __cu = unconstrained; if let Some(result) = record.function_queries[660].get_mut(&__args[..]) { if !__cu && *result.multiplicity == G::ZERO { aiur_fn_660(__args, record, io_buffer, false)? } else { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_660] = unsafe { *(result.output.as_ptr() as *const [G; OUT_660]) }; __ret } } else { aiur_fn_660(__args, record, io_buffer, __cu)? } }; let __v_34: G = __r_arr[0]; let __v_35: G = { let __values: [G; 3] = [__v_31, __v_30, __v_34]; let __mq = record.memory_queries.get_mut(&3).ok_or(ExecError::InvalidMemorySize(3))?; if let Some(result) = __mq.get_mut(&__values[..]) { if !unconstrained { *result.multiplicity += G::ONE; } result.output[0] } else { let __ptr = G::from_usize(__mq.len()); __mq.insert(&__values[..], &[__ptr], G::from_bool(!unconstrained)); __ptr } }; - let __ret: [G; OUT_664] = [__v_35]; - if let Some(result) = record.function_queries[664].get_mut(&inp[..]) { debug_assert_eq!(result.output, &__ret[..]); if !unconstrained { *result.multiplicity += G::ONE; } } else { record.function_queries[664].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained)); }; + let __ret: [G; OUT_660] = [__v_35]; + if let Some(result) = record.function_queries[660].get_mut(&inp[..]) { debug_assert_eq!(result.output, &__ret[..]); if !unconstrained { *result.multiplicity += G::ONE; } } else { record.function_queries[660].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained)); }; return Ok(__ret); }, _ => { let __v_29: G = G::from_u64(1); let __v_30: G = G::from_u64(1); let __v_31: G = { let __values: [G; 3] = [__v_29, __v_30, __v_30]; let __mq = record.memory_queries.get_mut(&3).ok_or(ExecError::InvalidMemorySize(3))?; if let Some(result) = __mq.get_mut(&__values[..]) { if !unconstrained { *result.multiplicity += G::ONE; } result.output[0] } else { let __ptr = G::from_usize(__mq.len()); __mq.insert(&__values[..], &[__ptr], G::from_bool(!unconstrained)); __ptr } }; - let __ret: [G; OUT_664] = [__v_31]; - if let Some(result) = record.function_queries[664].get_mut(&inp[..]) { debug_assert_eq!(result.output, &__ret[..]); if !unconstrained { *result.multiplicity += G::ONE; } } else { record.function_queries[664].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained)); }; + let __ret: [G; OUT_660] = [__v_31]; + if let Some(result) = record.function_queries[660].get_mut(&inp[..]) { debug_assert_eq!(result.output, &__ret[..]); if !unconstrained { *result.multiplicity += G::ONE; } } else { record.function_queries[660].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained)); }; return Ok(__ret); }, } @@ -56225,15 +55953,15 @@ fn aiur_fn_664( }) } -const INPUT_SIZE_665: usize = 9; -const IN_665: usize = 9; -const OUT_665: usize = 0; -fn aiur_fn_665( - inp: [G; IN_665], +const INPUT_SIZE_661: usize = 9; +const IN_661: usize = 9; +const OUT_661: usize = 0; +fn aiur_fn_661( + inp: [G; IN_661], record: &mut QueryRecord, io_buffer: &mut IOBuffer, unconstrained: bool, -) -> Result<[G; OUT_665], ExecError> { +) -> Result<[G; OUT_661], ExecError> { stacker::maybe_grow(64 * 1024, 4 * 1024 * 1024, || { let __v_0: G = inp[0]; let __v_1: G = inp[1]; @@ -56252,14 +55980,14 @@ fn aiur_fn_665( let __v_13: G = __loaded[4]; match __v_9.as_canonical_u64() { 1u64 => { - let __ret: [G; OUT_665] = []; - if let Some(result) = record.function_queries[665].get_mut(&inp[..]) { debug_assert_eq!(result.output, &__ret[..]); if !unconstrained { *result.multiplicity += G::ONE; } } else { record.function_queries[665].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained)); }; + let __ret: [G; OUT_661] = []; + if let Some(result) = record.function_queries[661].get_mut(&inp[..]) { debug_assert_eq!(result.output, &__ret[..]); if !unconstrained { *result.multiplicity += G::ONE; } } else { record.function_queries[661].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained)); }; return Ok(__ret); }, 0u64 => { match __v_10.as_canonical_u64() { _ => { - let __r_arr: [G; OUT_290] = { let __args: [G; IN_290] = [__v_5, __v_6, __v_10]; let __cu = unconstrained; if let Some(result) = record.function_queries[290].get_mut(&__args[..]) { if !__cu && *result.multiplicity == G::ZERO { aiur_fn_290(__args, record, io_buffer, false)? } else { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_290] = unsafe { *(result.output.as_ptr() as *const [G; OUT_290]) }; __ret } } else { aiur_fn_290(__args, record, io_buffer, __cu)? } }; + let __r_arr: [G; OUT_286] = { let __args: [G; IN_286] = [__v_5, __v_6, __v_10]; let __cu = unconstrained; if let Some(result) = record.function_queries[286].get_mut(&__args[..]) { if !__cu && *result.multiplicity == G::ZERO { aiur_fn_286(__args, record, io_buffer, false)? } else { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_286] = unsafe { *(result.output.as_ptr() as *const [G; OUT_286]) }; __ret } } else { aiur_fn_286(__args, record, io_buffer, __cu)? } }; let __v_14: G = __r_arr[0]; let __loaded: [G; 12] = { let __mq = record.memory_queries.get_mut(&12).ok_or(ExecError::InvalidMemorySize(12))?; let __ptr_u64 = __v_14.as_canonical_u64(); let __ptr_usize = usize::try_from(__ptr_u64).ok().ok_or(ExecError::PointerTooLarge(__ptr_u64))?; let (__args, __mult) = __mq.get_index_mut(__ptr_usize).ok_or(ExecError::UnboundPointer { ptr: __ptr_u64, size: 12 })?; if !unconstrained { *__mult += G::ONE; } let __arr: [G; 12] = __args[..12].try_into().unwrap(); __arr }; let __v_15: G = __loaded[0]; @@ -56300,8 +56028,8 @@ fn aiur_fn_665( let __v_31: G = __loaded[2]; match __v_29.as_canonical_u64() { 1u64 => { - let __ret: [G; OUT_665] = []; - if let Some(result) = record.function_queries[665].get_mut(&inp[..]) { debug_assert_eq!(result.output, &__ret[..]); if !unconstrained { *result.multiplicity += G::ONE; } } else { record.function_queries[665].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained)); }; + let __ret: [G; OUT_661] = []; + if let Some(result) = record.function_queries[661].get_mut(&inp[..]) { debug_assert_eq!(result.output, &__ret[..]); if !unconstrained { *result.multiplicity += G::ONE; } } else { record.function_queries[661].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained)); }; return Ok(__ret); }, 0u64 => { @@ -56312,7 +56040,7 @@ fn aiur_fn_665( let __v_36: G = G::from_u64(1); let __v_37: G = G::from_u64(1); let __v_38: G = { let __values: [G; 3] = [__v_36, __v_37, __v_37]; let __mq = record.memory_queries.get_mut(&3).ok_or(ExecError::InvalidMemorySize(3))?; if let Some(result) = __mq.get_mut(&__values[..]) { if !unconstrained { *result.multiplicity += G::ONE; } result.output[0] } else { let __ptr = G::from_usize(__mq.len()); __mq.insert(&__values[..], &[__ptr], G::from_bool(!unconstrained)); __ptr } }; - let __r_arr: [G; OUT_696] = { let __args: [G; IN_696] = [__v_12, __v_34, __v_35, __v_38]; let __cu = unconstrained; if let Some(result) = record.function_queries[696].get_mut(&__args[..]) { if !__cu && *result.multiplicity == G::ZERO { aiur_fn_696(__args, record, io_buffer, false)? } else { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_696] = unsafe { *(result.output.as_ptr() as *const [G; OUT_696]) }; __ret } } else { aiur_fn_696(__args, record, io_buffer, __cu)? } }; + let __r_arr: [G; OUT_692] = { let __args: [G; IN_692] = [__v_12, __v_34, __v_35, __v_38]; let __cu = unconstrained; if let Some(result) = record.function_queries[692].get_mut(&__args[..]) { if !__cu && *result.multiplicity == G::ZERO { aiur_fn_692(__args, record, io_buffer, false)? } else { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_692] = unsafe { *(result.output.as_ptr() as *const [G; OUT_692]) }; __ret } } else { aiur_fn_692(__args, record, io_buffer, __cu)? } }; let __v_39: G = __r_arr[0]; let __v_40: G = __r_arr[1]; let __v_41: G = __r_arr[2]; @@ -56322,7 +56050,7 @@ fn aiur_fn_665( let __v_42: G = G::from_u64(1); let __v_43: G = G::from_u64(1); let __v_44: G = { let __values: [G; 3] = [__v_42, __v_43, __v_43]; let __mq = record.memory_queries.get_mut(&3).ok_or(ExecError::InvalidMemorySize(3))?; if let Some(result) = __mq.get_mut(&__values[..]) { if !unconstrained { *result.multiplicity += G::ONE; } result.output[0] } else { let __ptr = G::from_usize(__mq.len()); __mq.insert(&__values[..], &[__ptr], G::from_bool(!unconstrained)); __ptr } }; - let __r_arr: [G; OUT_439] = { let __args: [G; IN_439] = [__v_39, __v_30, __v_44]; let __cu = unconstrained; if let Some(result) = record.function_queries[439].get_mut(&__args[..]) { if !__cu && *result.multiplicity == G::ZERO { aiur_fn_439(__args, record, io_buffer, false)? } else { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_439] = unsafe { *(result.output.as_ptr() as *const [G; OUT_439]) }; __ret } } else { aiur_fn_439(__args, record, io_buffer, __cu)? } }; + let __r_arr: [G; OUT_435] = { let __args: [G; IN_435] = [__v_39, __v_30, __v_44]; let __cu = unconstrained; if let Some(result) = record.function_queries[435].get_mut(&__args[..]) { if !__cu && *result.multiplicity == G::ZERO { aiur_fn_435(__args, record, io_buffer, false)? } else { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_435] = unsafe { *(result.output.as_ptr() as *const [G; OUT_435]) }; __ret } } else { aiur_fn_435(__args, record, io_buffer, __cu)? } }; let __v_45: G = __r_arr[0]; let __v_46: G = G::from_u64(1); if (__v_45 != __v_46) { @@ -56330,9 +56058,9 @@ fn aiur_fn_665( } let __v_47: G = G::from_u64(1); let __v_48: G = (__v_8 + __v_47); - let __r_arr: [G; OUT_665] = { let __args: [G; IN_665] = [__v_13, __v_31, __v_2, __v_3, __v_4, __v_5, __v_6, __v_7, __v_48]; let __cu = unconstrained; if let Some(result) = record.function_queries[665].get_mut(&__args[..]) { if !__cu && *result.multiplicity == G::ZERO { aiur_fn_665(__args, record, io_buffer, false)? } else { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_665] = unsafe { *(result.output.as_ptr() as *const [G; OUT_665]) }; __ret } } else { aiur_fn_665(__args, record, io_buffer, __cu)? } }; - let __ret: [G; OUT_665] = []; - if let Some(result) = record.function_queries[665].get_mut(&inp[..]) { debug_assert_eq!(result.output, &__ret[..]); if !unconstrained { *result.multiplicity += G::ONE; } } else { record.function_queries[665].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained)); }; + let __r_arr: [G; OUT_661] = { let __args: [G; IN_661] = [__v_13, __v_31, __v_2, __v_3, __v_4, __v_5, __v_6, __v_7, __v_48]; let __cu = unconstrained; if let Some(result) = record.function_queries[661].get_mut(&__args[..]) { if !__cu && *result.multiplicity == G::ZERO { aiur_fn_661(__args, record, io_buffer, false)? } else { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_661] = unsafe { *(result.output.as_ptr() as *const [G; OUT_661]) }; __ret } } else { aiur_fn_661(__args, record, io_buffer, __cu)? } }; + let __ret: [G; OUT_661] = []; + if let Some(result) = record.function_queries[661].get_mut(&inp[..]) { debug_assert_eq!(result.output, &__ret[..]); if !unconstrained { *result.multiplicity += G::ONE; } } else { record.function_queries[661].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained)); }; return Ok(__ret); }, _ => { @@ -56349,15 +56077,15 @@ fn aiur_fn_665( }) } -const INPUT_SIZE_666: usize = 12; -const IN_666: usize = 12; -const OUT_666: usize = 1; -fn aiur_fn_666( - inp: [G; IN_666], +const INPUT_SIZE_662: usize = 12; +const IN_662: usize = 12; +const OUT_662: usize = 1; +fn aiur_fn_662( + inp: [G; IN_662], record: &mut QueryRecord, io_buffer: &mut IOBuffer, unconstrained: bool, -) -> Result<[G; OUT_666], ExecError> { +) -> Result<[G; OUT_662], ExecError> { stacker::maybe_grow(64 * 1024, 4 * 1024 * 1024, || { let __v_0: G = inp[0]; let __v_1: G = inp[1]; @@ -56377,13 +56105,13 @@ fn aiur_fn_666( let __v_14: G = __loaded[2]; match __v_12.as_canonical_u64() { 1u64 => { - let __ret: [G; OUT_666] = [__v_0]; - if let Some(result) = record.function_queries[666].get_mut(&inp[..]) { debug_assert_eq!(result.output, &__ret[..]); if !unconstrained { *result.multiplicity += G::ONE; } } else { record.function_queries[666].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained)); }; + let __ret: [G; OUT_662] = [__v_0]; + if let Some(result) = record.function_queries[662].get_mut(&inp[..]) { debug_assert_eq!(result.output, &__ret[..]); if !unconstrained { *result.multiplicity += G::ONE; } } else { record.function_queries[662].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained)); }; return Ok(__ret); }, 0u64 => { let __v_15: G = G::from_u64(0); - let __r_arr: [G; OUT_756] = { let __args: [G; IN_756] = [__v_2, __v_11, __v_15]; let __cu = unconstrained; if let Some(result) = record.function_queries[756].get_mut(&__args[..]) { if !__cu && *result.multiplicity == G::ZERO { aiur_fn_756(__args, record, io_buffer, false)? } else { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_756] = unsafe { *(result.output.as_ptr() as *const [G; OUT_756]) }; __ret } } else { aiur_fn_756(__args, record, io_buffer, __cu)? } }; + let __r_arr: [G; OUT_752] = { let __args: [G; IN_752] = [__v_2, __v_11, __v_15]; let __cu = unconstrained; if let Some(result) = record.function_queries[752].get_mut(&__args[..]) { if !__cu && *result.multiplicity == G::ZERO { aiur_fn_752(__args, record, io_buffer, false)? } else { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_752] = unsafe { *(result.output.as_ptr() as *const [G; OUT_752]) }; __ret } } else { aiur_fn_752(__args, record, io_buffer, __cu)? } }; let __v_16: G = __r_arr[0]; let __v_17: G = G::from_u64(0); let __v_18: G = G::from_u64(0); @@ -56418,27 +56146,27 @@ fn aiur_fn_666( let __v_47: G = G::from_u64(0); let __v_48: G = G::from_u64(0); let __v_49: G = { let __values: [G; 32] = [__v_17, __v_18, __v_19, __v_20, __v_21, __v_22, __v_23, __v_24, __v_25, __v_26, __v_27, __v_28, __v_29, __v_30, __v_31, __v_32, __v_33, __v_34, __v_35, __v_36, __v_37, __v_38, __v_39, __v_40, __v_41, __v_42, __v_43, __v_44, __v_45, __v_46, __v_47, __v_48]; let __mq = record.memory_queries.get_mut(&32).ok_or(ExecError::InvalidMemorySize(32))?; if let Some(result) = __mq.get_mut(&__values[..]) { if !unconstrained { *result.multiplicity += G::ONE; } result.output[0] } else { let __ptr = G::from_usize(__mq.len()); __mq.insert(&__values[..], &[__ptr], G::from_bool(!unconstrained)); __ptr } }; - let __r_arr: [G; OUT_756] = { let __args: [G; IN_756] = [__v_4, __v_16, __v_49]; let __cu = unconstrained; if let Some(result) = record.function_queries[756].get_mut(&__args[..]) { if !__cu && *result.multiplicity == G::ZERO { aiur_fn_756(__args, record, io_buffer, false)? } else { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_756] = unsafe { *(result.output.as_ptr() as *const [G; OUT_756]) }; __ret } } else { aiur_fn_756(__args, record, io_buffer, __cu)? } }; + let __r_arr: [G; OUT_752] = { let __args: [G; IN_752] = [__v_4, __v_16, __v_49]; let __cu = unconstrained; if let Some(result) = record.function_queries[752].get_mut(&__args[..]) { if !__cu && *result.multiplicity == G::ZERO { aiur_fn_752(__args, record, io_buffer, false)? } else { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_752] = unsafe { *(result.output.as_ptr() as *const [G; OUT_752]) }; __ret } } else { aiur_fn_752(__args, record, io_buffer, __cu)? } }; let __v_50: G = __r_arr[0]; let __v_51: G = G::from_u64(0); - let __r_arr: [G; OUT_756] = { let __args: [G; IN_756] = [__v_5, __v_16, __v_51]; let __cu = unconstrained; if let Some(result) = record.function_queries[756].get_mut(&__args[..]) { if !__cu && *result.multiplicity == G::ZERO { aiur_fn_756(__args, record, io_buffer, false)? } else { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_756] = unsafe { *(result.output.as_ptr() as *const [G; OUT_756]) }; __ret } } else { aiur_fn_756(__args, record, io_buffer, __cu)? } }; + let __r_arr: [G; OUT_752] = { let __args: [G; IN_752] = [__v_5, __v_16, __v_51]; let __cu = unconstrained; if let Some(result) = record.function_queries[752].get_mut(&__args[..]) { if !__cu && *result.multiplicity == G::ZERO { aiur_fn_752(__args, record, io_buffer, false)? } else { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_752] = unsafe { *(result.output.as_ptr() as *const [G; OUT_752]) }; __ret } } else { aiur_fn_752(__args, record, io_buffer, __cu)? } }; let __v_52: G = __r_arr[0]; let __v_53: G = (__v_6 + __v_7); let __v_54: G = (__v_53 + __v_8); let __v_55: G = (__v_54 + __v_9); - let __r_arr: [G; OUT_766] = { let __args: [G; IN_766] = [__v_3, __v_13]; let __cu = unconstrained; if let Some(result) = record.function_queries[766].get_mut(&__args[..]) { if !__cu && *result.multiplicity == G::ZERO { aiur_fn_766(__args, record, io_buffer, false)? } else { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_766] = unsafe { *(result.output.as_ptr() as *const [G; OUT_766]) }; __ret } } else { aiur_fn_766(__args, record, io_buffer, __cu)? } }; + let __r_arr: [G; OUT_762] = { let __args: [G; IN_762] = [__v_3, __v_13]; let __cu = unconstrained; if let Some(result) = record.function_queries[762].get_mut(&__args[..]) { if !__cu && *result.multiplicity == G::ZERO { aiur_fn_762(__args, record, io_buffer, false)? } else { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_762] = unsafe { *(result.output.as_ptr() as *const [G; OUT_762]) }; __ret } } else { aiur_fn_762(__args, record, io_buffer, __cu)? } }; let __v_56: G = __r_arr[0]; let __v_57: G = (__v_9 - __v_13); let __v_58: G = G::from_u64(0); - let __r_arr: [G; OUT_359] = { let __args: [G; IN_359] = [__v_56, __v_57, __v_58]; let __cu = unconstrained; if let Some(result) = record.function_queries[359].get_mut(&__args[..]) { if !__cu && *result.multiplicity == G::ZERO { aiur_fn_359(__args, record, io_buffer, false)? } else { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_359] = unsafe { *(result.output.as_ptr() as *const [G; OUT_359]) }; __ret } } else { aiur_fn_359(__args, record, io_buffer, __cu)? } }; + let __r_arr: [G; OUT_355] = { let __args: [G; IN_355] = [__v_56, __v_57, __v_58]; let __cu = unconstrained; if let Some(result) = record.function_queries[355].get_mut(&__args[..]) { if !__cu && *result.multiplicity == G::ZERO { aiur_fn_355(__args, record, io_buffer, false)? } else { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_355] = unsafe { *(result.output.as_ptr() as *const [G; OUT_355]) }; __ret } } else { aiur_fn_355(__args, record, io_buffer, __cu)? } }; let __v_59: G = __r_arr[0]; let __v_60: G = (__v_7 + __v_8); - let __r_arr: [G; OUT_359] = { let __args: [G; IN_359] = [__v_59, __v_60, __v_9]; let __cu = unconstrained; if let Some(result) = record.function_queries[359].get_mut(&__args[..]) { if !__cu && *result.multiplicity == G::ZERO { aiur_fn_359(__args, record, io_buffer, false)? } else { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_359] = unsafe { *(result.output.as_ptr() as *const [G; OUT_359]) }; __ret } } else { aiur_fn_359(__args, record, io_buffer, __cu)? } }; + let __r_arr: [G; OUT_355] = { let __args: [G; IN_355] = [__v_59, __v_60, __v_9]; let __cu = unconstrained; if let Some(result) = record.function_queries[355].get_mut(&__args[..]) { if !__cu && *result.multiplicity == G::ZERO { aiur_fn_355(__args, record, io_buffer, false)? } else { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_355] = unsafe { *(result.output.as_ptr() as *const [G; OUT_355]) }; __ret } } else { aiur_fn_355(__args, record, io_buffer, __cu)? } }; let __v_61: G = __r_arr[0]; - let __r_arr: [G; OUT_680] = { let __args: [G; IN_680] = [__v_61]; let __cu = unconstrained; if let Some(result) = record.function_queries[680].get_mut(&__args[..]) { if !__cu && *result.multiplicity == G::ZERO { aiur_fn_680(__args, record, io_buffer, false)? } else { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_680] = unsafe { *(result.output.as_ptr() as *const [G; OUT_680]) }; __ret } } else { aiur_fn_680(__args, record, io_buffer, __cu)? } }; + let __r_arr: [G; OUT_676] = { let __args: [G; IN_676] = [__v_61]; let __cu = unconstrained; if let Some(result) = record.function_queries[676].get_mut(&__args[..]) { if !__cu && *result.multiplicity == G::ZERO { aiur_fn_676(__args, record, io_buffer, false)? } else { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_676] = unsafe { *(result.output.as_ptr() as *const [G; OUT_676]) }; __ret } } else { aiur_fn_676(__args, record, io_buffer, __cu)? } }; let __v_62: G = __r_arr[0]; let __v_63: G = __r_arr[1]; - let __r_arr: [G; OUT_764] = { let __args: [G; IN_764] = [__v_62]; let __cu = unconstrained; if let Some(result) = record.function_queries[764].get_mut(&__args[..]) { if !__cu && *result.multiplicity == G::ZERO { aiur_fn_764(__args, record, io_buffer, false)? } else { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_764] = unsafe { *(result.output.as_ptr() as *const [G; OUT_764]) }; __ret } } else { aiur_fn_764(__args, record, io_buffer, __cu)? } }; + let __r_arr: [G; OUT_760] = { let __args: [G; IN_760] = [__v_62]; let __cu = unconstrained; if let Some(result) = record.function_queries[760].get_mut(&__args[..]) { if !__cu && *result.multiplicity == G::ZERO { aiur_fn_760(__args, record, io_buffer, false)? } else { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_760] = unsafe { *(result.output.as_ptr() as *const [G; OUT_760]) }; __ret } } else { aiur_fn_760(__args, record, io_buffer, __cu)? } }; let __v_64: G = __r_arr[0]; let __v_65: G = (__v_55 + __v_64); let __v_66: G = G::from_u64(2); @@ -56447,32 +56175,32 @@ fn aiur_fn_666( let __v_69: G = G::from_u64(1); let __v_70: G = (__v_65 - __v_69); let __v_71: G = G::from_u64(0); - let __r_arr: [G; OUT_657] = { let __args: [G; IN_657] = [__v_68, __v_6, __v_70, __v_71]; let __cu = unconstrained; if let Some(result) = record.function_queries[657].get_mut(&__args[..]) { if !__cu && *result.multiplicity == G::ZERO { aiur_fn_657(__args, record, io_buffer, false)? } else { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_657] = unsafe { *(result.output.as_ptr() as *const [G; OUT_657]) }; __ret } } else { aiur_fn_657(__args, record, io_buffer, __cu)? } }; + let __r_arr: [G; OUT_653] = { let __args: [G; IN_653] = [__v_68, __v_6, __v_70, __v_71]; let __cu = unconstrained; if let Some(result) = record.function_queries[653].get_mut(&__args[..]) { if !__cu && *result.multiplicity == G::ZERO { aiur_fn_653(__args, record, io_buffer, false)? } else { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_653] = unsafe { *(result.output.as_ptr() as *const [G; OUT_653]) }; __ret } } else { aiur_fn_653(__args, record, io_buffer, __cu)? } }; let __v_72: G = __r_arr[0]; let __v_73: G = G::from_u64(1); let __v_74: G = (__v_65 - __v_73); let __v_75: G = (__v_74 - __v_6); let __v_76: G = G::from_u64(0); - let __r_arr: [G; OUT_657] = { let __args: [G; IN_657] = [__v_72, __v_7, __v_75, __v_76]; let __cu = unconstrained; if let Some(result) = record.function_queries[657].get_mut(&__args[..]) { if !__cu && *result.multiplicity == G::ZERO { aiur_fn_657(__args, record, io_buffer, false)? } else { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_657] = unsafe { *(result.output.as_ptr() as *const [G; OUT_657]) }; __ret } } else { aiur_fn_657(__args, record, io_buffer, __cu)? } }; + let __r_arr: [G; OUT_653] = { let __args: [G; IN_653] = [__v_72, __v_7, __v_75, __v_76]; let __cu = unconstrained; if let Some(result) = record.function_queries[653].get_mut(&__args[..]) { if !__cu && *result.multiplicity == G::ZERO { aiur_fn_653(__args, record, io_buffer, false)? } else { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_653] = unsafe { *(result.output.as_ptr() as *const [G; OUT_653]) }; __ret } } else { aiur_fn_653(__args, record, io_buffer, __cu)? } }; let __v_77: G = __r_arr[0]; let __v_78: G = G::from_u64(1); let __v_79: G = (__v_65 - __v_78); let __v_80: G = (__v_79 - __v_6); let __v_81: G = (__v_80 - __v_7); let __v_82: G = G::from_u64(0); - let __r_arr: [G; OUT_657] = { let __args: [G; IN_657] = [__v_77, __v_8, __v_81, __v_82]; let __cu = unconstrained; if let Some(result) = record.function_queries[657].get_mut(&__args[..]) { if !__cu && *result.multiplicity == G::ZERO { aiur_fn_657(__args, record, io_buffer, false)? } else { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_657] = unsafe { *(result.output.as_ptr() as *const [G; OUT_657]) }; __ret } } else { aiur_fn_657(__args, record, io_buffer, __cu)? } }; + let __r_arr: [G; OUT_653] = { let __args: [G; IN_653] = [__v_77, __v_8, __v_81, __v_82]; let __cu = unconstrained; if let Some(result) = record.function_queries[653].get_mut(&__args[..]) { if !__cu && *result.multiplicity == G::ZERO { aiur_fn_653(__args, record, io_buffer, false)? } else { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_653] = unsafe { *(result.output.as_ptr() as *const [G; OUT_653]) }; __ret } } else { aiur_fn_653(__args, record, io_buffer, __cu)? } }; let __v_83: G = __r_arr[0]; let __v_84: G = G::from_u64(1); let __v_85: G = G::from_u64(1); let __v_86: G = { let __values: [G; 3] = [__v_84, __v_85, __v_85]; let __mq = record.memory_queries.get_mut(&3).ok_or(ExecError::InvalidMemorySize(3))?; if let Some(result) = __mq.get_mut(&__values[..]) { if !unconstrained { *result.multiplicity += G::ONE; } result.output[0] } else { let __ptr = G::from_usize(__mq.len()); __mq.insert(&__values[..], &[__ptr], G::from_bool(!unconstrained)); __ptr } }; - let __r_arr: [G; OUT_418] = { let __args: [G; IN_418] = [__v_63, __v_86]; let __cu = unconstrained; if let Some(result) = record.function_queries[418].get_mut(&__args[..]) { if !__cu && *result.multiplicity == G::ZERO { aiur_fn_418(__args, record, io_buffer, false)? } else { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_418] = unsafe { *(result.output.as_ptr() as *const [G; OUT_418]) }; __ret } } else { aiur_fn_418(__args, record, io_buffer, __cu)? } }; + let __r_arr: [G; OUT_414] = { let __args: [G; IN_414] = [__v_63, __v_86]; let __cu = unconstrained; if let Some(result) = record.function_queries[414].get_mut(&__args[..]) { if !__cu && *result.multiplicity == G::ZERO { aiur_fn_414(__args, record, io_buffer, false)? } else { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_414] = unsafe { *(result.output.as_ptr() as *const [G; OUT_414]) }; __ret } } else { aiur_fn_414(__args, record, io_buffer, __cu)? } }; let __v_87: G = __r_arr[0]; let __r_arr: [G; OUT_111] = { let __args: [G; IN_111] = [__v_87]; let __cu = unconstrained; if let Some(result) = record.function_queries[111].get_mut(&__args[..]) { if !__cu && *result.multiplicity == G::ZERO { aiur_fn_111(__args, record, io_buffer, false)? } else { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_111] = unsafe { *(result.output.as_ptr() as *const [G; OUT_111]) }; __ret } } else { aiur_fn_111(__args, record, io_buffer, __cu)? } }; let __v_88: G = __r_arr[0]; let __v_89: G = __r_arr[1]; - let __r_arr: [G; OUT_775] = { let __args: [G; IN_775] = [__v_89, __v_52]; let __cu = unconstrained; if let Some(result) = record.function_queries[775].get_mut(&__args[..]) { if !__cu && *result.multiplicity == G::ZERO { aiur_fn_775(__args, record, io_buffer, false)? } else { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_775] = unsafe { *(result.output.as_ptr() as *const [G; OUT_775]) }; __ret } } else { aiur_fn_775(__args, record, io_buffer, __cu)? } }; + let __r_arr: [G; OUT_771] = { let __args: [G; IN_771] = [__v_89, __v_52]; let __cu = unconstrained; if let Some(result) = record.function_queries[771].get_mut(&__args[..]) { if !__cu && *result.multiplicity == G::ZERO { aiur_fn_771(__args, record, io_buffer, false)? } else { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_771] = unsafe { *(result.output.as_ptr() as *const [G; OUT_771]) }; __ret } } else { aiur_fn_771(__args, record, io_buffer, __cu)? } }; let __v_90: G = __r_arr[0]; - let __r_arr: [G; OUT_255] = { let __args: [G; IN_255] = [__v_83, __v_90]; let __cu = unconstrained; if let Some(result) = record.function_queries[255].get_mut(&__args[..]) { if !__cu && *result.multiplicity == G::ZERO { aiur_fn_255(__args, record, io_buffer, false)? } else { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_255] = unsafe { *(result.output.as_ptr() as *const [G; OUT_255]) }; __ret } } else { aiur_fn_255(__args, record, io_buffer, __cu)? } }; + let __r_arr: [G; OUT_251] = { let __args: [G; IN_251] = [__v_83, __v_90]; let __cu = unconstrained; if let Some(result) = record.function_queries[251].get_mut(&__args[..]) { if !__cu && *result.multiplicity == G::ZERO { aiur_fn_251(__args, record, io_buffer, false)? } else { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_251] = unsafe { *(result.output.as_ptr() as *const [G; OUT_251]) }; __ret } } else { aiur_fn_251(__args, record, io_buffer, __cu)? } }; let __v_91: G = __r_arr[0]; let __v_92: G = G::from_u64(1); let __v_93: G = (__v_9 - __v_92); @@ -56482,22 +56210,22 @@ fn aiur_fn_666( let __v_97: G = G::from_u64(0); let __v_98: G = { let __values: [G; 4] = [__v_96, __v_95, __v_97, __v_97]; let __mq = record.memory_queries.get_mut(&4).ok_or(ExecError::InvalidMemorySize(4))?; if let Some(result) = __mq.get_mut(&__values[..]) { if !unconstrained { *result.multiplicity += G::ONE; } result.output[0] } else { let __ptr = G::from_usize(__mq.len()); __mq.insert(&__values[..], &[__ptr], G::from_bool(!unconstrained)); __ptr } }; let __v_99: G = G::from_u64(0); - let __r_arr: [G; OUT_649] = { let __args: [G; IN_649] = [__v_98, __v_64, __v_99]; let __cu = unconstrained; if let Some(result) = record.function_queries[649].get_mut(&__args[..]) { if !__cu && *result.multiplicity == G::ZERO { aiur_fn_649(__args, record, io_buffer, false)? } else { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_649] = unsafe { *(result.output.as_ptr() as *const [G; OUT_649]) }; __ret } } else { aiur_fn_649(__args, record, io_buffer, __cu)? } }; + let __r_arr: [G; OUT_645] = { let __args: [G; IN_645] = [__v_98, __v_64, __v_99]; let __cu = unconstrained; if let Some(result) = record.function_queries[645].get_mut(&__args[..]) { if !__cu && *result.multiplicity == G::ZERO { aiur_fn_645(__args, record, io_buffer, false)? } else { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_645] = unsafe { *(result.output.as_ptr() as *const [G; OUT_645]) }; __ret } } else { aiur_fn_645(__args, record, io_buffer, __cu)? } }; let __v_100: G = __r_arr[0]; let __v_101: G = G::from_u64(3); let __v_102: G = G::from_u64(0); let __v_103: G = { let __values: [G; 4] = [__v_101, __v_91, __v_100, __v_102]; let __mq = record.memory_queries.get_mut(&4).ok_or(ExecError::InvalidMemorySize(4))?; if let Some(result) = __mq.get_mut(&__values[..]) { if !unconstrained { *result.multiplicity += G::ONE; } result.output[0] } else { let __ptr = G::from_usize(__mq.len()); __mq.insert(&__values[..], &[__ptr], G::from_bool(!unconstrained)); __ptr } }; - let __r_arr: [G; OUT_658] = { let __args: [G; IN_658] = [__v_103, __v_62]; let __cu = unconstrained; if let Some(result) = record.function_queries[658].get_mut(&__args[..]) { if !__cu && *result.multiplicity == G::ZERO { aiur_fn_658(__args, record, io_buffer, false)? } else { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_658] = unsafe { *(result.output.as_ptr() as *const [G; OUT_658]) }; __ret } } else { aiur_fn_658(__args, record, io_buffer, __cu)? } }; + let __r_arr: [G; OUT_654] = { let __args: [G; IN_654] = [__v_103, __v_62]; let __cu = unconstrained; if let Some(result) = record.function_queries[654].get_mut(&__args[..]) { if !__cu && *result.multiplicity == G::ZERO { aiur_fn_654(__args, record, io_buffer, false)? } else { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_654] = unsafe { *(result.output.as_ptr() as *const [G; OUT_654]) }; __ret } } else { aiur_fn_654(__args, record, io_buffer, __cu)? } }; let __v_104: G = __r_arr[0]; let __v_105: G = G::from_u64(3); let __v_106: G = G::from_u64(0); let __v_107: G = { let __values: [G; 4] = [__v_105, __v_0, __v_104, __v_106]; let __mq = record.memory_queries.get_mut(&4).ok_or(ExecError::InvalidMemorySize(4))?; if let Some(result) = __mq.get_mut(&__values[..]) { if !unconstrained { *result.multiplicity += G::ONE; } result.output[0] } else { let __ptr = G::from_usize(__mq.len()); __mq.insert(&__values[..], &[__ptr], G::from_bool(!unconstrained)); __ptr } }; let __v_108: G = G::from_u64(1); let __v_109: G = (__v_11 + __v_108); - let __r_arr: [G; OUT_666] = { let __args: [G; IN_666] = [__v_107, __v_14, __v_2, __v_3, __v_4, __v_5, __v_6, __v_7, __v_8, __v_9, __v_10, __v_109]; let __cu = unconstrained; if let Some(result) = record.function_queries[666].get_mut(&__args[..]) { if !__cu && *result.multiplicity == G::ZERO { aiur_fn_666(__args, record, io_buffer, false)? } else { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_666] = unsafe { *(result.output.as_ptr() as *const [G; OUT_666]) }; __ret } } else { aiur_fn_666(__args, record, io_buffer, __cu)? } }; + let __r_arr: [G; OUT_662] = { let __args: [G; IN_662] = [__v_107, __v_14, __v_2, __v_3, __v_4, __v_5, __v_6, __v_7, __v_8, __v_9, __v_10, __v_109]; let __cu = unconstrained; if let Some(result) = record.function_queries[662].get_mut(&__args[..]) { if !__cu && *result.multiplicity == G::ZERO { aiur_fn_662(__args, record, io_buffer, false)? } else { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_662] = unsafe { *(result.output.as_ptr() as *const [G; OUT_662]) }; __ret } } else { aiur_fn_662(__args, record, io_buffer, __cu)? } }; let __v_110: G = __r_arr[0]; - let __ret: [G; OUT_666] = [__v_110]; - if let Some(result) = record.function_queries[666].get_mut(&inp[..]) { debug_assert_eq!(result.output, &__ret[..]); if !unconstrained { *result.multiplicity += G::ONE; } } else { record.function_queries[666].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained)); }; + let __ret: [G; OUT_662] = [__v_110]; + if let Some(result) = record.function_queries[662].get_mut(&inp[..]) { debug_assert_eq!(result.output, &__ret[..]); if !unconstrained { *result.multiplicity += G::ONE; } } else { record.function_queries[662].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained)); }; return Ok(__ret); }, _ => { @@ -56507,15 +56235,15 @@ fn aiur_fn_666( }) } -const INPUT_SIZE_667: usize = 13; -const IN_667: usize = 13; -const OUT_667: usize = 1; -fn aiur_fn_667( - inp: [G; IN_667], +const INPUT_SIZE_663: usize = 13; +const IN_663: usize = 13; +const OUT_663: usize = 1; +fn aiur_fn_663( + inp: [G; IN_663], record: &mut QueryRecord, io_buffer: &mut IOBuffer, unconstrained: bool, -) -> Result<[G; OUT_667], ExecError> { +) -> Result<[G; OUT_663], ExecError> { stacker::maybe_grow(64 * 1024, 4 * 1024 * 1024, || { let __v_0: G = inp[0]; let __v_1: G = inp[1]; @@ -56530,19 +56258,19 @@ fn aiur_fn_667( let __v_10: G = inp[10]; let __v_11: G = inp[11]; let __v_12: G = inp[12]; - let __r_arr: [G; OUT_336] = { let __args: [G; IN_336] = [__v_0, __v_6]; let __cu = unconstrained; if let Some(result) = record.function_queries[336].get_mut(&__args[..]) { if !__cu && *result.multiplicity == G::ZERO { aiur_fn_336(__args, record, io_buffer, false)? } else { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_336] = unsafe { *(result.output.as_ptr() as *const [G; OUT_336]) }; __ret } } else { aiur_fn_336(__args, record, io_buffer, __cu)? } }; + let __r_arr: [G; OUT_332] = { let __args: [G; IN_332] = [__v_0, __v_6]; let __cu = unconstrained; if let Some(result) = record.function_queries[332].get_mut(&__args[..]) { if !__cu && *result.multiplicity == G::ZERO { aiur_fn_332(__args, record, io_buffer, false)? } else { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_332] = unsafe { *(result.output.as_ptr() as *const [G; OUT_332]) }; __ret } } else { aiur_fn_332(__args, record, io_buffer, __cu)? } }; let __v_13: G = __r_arr[0]; - let __r_arr: [G; OUT_586] = { let __args: [G; IN_586] = [__v_13, __v_5]; let __cu = unconstrained; if let Some(result) = record.function_queries[586].get_mut(&__args[..]) { if !__cu && *result.multiplicity == G::ZERO { aiur_fn_586(__args, record, io_buffer, false)? } else { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_586] = unsafe { *(result.output.as_ptr() as *const [G; OUT_586]) }; __ret } } else { aiur_fn_586(__args, record, io_buffer, __cu)? } }; + let __r_arr: [G; OUT_582] = { let __args: [G; IN_582] = [__v_13, __v_5]; let __cu = unconstrained; if let Some(result) = record.function_queries[582].get_mut(&__args[..]) { if !__cu && *result.multiplicity == G::ZERO { aiur_fn_582(__args, record, io_buffer, false)? } else { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_582] = unsafe { *(result.output.as_ptr() as *const [G; OUT_582]) }; __ret } } else { aiur_fn_582(__args, record, io_buffer, __cu)? } }; let __v_14: G = __r_arr[0]; let __v_15: G = G::from_u64(0); - let __r_arr: [G; OUT_677] = { let __args: [G; IN_677] = [__v_14, __v_15]; let __cu = unconstrained; if let Some(result) = record.function_queries[677].get_mut(&__args[..]) { if !__cu && *result.multiplicity == G::ZERO { aiur_fn_677(__args, record, io_buffer, false)? } else { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_677] = unsafe { *(result.output.as_ptr() as *const [G; OUT_677]) }; __ret } } else { aiur_fn_677(__args, record, io_buffer, __cu)? } }; + let __r_arr: [G; OUT_673] = { let __args: [G; IN_673] = [__v_14, __v_15]; let __cu = unconstrained; if let Some(result) = record.function_queries[673].get_mut(&__args[..]) { if !__cu && *result.multiplicity == G::ZERO { aiur_fn_673(__args, record, io_buffer, false)? } else { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_673] = unsafe { *(result.output.as_ptr() as *const [G; OUT_673]) }; __ret } } else { aiur_fn_673(__args, record, io_buffer, __cu)? } }; let __v_16: G = __r_arr[0]; let __v_17: G = (__v_2 + __v_3); let __v_18: G = (__v_17 + __v_4); let __v_19: G = (__v_18 + __v_16); let __v_20: G = G::from_u64(0); let __v_21: G = G::from_u64(0); - let __r_arr: [G; OUT_678] = { let __args: [G; IN_678] = [__v_13, __v_5, __v_5, __v_20, __v_11, __v_12, __v_21]; let __cu = unconstrained; if let Some(result) = record.function_queries[678].get_mut(&__args[..]) { if !__cu && *result.multiplicity == G::ZERO { aiur_fn_678(__args, record, io_buffer, false)? } else { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_678] = unsafe { *(result.output.as_ptr() as *const [G; OUT_678]) }; __ret } } else { aiur_fn_678(__args, record, io_buffer, __cu)? } }; + let __r_arr: [G; OUT_674] = { let __args: [G; IN_674] = [__v_13, __v_5, __v_5, __v_20, __v_11, __v_12, __v_21]; let __cu = unconstrained; if let Some(result) = record.function_queries[674].get_mut(&__args[..]) { if !__cu && *result.multiplicity == G::ZERO { aiur_fn_674(__args, record, io_buffer, false)? } else { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_674] = unsafe { *(result.output.as_ptr() as *const [G; OUT_674]) }; __ret } } else { aiur_fn_674(__args, record, io_buffer, __cu)? } }; let __v_22: G = __r_arr[0]; let __v_23: G = G::from_u64(1); let __v_24: G = G::from_u64(1); @@ -56555,7 +56283,7 @@ fn aiur_fn_667( let __v_31: G = { let __values: [G; 3] = [__v_29, __v_30, __v_30]; let __mq = record.memory_queries.get_mut(&3).ok_or(ExecError::InvalidMemorySize(3))?; if let Some(result) = __mq.get_mut(&__values[..]) { if !unconstrained { *result.multiplicity += G::ONE; } result.output[0] } else { let __ptr = G::from_usize(__mq.len()); __mq.insert(&__values[..], &[__ptr], G::from_bool(!unconstrained)); __ptr } }; let __v_32: G = G::from_u64(0); let __v_33: G = G::from_u64(0); - let __r_arr: [G; OUT_690] = { let __args: [G; IN_690] = [__v_22, __v_8, __v_25, __v_28, __v_31, __v_32, __v_33]; let __cu = unconstrained; if let Some(result) = record.function_queries[690].get_mut(&__args[..]) { if !__cu && *result.multiplicity == G::ZERO { aiur_fn_690(__args, record, io_buffer, false)? } else { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_690] = unsafe { *(result.output.as_ptr() as *const [G; OUT_690]) }; __ret } } else { aiur_fn_690(__args, record, io_buffer, __cu)? } }; + let __r_arr: [G; OUT_686] = { let __args: [G; IN_686] = [__v_22, __v_8, __v_25, __v_28, __v_31, __v_32, __v_33]; let __cu = unconstrained; if let Some(result) = record.function_queries[686].get_mut(&__args[..]) { if !__cu && *result.multiplicity == G::ZERO { aiur_fn_686(__args, record, io_buffer, false)? } else { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_686] = unsafe { *(result.output.as_ptr() as *const [G; OUT_686]) }; __ret } } else { aiur_fn_686(__args, record, io_buffer, __cu)? } }; let __v_34: G = __r_arr[0]; let __v_35: G = __r_arr[1]; let __v_36: G = __r_arr[2]; @@ -56569,26 +56297,26 @@ fn aiur_fn_667( let __v_44: G = G::from_u64(0); let __v_45: G = { let __values: [G; 4] = [__v_43, __v_42, __v_44, __v_44]; let __mq = record.memory_queries.get_mut(&4).ok_or(ExecError::InvalidMemorySize(4))?; if let Some(result) = __mq.get_mut(&__values[..]) { if !unconstrained { *result.multiplicity += G::ONE; } result.output[0] } else { let __ptr = G::from_usize(__mq.len()); __mq.insert(&__values[..], &[__ptr], G::from_bool(!unconstrained)); __ptr } }; let __v_46: G = G::from_u64(0); - let __r_arr: [G; OUT_684] = { let __args: [G; IN_684] = [__v_45, __v_16, __v_16, __v_46]; let __cu = unconstrained; if let Some(result) = record.function_queries[684].get_mut(&__args[..]) { if !__cu && *result.multiplicity == G::ZERO { aiur_fn_684(__args, record, io_buffer, false)? } else { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_684] = unsafe { *(result.output.as_ptr() as *const [G; OUT_684]) }; __ret } } else { aiur_fn_684(__args, record, io_buffer, __cu)? } }; + let __r_arr: [G; OUT_680] = { let __args: [G; IN_680] = [__v_45, __v_16, __v_16, __v_46]; let __cu = unconstrained; if let Some(result) = record.function_queries[680].get_mut(&__args[..]) { if !__cu && *result.multiplicity == G::ZERO { aiur_fn_680(__args, record, io_buffer, false)? } else { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_680] = unsafe { *(result.output.as_ptr() as *const [G; OUT_680]) }; __ret } } else { aiur_fn_680(__args, record, io_buffer, __cu)? } }; let __v_47: G = __r_arr[0]; let __v_48: G = G::from_u64(0); - let __r_arr: [G; OUT_666] = { let __args: [G; IN_666] = [__v_47, __v_35, __v_36, __v_34, __v_9, __v_10, __v_2, __v_3, __v_4, __v_16, __v_7, __v_48]; let __cu = unconstrained; if let Some(result) = record.function_queries[666].get_mut(&__args[..]) { if !__cu && *result.multiplicity == G::ZERO { aiur_fn_666(__args, record, io_buffer, false)? } else { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_666] = unsafe { *(result.output.as_ptr() as *const [G; OUT_666]) }; __ret } } else { aiur_fn_666(__args, record, io_buffer, __cu)? } }; + let __r_arr: [G; OUT_662] = { let __args: [G; IN_662] = [__v_47, __v_35, __v_36, __v_34, __v_9, __v_10, __v_2, __v_3, __v_4, __v_16, __v_7, __v_48]; let __cu = unconstrained; if let Some(result) = record.function_queries[662].get_mut(&__args[..]) { if !__cu && *result.multiplicity == G::ZERO { aiur_fn_662(__args, record, io_buffer, false)? } else { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_662] = unsafe { *(result.output.as_ptr() as *const [G; OUT_662]) }; __ret } } else { aiur_fn_662(__args, record, io_buffer, __cu)? } }; let __v_49: G = __r_arr[0]; - let __ret: [G; OUT_667] = [__v_49]; - if let Some(result) = record.function_queries[667].get_mut(&inp[..]) { debug_assert_eq!(result.output, &__ret[..]); if !unconstrained { *result.multiplicity += G::ONE; } } else { record.function_queries[667].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained)); }; + let __ret: [G; OUT_663] = [__v_49]; + if let Some(result) = record.function_queries[663].get_mut(&inp[..]) { debug_assert_eq!(result.output, &__ret[..]); if !unconstrained { *result.multiplicity += G::ONE; } } else { record.function_queries[663].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained)); }; return Ok(__ret); }) } -const INPUT_SIZE_668: usize = 3; -const IN_668: usize = 3; -const OUT_668: usize = 1; -fn aiur_fn_668( - inp: [G; IN_668], +const INPUT_SIZE_664: usize = 3; +const IN_664: usize = 3; +const OUT_664: usize = 1; +fn aiur_fn_664( + inp: [G; IN_664], record: &mut QueryRecord, io_buffer: &mut IOBuffer, unconstrained: bool, -) -> Result<[G; OUT_668], ExecError> { +) -> Result<[G; OUT_664], ExecError> { stacker::maybe_grow(64 * 1024, 4 * 1024 * 1024, || { let __v_0: G = inp[0]; let __v_1: G = inp[1]; @@ -56605,19 +56333,19 @@ fn aiur_fn_668( let __v_9: G = G::from_u64(1); let __v_10: G = G::from_u64(1); let __v_11: G = { let __values: [G; 3] = [__v_9, __v_10, __v_10]; let __mq = record.memory_queries.get_mut(&3).ok_or(ExecError::InvalidMemorySize(3))?; if let Some(result) = __mq.get_mut(&__values[..]) { if !unconstrained { *result.multiplicity += G::ONE; } result.output[0] } else { let __ptr = G::from_usize(__mq.len()); __mq.insert(&__values[..], &[__ptr], G::from_bool(!unconstrained)); __ptr } }; - let __ret: [G; OUT_668] = [__v_11]; - if let Some(result) = record.function_queries[668].get_mut(&inp[..]) { debug_assert_eq!(result.output, &__ret[..]); if !unconstrained { *result.multiplicity += G::ONE; } } else { record.function_queries[668].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained)); }; + let __ret: [G; OUT_664] = [__v_11]; + if let Some(result) = record.function_queries[664].get_mut(&inp[..]) { debug_assert_eq!(result.output, &__ret[..]); if !unconstrained { *result.multiplicity += G::ONE; } } else { record.function_queries[664].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained)); }; return Ok(__ret); }, 0u64 => { - let __r_arr: [G; OUT_669] = { let __args: [G; IN_669] = [__v_1, __v_4, __v_6, __v_5, __v_2]; let __cu = unconstrained; if let Some(result) = record.function_queries[669].get_mut(&__args[..]) { if !__cu && *result.multiplicity == G::ZERO { aiur_fn_669(__args, record, io_buffer, false)? } else { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_669] = unsafe { *(result.output.as_ptr() as *const [G; OUT_669]) }; __ret } } else { aiur_fn_669(__args, record, io_buffer, __cu)? } }; + let __r_arr: [G; OUT_665] = { let __args: [G; IN_665] = [__v_1, __v_4, __v_6, __v_5, __v_2]; let __cu = unconstrained; if let Some(result) = record.function_queries[665].get_mut(&__args[..]) { if !__cu && *result.multiplicity == G::ZERO { aiur_fn_665(__args, record, io_buffer, false)? } else { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_665] = unsafe { *(result.output.as_ptr() as *const [G; OUT_665]) }; __ret } } else { aiur_fn_665(__args, record, io_buffer, __cu)? } }; let __v_9: G = __r_arr[0]; let __v_10: G = G::from_u64(0); - let __r_arr: [G; OUT_668] = { let __args: [G; IN_668] = [__v_8, __v_1, __v_2]; let __cu = unconstrained; if let Some(result) = record.function_queries[668].get_mut(&__args[..]) { if !__cu && *result.multiplicity == G::ZERO { aiur_fn_668(__args, record, io_buffer, false)? } else { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_668] = unsafe { *(result.output.as_ptr() as *const [G; OUT_668]) }; __ret } } else { aiur_fn_668(__args, record, io_buffer, __cu)? } }; + let __r_arr: [G; OUT_664] = { let __args: [G; IN_664] = [__v_8, __v_1, __v_2]; let __cu = unconstrained; if let Some(result) = record.function_queries[664].get_mut(&__args[..]) { if !__cu && *result.multiplicity == G::ZERO { aiur_fn_664(__args, record, io_buffer, false)? } else { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_664] = unsafe { *(result.output.as_ptr() as *const [G; OUT_664]) }; __ret } } else { aiur_fn_664(__args, record, io_buffer, __cu)? } }; let __v_11: G = __r_arr[0]; let __v_12: G = { let __values: [G; 3] = [__v_10, __v_9, __v_11]; let __mq = record.memory_queries.get_mut(&3).ok_or(ExecError::InvalidMemorySize(3))?; if let Some(result) = __mq.get_mut(&__values[..]) { if !unconstrained { *result.multiplicity += G::ONE; } result.output[0] } else { let __ptr = G::from_usize(__mq.len()); __mq.insert(&__values[..], &[__ptr], G::from_bool(!unconstrained)); __ptr } }; - let __ret: [G; OUT_668] = [__v_12]; - if let Some(result) = record.function_queries[668].get_mut(&inp[..]) { debug_assert_eq!(result.output, &__ret[..]); if !unconstrained { *result.multiplicity += G::ONE; } } else { record.function_queries[668].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained)); }; + let __ret: [G; OUT_664] = [__v_12]; + if let Some(result) = record.function_queries[664].get_mut(&inp[..]) { debug_assert_eq!(result.output, &__ret[..]); if !unconstrained { *result.multiplicity += G::ONE; } } else { record.function_queries[664].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained)); }; return Ok(__ret); }, _ => { @@ -56627,22 +56355,22 @@ fn aiur_fn_668( }) } -const INPUT_SIZE_669: usize = 5; -const IN_669: usize = 5; -const OUT_669: usize = 1; -fn aiur_fn_669( - inp: [G; IN_669], +const INPUT_SIZE_665: usize = 5; +const IN_665: usize = 5; +const OUT_665: usize = 1; +fn aiur_fn_665( + inp: [G; IN_665], record: &mut QueryRecord, io_buffer: &mut IOBuffer, unconstrained: bool, -) -> Result<[G; OUT_669], ExecError> { +) -> Result<[G; OUT_665], ExecError> { stacker::maybe_grow(64 * 1024, 4 * 1024 * 1024, || { let __v_0: G = inp[0]; let __v_1: G = inp[1]; let __v_2: G = inp[2]; let __v_3: G = inp[3]; let __v_4: G = inp[4]; - let __r_arr: [G; OUT_282] = { let __args: [G; IN_282] = [__v_0]; let __cu = unconstrained; if let Some(result) = record.function_queries[282].get_mut(&__args[..]) { if !__cu && *result.multiplicity == G::ZERO { aiur_fn_282(__args, record, io_buffer, false)? } else { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_282] = unsafe { *(result.output.as_ptr() as *const [G; OUT_282]) }; __ret } } else { aiur_fn_282(__args, record, io_buffer, __cu)? } }; + let __r_arr: [G; OUT_278] = { let __args: [G; IN_278] = [__v_0]; let __cu = unconstrained; if let Some(result) = record.function_queries[278].get_mut(&__args[..]) { if !__cu && *result.multiplicity == G::ZERO { aiur_fn_278(__args, record, io_buffer, false)? } else { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_278] = unsafe { *(result.output.as_ptr() as *const [G; OUT_278]) }; __ret } } else { aiur_fn_278(__args, record, io_buffer, __cu)? } }; let __v_5: G = __r_arr[0]; let __v_6: G = __r_arr[1]; let __v_7: G = __r_arr[2]; @@ -56696,15 +56424,15 @@ fn aiur_fn_669( match __v_5.as_canonical_u64() { 8u64 => { let __v_53: G = G::from_u64(0); - let __r_arr: [G; OUT_670] = { let __args: [G; IN_670] = [__v_6, __v_6, __v_0, __v_1, __v_2, __v_3, __v_4, __v_53]; let __cu = unconstrained; if let Some(result) = record.function_queries[670].get_mut(&__args[..]) { if !__cu && *result.multiplicity == G::ZERO { aiur_fn_670(__args, record, io_buffer, false)? } else { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_670] = unsafe { *(result.output.as_ptr() as *const [G; OUT_670]) }; __ret } } else { aiur_fn_670(__args, record, io_buffer, __cu)? } }; + let __r_arr: [G; OUT_666] = { let __args: [G; IN_666] = [__v_6, __v_6, __v_0, __v_1, __v_2, __v_3, __v_4, __v_53]; let __cu = unconstrained; if let Some(result) = record.function_queries[666].get_mut(&__args[..]) { if !__cu && *result.multiplicity == G::ZERO { aiur_fn_666(__args, record, io_buffer, false)? } else { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_666] = unsafe { *(result.output.as_ptr() as *const [G; OUT_666]) }; __ret } } else { aiur_fn_666(__args, record, io_buffer, __cu)? } }; let __v_54: G = __r_arr[0]; - let __ret: [G; OUT_669] = [__v_54]; - if let Some(result) = record.function_queries[669].get_mut(&inp[..]) { debug_assert_eq!(result.output, &__ret[..]); if !unconstrained { *result.multiplicity += G::ONE; } } else { record.function_queries[669].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained)); }; + let __ret: [G; OUT_665] = [__v_54]; + if let Some(result) = record.function_queries[665].get_mut(&inp[..]) { debug_assert_eq!(result.output, &__ret[..]); if !unconstrained { *result.multiplicity += G::ONE; } } else { record.function_queries[665].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained)); }; return Ok(__ret); }, _ => { - let __ret: [G; OUT_669] = [__v_4]; - if let Some(result) = record.function_queries[669].get_mut(&inp[..]) { debug_assert_eq!(result.output, &__ret[..]); if !unconstrained { *result.multiplicity += G::ONE; } } else { record.function_queries[669].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained)); }; + let __ret: [G; OUT_665] = [__v_4]; + if let Some(result) = record.function_queries[665].get_mut(&inp[..]) { debug_assert_eq!(result.output, &__ret[..]); if !unconstrained { *result.multiplicity += G::ONE; } } else { record.function_queries[665].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained)); }; return Ok(__ret); }, } @@ -56713,15 +56441,15 @@ fn aiur_fn_669( }) } -const INPUT_SIZE_670: usize = 8; -const IN_670: usize = 8; -const OUT_670: usize = 1; -fn aiur_fn_670( - inp: [G; IN_670], +const INPUT_SIZE_666: usize = 8; +const IN_666: usize = 8; +const OUT_666: usize = 1; +fn aiur_fn_666( + inp: [G; IN_666], record: &mut QueryRecord, io_buffer: &mut IOBuffer, unconstrained: bool, -) -> Result<[G; OUT_670], ExecError> { +) -> Result<[G; OUT_666], ExecError> { stacker::maybe_grow(64 * 1024, 4 * 1024 * 1024, || { let __v_0: G = inp[0]; let __v_1: G = inp[1]; @@ -56781,16 +56509,16 @@ fn aiur_fn_670( let __v_54: G = __loaded[46]; match __v_8.as_canonical_u64() { 1u64 => { - let __ret: [G; OUT_670] = [__v_6]; - if let Some(result) = record.function_queries[670].get_mut(&inp[..]) { debug_assert_eq!(result.output, &__ret[..]); if !unconstrained { *result.multiplicity += G::ONE; } } else { record.function_queries[670].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained)); }; + let __ret: [G; OUT_666] = [__v_6]; + if let Some(result) = record.function_queries[666].get_mut(&inp[..]) { debug_assert_eq!(result.output, &__ret[..]); if !unconstrained { *result.multiplicity += G::ONE; } } else { record.function_queries[666].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained)); }; return Ok(__ret); }, 0u64 => { match __v_9.as_canonical_u64() { 2u64 => { - let __r_arr: [G; OUT_294] = { let __args: [G; IN_294] = [__v_0, __v_2, __v_7]; let __cu = unconstrained; if let Some(result) = record.function_queries[294].get_mut(&__args[..]) { if !__cu && *result.multiplicity == G::ZERO { aiur_fn_294(__args, record, io_buffer, false)? } else { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_294] = unsafe { *(result.output.as_ptr() as *const [G; OUT_294]) }; __ret } } else { aiur_fn_294(__args, record, io_buffer, __cu)? } }; + let __r_arr: [G; OUT_290] = { let __args: [G; IN_290] = [__v_0, __v_2, __v_7]; let __cu = unconstrained; if let Some(result) = record.function_queries[290].get_mut(&__args[..]) { if !__cu && *result.multiplicity == G::ZERO { aiur_fn_290(__args, record, io_buffer, false)? } else { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_290] = unsafe { *(result.output.as_ptr() as *const [G; OUT_290]) }; __ret } } else { aiur_fn_290(__args, record, io_buffer, __cu)? } }; let __v_55: G = __r_arr[0]; - let __r_arr: [G; OUT_287] = { let __args: [G; IN_287] = [__v_55]; let __cu = unconstrained; if let Some(result) = record.function_queries[287].get_mut(&__args[..]) { if !__cu && *result.multiplicity == G::ZERO { aiur_fn_287(__args, record, io_buffer, false)? } else { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_287] = unsafe { *(result.output.as_ptr() as *const [G; OUT_287]) }; __ret } } else { aiur_fn_287(__args, record, io_buffer, __cu)? } }; + let __r_arr: [G; OUT_283] = { let __args: [G; IN_283] = [__v_55]; let __cu = unconstrained; if let Some(result) = record.function_queries[283].get_mut(&__args[..]) { if !__cu && *result.multiplicity == G::ZERO { aiur_fn_283(__args, record, io_buffer, false)? } else { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_283] = unsafe { *(result.output.as_ptr() as *const [G; OUT_283]) }; __ret } } else { aiur_fn_283(__args, record, io_buffer, __cu)? } }; let __v_56: G = __r_arr[0]; let __loaded: [G; 12] = { let __mq = record.memory_queries.get_mut(&12).ok_or(ExecError::InvalidMemorySize(12))?; let __ptr_u64 = __v_56.as_canonical_u64(); let __ptr_usize = usize::try_from(__ptr_u64).ok().ok_or(ExecError::PointerTooLarge(__ptr_u64))?; let (__args, __mult) = __mq.get_index_mut(__ptr_usize).ok_or(ExecError::UnboundPointer { ptr: __ptr_u64, size: 12 })?; if !unconstrained { *__mult += G::ONE; } let __arr: [G; 12] = __args[..12].try_into().unwrap(); __arr }; let __v_57: G = __loaded[0]; @@ -56807,9 +56535,9 @@ fn aiur_fn_670( let __v_68: G = __loaded[11]; let __mc_out___mc_0: [G; 1] = '__mc_0: { match __v_57.as_canonical_u64() { 7u64 => { - let __r_arr: [G; OUT_623] = { let __args: [G; IN_623] = [__v_59, __v_60, __v_62, __v_63, __v_61]; let __cu = unconstrained; if let Some(result) = record.function_queries[623].get_mut(&__args[..]) { if !__cu && *result.multiplicity == G::ZERO { aiur_fn_623(__args, record, io_buffer, false)? } else { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_623] = unsafe { *(result.output.as_ptr() as *const [G; OUT_623]) }; __ret } } else { aiur_fn_623(__args, record, io_buffer, __cu)? } }; + let __r_arr: [G; OUT_619] = { let __args: [G; IN_619] = [__v_59, __v_60, __v_62, __v_63, __v_61]; let __cu = unconstrained; if let Some(result) = record.function_queries[619].get_mut(&__args[..]) { if !__cu && *result.multiplicity == G::ZERO { aiur_fn_619(__args, record, io_buffer, false)? } else { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_619] = unsafe { *(result.output.as_ptr() as *const [G; OUT_619]) }; __ret } } else { aiur_fn_619(__args, record, io_buffer, __cu)? } }; let __v_69: G = __r_arr[0]; - let __r_arr: [G; OUT_287] = { let __args: [G; IN_287] = [__v_69]; let __cu = unconstrained; if let Some(result) = record.function_queries[287].get_mut(&__args[..]) { if !__cu && *result.multiplicity == G::ZERO { aiur_fn_287(__args, record, io_buffer, false)? } else { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_287] = unsafe { *(result.output.as_ptr() as *const [G; OUT_287]) }; __ret } } else { aiur_fn_287(__args, record, io_buffer, __cu)? } }; + let __r_arr: [G; OUT_283] = { let __args: [G; IN_283] = [__v_69]; let __cu = unconstrained; if let Some(result) = record.function_queries[283].get_mut(&__args[..]) { if !__cu && *result.multiplicity == G::ZERO { aiur_fn_283(__args, record, io_buffer, false)? } else { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_283] = unsafe { *(result.output.as_ptr() as *const [G; OUT_283]) }; __ret } } else { aiur_fn_283(__args, record, io_buffer, __cu)? } }; let __v_70: G = __r_arr[0]; let __loaded: [G; 12] = { let __mq = record.memory_queries.get_mut(&12).ok_or(ExecError::InvalidMemorySize(12))?; let __ptr_u64 = __v_70.as_canonical_u64(); let __ptr_usize = usize::try_from(__ptr_u64).ok().ok_or(ExecError::PointerTooLarge(__ptr_u64))?; let (__args, __mult) = __mq.get_index_mut(__ptr_usize).ok_or(ExecError::UnboundPointer { ptr: __ptr_u64, size: 12 })?; if !unconstrained { *__mult += G::ONE; } let __arr: [G; 12] = __args[..12].try_into().unwrap(); __arr }; let __v_71: G = __loaded[0]; @@ -56845,9 +56573,9 @@ fn aiur_fn_670( break '__mc_0 [__v_85]; }, _ => { - let __r_arr: [G; OUT_625] = { let __args: [G; IN_625] = [__v_59, __v_60, __v_62, __v_63, __v_61, __v_83]; let __cu = unconstrained; if let Some(result) = record.function_queries[625].get_mut(&__args[..]) { if !__cu && *result.multiplicity == G::ZERO { aiur_fn_625(__args, record, io_buffer, false)? } else { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_625] = unsafe { *(result.output.as_ptr() as *const [G; OUT_625]) }; __ret } } else { aiur_fn_625(__args, record, io_buffer, __cu)? } }; + let __r_arr: [G; OUT_621] = { let __args: [G; IN_621] = [__v_59, __v_60, __v_62, __v_63, __v_61, __v_83]; let __cu = unconstrained; if let Some(result) = record.function_queries[621].get_mut(&__args[..]) { if !__cu && *result.multiplicity == G::ZERO { aiur_fn_621(__args, record, io_buffer, false)? } else { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_621] = unsafe { *(result.output.as_ptr() as *const [G; OUT_621]) }; __ret } } else { aiur_fn_621(__args, record, io_buffer, __cu)? } }; let __v_85: G = __r_arr[0]; - let __r_arr: [G; OUT_633] = { let __args: [G; IN_633] = [__v_85, __v_4]; let __cu = unconstrained; if let Some(result) = record.function_queries[633].get_mut(&__args[..]) { if !__cu && *result.multiplicity == G::ZERO { aiur_fn_633(__args, record, io_buffer, false)? } else { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_633] = unsafe { *(result.output.as_ptr() as *const [G; OUT_633]) }; __ret } } else { aiur_fn_633(__args, record, io_buffer, __cu)? } }; + let __r_arr: [G; OUT_629] = { let __args: [G; IN_629] = [__v_85, __v_4]; let __cu = unconstrained; if let Some(result) = record.function_queries[629].get_mut(&__args[..]) { if !__cu && *result.multiplicity == G::ZERO { aiur_fn_629(__args, record, io_buffer, false)? } else { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_629] = unsafe { *(result.output.as_ptr() as *const [G; OUT_629]) }; __ret } } else { aiur_fn_629(__args, record, io_buffer, __cu)? } }; let __v_86: G = __r_arr[0]; break '__mc_0 [__v_86]; }, @@ -56868,17 +56596,17 @@ fn aiur_fn_670( let __v_69: G = __mc_out___mc_0[0]; match __v_69.as_canonical_u64() { 1u64 => { - let __ret: [G; OUT_670] = [__v_55]; - if let Some(result) = record.function_queries[670].get_mut(&inp[..]) { debug_assert_eq!(result.output, &__ret[..]); if !unconstrained { *result.multiplicity += G::ONE; } } else { record.function_queries[670].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained)); }; + let __ret: [G; OUT_666] = [__v_55]; + if let Some(result) = record.function_queries[666].get_mut(&inp[..]) { debug_assert_eq!(result.output, &__ret[..]); if !unconstrained { *result.multiplicity += G::ONE; } } else { record.function_queries[666].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained)); }; return Ok(__ret); }, _ => { let __v_70: G = G::from_u64(1); let __v_71: G = (__v_7 + __v_70); - let __r_arr: [G; OUT_670] = { let __args: [G; IN_670] = [__v_0, __v_54, __v_2, __v_3, __v_4, __v_5, __v_6, __v_71]; let __cu = unconstrained; if let Some(result) = record.function_queries[670].get_mut(&__args[..]) { if !__cu && *result.multiplicity == G::ZERO { aiur_fn_670(__args, record, io_buffer, false)? } else { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_670] = unsafe { *(result.output.as_ptr() as *const [G; OUT_670]) }; __ret } } else { aiur_fn_670(__args, record, io_buffer, __cu)? } }; + let __r_arr: [G; OUT_666] = { let __args: [G; IN_666] = [__v_0, __v_54, __v_2, __v_3, __v_4, __v_5, __v_6, __v_71]; let __cu = unconstrained; if let Some(result) = record.function_queries[666].get_mut(&__args[..]) { if !__cu && *result.multiplicity == G::ZERO { aiur_fn_666(__args, record, io_buffer, false)? } else { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_666] = unsafe { *(result.output.as_ptr() as *const [G; OUT_666]) }; __ret } } else { aiur_fn_666(__args, record, io_buffer, __cu)? } }; let __v_72: G = __r_arr[0]; - let __ret: [G; OUT_670] = [__v_72]; - if let Some(result) = record.function_queries[670].get_mut(&inp[..]) { debug_assert_eq!(result.output, &__ret[..]); if !unconstrained { *result.multiplicity += G::ONE; } } else { record.function_queries[670].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained)); }; + let __ret: [G; OUT_666] = [__v_72]; + if let Some(result) = record.function_queries[666].get_mut(&inp[..]) { debug_assert_eq!(result.output, &__ret[..]); if !unconstrained { *result.multiplicity += G::ONE; } } else { record.function_queries[666].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained)); }; return Ok(__ret); }, } @@ -56886,10 +56614,10 @@ fn aiur_fn_670( _ => { let __v_55: G = G::from_u64(1); let __v_56: G = (__v_7 + __v_55); - let __r_arr: [G; OUT_670] = { let __args: [G; IN_670] = [__v_0, __v_54, __v_2, __v_3, __v_4, __v_5, __v_6, __v_56]; let __cu = unconstrained; if let Some(result) = record.function_queries[670].get_mut(&__args[..]) { if !__cu && *result.multiplicity == G::ZERO { aiur_fn_670(__args, record, io_buffer, false)? } else { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_670] = unsafe { *(result.output.as_ptr() as *const [G; OUT_670]) }; __ret } } else { aiur_fn_670(__args, record, io_buffer, __cu)? } }; + let __r_arr: [G; OUT_666] = { let __args: [G; IN_666] = [__v_0, __v_54, __v_2, __v_3, __v_4, __v_5, __v_6, __v_56]; let __cu = unconstrained; if let Some(result) = record.function_queries[666].get_mut(&__args[..]) { if !__cu && *result.multiplicity == G::ZERO { aiur_fn_666(__args, record, io_buffer, false)? } else { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_666] = unsafe { *(result.output.as_ptr() as *const [G; OUT_666]) }; __ret } } else { aiur_fn_666(__args, record, io_buffer, __cu)? } }; let __v_57: G = __r_arr[0]; - let __ret: [G; OUT_670] = [__v_57]; - if let Some(result) = record.function_queries[670].get_mut(&inp[..]) { debug_assert_eq!(result.output, &__ret[..]); if !unconstrained { *result.multiplicity += G::ONE; } } else { record.function_queries[670].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained)); }; + let __ret: [G; OUT_666] = [__v_57]; + if let Some(result) = record.function_queries[666].get_mut(&inp[..]) { debug_assert_eq!(result.output, &__ret[..]); if !unconstrained { *result.multiplicity += G::ONE; } } else { record.function_queries[666].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained)); }; return Ok(__ret); }, } @@ -56901,15 +56629,15 @@ fn aiur_fn_670( }) } -const INPUT_SIZE_671: usize = 1; -const IN_671: usize = 1; -const OUT_671: usize = 1; -fn aiur_fn_671( - inp: [G; IN_671], +const INPUT_SIZE_667: usize = 1; +const IN_667: usize = 1; +const OUT_667: usize = 1; +fn aiur_fn_667( + inp: [G; IN_667], record: &mut QueryRecord, io_buffer: &mut IOBuffer, unconstrained: bool, -) -> Result<[G; OUT_671], ExecError> { +) -> Result<[G; OUT_667], ExecError> { stacker::maybe_grow(64 * 1024, 4 * 1024 * 1024, || { let __v_0: G = inp[0]; let __loaded: [G; 6] = { let __mq = record.memory_queries.get_mut(&6).ok_or(ExecError::InvalidMemorySize(6))?; let __ptr_u64 = __v_0.as_canonical_u64(); let __ptr_usize = usize::try_from(__ptr_u64).ok().ok_or(ExecError::PointerTooLarge(__ptr_u64))?; let (__args, __mult) = __mq.get_index_mut(__ptr_usize).ok_or(ExecError::UnboundPointer { ptr: __ptr_u64, size: 6 })?; if !unconstrained { *__mult += G::ONE; } let __arr: [G; 6] = __args[..6].try_into().unwrap(); __arr }; @@ -56924,12 +56652,12 @@ fn aiur_fn_671( let __v_7: G = G::from_u64(1); let __v_8: G = G::from_u64(1); let __v_9: G = { let __values: [G; 3] = [__v_7, __v_8, __v_8]; let __mq = record.memory_queries.get_mut(&3).ok_or(ExecError::InvalidMemorySize(3))?; if let Some(result) = __mq.get_mut(&__values[..]) { if !unconstrained { *result.multiplicity += G::ONE; } result.output[0] } else { let __ptr = G::from_usize(__mq.len()); __mq.insert(&__values[..], &[__ptr], G::from_bool(!unconstrained)); __ptr } }; - let __ret: [G; OUT_671] = [__v_9]; - if let Some(result) = record.function_queries[671].get_mut(&inp[..]) { debug_assert_eq!(result.output, &__ret[..]); if !unconstrained { *result.multiplicity += G::ONE; } } else { record.function_queries[671].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained)); }; + let __ret: [G; OUT_667] = [__v_9]; + if let Some(result) = record.function_queries[667].get_mut(&inp[..]) { debug_assert_eq!(result.output, &__ret[..]); if !unconstrained { *result.multiplicity += G::ONE; } } else { record.function_queries[667].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained)); }; return Ok(__ret); }, 0u64 => { - let __r_arr: [G; OUT_287] = { let __args: [G; IN_287] = [__v_2]; let __cu = unconstrained; if let Some(result) = record.function_queries[287].get_mut(&__args[..]) { if !__cu && *result.multiplicity == G::ZERO { aiur_fn_287(__args, record, io_buffer, false)? } else { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_287] = unsafe { *(result.output.as_ptr() as *const [G; OUT_287]) }; __ret } } else { aiur_fn_287(__args, record, io_buffer, __cu)? } }; + let __r_arr: [G; OUT_283] = { let __args: [G; IN_283] = [__v_2]; let __cu = unconstrained; if let Some(result) = record.function_queries[283].get_mut(&__args[..]) { if !__cu && *result.multiplicity == G::ZERO { aiur_fn_283(__args, record, io_buffer, false)? } else { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_283] = unsafe { *(result.output.as_ptr() as *const [G; OUT_283]) }; __ret } } else { aiur_fn_283(__args, record, io_buffer, __cu)? } }; let __v_7: G = __r_arr[0]; let __loaded: [G; 12] = { let __mq = record.memory_queries.get_mut(&12).ok_or(ExecError::InvalidMemorySize(12))?; let __ptr_u64 = __v_7.as_canonical_u64(); let __ptr_usize = usize::try_from(__ptr_u64).ok().ok_or(ExecError::PointerTooLarge(__ptr_u64))?; let (__args, __mult) = __mq.get_index_mut(__ptr_usize).ok_or(ExecError::UnboundPointer { ptr: __ptr_u64, size: 12 })?; if !unconstrained { *__mult += G::ONE; } let __arr: [G; 12] = __args[..12].try_into().unwrap(); __arr }; let __v_8: G = __loaded[0]; @@ -56956,11 +56684,11 @@ fn aiur_fn_671( }; let __v_20: G = __mc_out___mc_0[0]; let __v_21: G = G::from_u64(0); - let __r_arr: [G; OUT_671] = { let __args: [G; IN_671] = [__v_6]; let __cu = unconstrained; if let Some(result) = record.function_queries[671].get_mut(&__args[..]) { if !__cu && *result.multiplicity == G::ZERO { aiur_fn_671(__args, record, io_buffer, false)? } else { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_671] = unsafe { *(result.output.as_ptr() as *const [G; OUT_671]) }; __ret } } else { aiur_fn_671(__args, record, io_buffer, __cu)? } }; + let __r_arr: [G; OUT_667] = { let __args: [G; IN_667] = [__v_6]; let __cu = unconstrained; if let Some(result) = record.function_queries[667].get_mut(&__args[..]) { if !__cu && *result.multiplicity == G::ZERO { aiur_fn_667(__args, record, io_buffer, false)? } else { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_667] = unsafe { *(result.output.as_ptr() as *const [G; OUT_667]) }; __ret } } else { aiur_fn_667(__args, record, io_buffer, __cu)? } }; let __v_22: G = __r_arr[0]; let __v_23: G = { let __values: [G; 3] = [__v_21, __v_20, __v_22]; let __mq = record.memory_queries.get_mut(&3).ok_or(ExecError::InvalidMemorySize(3))?; if let Some(result) = __mq.get_mut(&__values[..]) { if !unconstrained { *result.multiplicity += G::ONE; } result.output[0] } else { let __ptr = G::from_usize(__mq.len()); __mq.insert(&__values[..], &[__ptr], G::from_bool(!unconstrained)); __ptr } }; - let __ret: [G; OUT_671] = [__v_23]; - if let Some(result) = record.function_queries[671].get_mut(&inp[..]) { debug_assert_eq!(result.output, &__ret[..]); if !unconstrained { *result.multiplicity += G::ONE; } } else { record.function_queries[671].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained)); }; + let __ret: [G; OUT_667] = [__v_23]; + if let Some(result) = record.function_queries[667].get_mut(&inp[..]) { debug_assert_eq!(result.output, &__ret[..]); if !unconstrained { *result.multiplicity += G::ONE; } } else { record.function_queries[667].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained)); }; return Ok(__ret); }, _ => { @@ -56970,20 +56698,20 @@ fn aiur_fn_671( }) } -const INPUT_SIZE_672: usize = 3; -const IN_672: usize = 3; -const OUT_672: usize = 1; -fn aiur_fn_672( - inp: [G; IN_672], +const INPUT_SIZE_668: usize = 3; +const IN_668: usize = 3; +const OUT_668: usize = 1; +fn aiur_fn_668( + inp: [G; IN_668], record: &mut QueryRecord, io_buffer: &mut IOBuffer, unconstrained: bool, -) -> Result<[G; OUT_672], ExecError> { +) -> Result<[G; OUT_668], ExecError> { stacker::maybe_grow(64 * 1024, 4 * 1024 * 1024, || { let __v_0: G = inp[0]; let __v_1: G = inp[1]; let __v_2: G = inp[2]; - let __r_arr: [G; OUT_293] = { let __args: [G; IN_293] = [__v_0]; let __cu = unconstrained; if let Some(result) = record.function_queries[293].get_mut(&__args[..]) { if !__cu && *result.multiplicity == G::ZERO { aiur_fn_293(__args, record, io_buffer, false)? } else { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_293] = unsafe { *(result.output.as_ptr() as *const [G; OUT_293]) }; __ret } } else { aiur_fn_293(__args, record, io_buffer, __cu)? } }; + let __r_arr: [G; OUT_289] = { let __args: [G; IN_289] = [__v_0]; let __cu = unconstrained; if let Some(result) = record.function_queries[289].get_mut(&__args[..]) { if !__cu && *result.multiplicity == G::ZERO { aiur_fn_289(__args, record, io_buffer, false)? } else { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_289] = unsafe { *(result.output.as_ptr() as *const [G; OUT_289]) }; __ret } } else { aiur_fn_289(__args, record, io_buffer, __cu)? } }; let __v_3: G = __r_arr[0]; let __v_4: G = __r_arr[1]; let __v_5: G = __r_arr[2]; @@ -56992,7 +56720,7 @@ fn aiur_fn_672( let __v_8: G = __r_arr[5]; let __v_9: G = __r_arr[6]; let __v_10: G = __r_arr[7]; - let __r_arr: [G; OUT_293] = { let __args: [G; IN_293] = [__v_1]; let __cu = unconstrained; if let Some(result) = record.function_queries[293].get_mut(&__args[..]) { if !__cu && *result.multiplicity == G::ZERO { aiur_fn_293(__args, record, io_buffer, false)? } else { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_293] = unsafe { *(result.output.as_ptr() as *const [G; OUT_293]) }; __ret } } else { aiur_fn_293(__args, record, io_buffer, __cu)? } }; + let __r_arr: [G; OUT_289] = { let __args: [G; IN_289] = [__v_1]; let __cu = unconstrained; if let Some(result) = record.function_queries[289].get_mut(&__args[..]) { if !__cu && *result.multiplicity == G::ZERO { aiur_fn_289(__args, record, io_buffer, false)? } else { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_289] = unsafe { *(result.output.as_ptr() as *const [G; OUT_289]) }; __ret } } else { aiur_fn_289(__args, record, io_buffer, __cu)? } }; let __v_11: G = __r_arr[0]; let __v_12: G = __r_arr[1]; let __v_13: G = __r_arr[2]; @@ -57019,21 +56747,21 @@ fn aiur_fn_672( let __v_33: G = __r_arr[0]; let __r_arr: [G; OUT_21] = { let __args: [G; IN_21] = [__v_33]; let __cu = unconstrained; if let Some(result) = record.function_queries[21].get_mut(&__args[..]) { if !__cu && *result.multiplicity == G::ZERO { aiur_fn_21(__args, record, io_buffer, false)? } else { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_21] = unsafe { *(result.output.as_ptr() as *const [G; OUT_21]) }; __ret } } else { aiur_fn_21(__args, record, io_buffer, __cu)? } }; let __v_34: G = __r_arr[0]; - let __ret: [G; OUT_672] = [__v_34]; - if let Some(result) = record.function_queries[672].get_mut(&inp[..]) { debug_assert_eq!(result.output, &__ret[..]); if !unconstrained { *result.multiplicity += G::ONE; } } else { record.function_queries[672].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained)); }; + let __ret: [G; OUT_668] = [__v_34]; + if let Some(result) = record.function_queries[668].get_mut(&inp[..]) { debug_assert_eq!(result.output, &__ret[..]); if !unconstrained { *result.multiplicity += G::ONE; } } else { record.function_queries[668].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained)); }; return Ok(__ret); }) } -const INPUT_SIZE_673: usize = 15; -const IN_673: usize = 15; -const OUT_673: usize = 1; -fn aiur_fn_673( - inp: [G; IN_673], +const INPUT_SIZE_669: usize = 15; +const IN_669: usize = 15; +const OUT_669: usize = 1; +fn aiur_fn_669( + inp: [G; IN_669], record: &mut QueryRecord, io_buffer: &mut IOBuffer, unconstrained: bool, -) -> Result<[G; OUT_673], ExecError> { +) -> Result<[G; OUT_669], ExecError> { stacker::maybe_grow(64 * 1024, 4 * 1024 * 1024, || { let __v_0: G = inp[0]; let __v_1: G = inp[1]; @@ -57056,12 +56784,12 @@ fn aiur_fn_673( let __v_16: G = G::from_u64(1); let __v_17: G = G::from_u64(1); let __v_18: G = { let __values: [G; 3] = [__v_16, __v_17, __v_17]; let __mq = record.memory_queries.get_mut(&3).ok_or(ExecError::InvalidMemorySize(3))?; if let Some(result) = __mq.get_mut(&__values[..]) { if !unconstrained { *result.multiplicity += G::ONE; } result.output[0] } else { let __ptr = G::from_usize(__mq.len()); __mq.insert(&__values[..], &[__ptr], G::from_bool(!unconstrained)); __ptr } }; - let __ret: [G; OUT_673] = [__v_18]; - if let Some(result) = record.function_queries[673].get_mut(&inp[..]) { debug_assert_eq!(result.output, &__ret[..]); if !unconstrained { *result.multiplicity += G::ONE; } } else { record.function_queries[673].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained)); }; + let __ret: [G; OUT_669] = [__v_18]; + if let Some(result) = record.function_queries[669].get_mut(&inp[..]) { debug_assert_eq!(result.output, &__ret[..]); if !unconstrained { *result.multiplicity += G::ONE; } } else { record.function_queries[669].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained)); }; return Ok(__ret); }, _ => { - let __r_arr: [G; OUT_290] = { let __args: [G; IN_290] = [__v_10, __v_11, __v_14]; let __cu = unconstrained; if let Some(result) = record.function_queries[290].get_mut(&__args[..]) { if !__cu && *result.multiplicity == G::ZERO { aiur_fn_290(__args, record, io_buffer, false)? } else { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_290] = unsafe { *(result.output.as_ptr() as *const [G; OUT_290]) }; __ret } } else { aiur_fn_290(__args, record, io_buffer, __cu)? } }; + let __r_arr: [G; OUT_286] = { let __args: [G; IN_286] = [__v_10, __v_11, __v_14]; let __cu = unconstrained; if let Some(result) = record.function_queries[286].get_mut(&__args[..]) { if !__cu && *result.multiplicity == G::ZERO { aiur_fn_286(__args, record, io_buffer, false)? } else { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_286] = unsafe { *(result.output.as_ptr() as *const [G; OUT_286]) }; __ret } } else { aiur_fn_286(__args, record, io_buffer, __cu)? } }; let __v_16: G = __r_arr[0]; let __loaded: [G; 12] = { let __mq = record.memory_queries.get_mut(&12).ok_or(ExecError::InvalidMemorySize(12))?; let __ptr_u64 = __v_16.as_canonical_u64(); let __ptr_usize = usize::try_from(__ptr_u64).ok().ok_or(ExecError::PointerTooLarge(__ptr_u64))?; let (__args, __mult) = __mq.get_index_mut(__ptr_usize).ok_or(ExecError::UnboundPointer { ptr: __ptr_u64, size: 12 })?; if !unconstrained { *__mult += G::ONE; } let __arr: [G; 12] = __args[..12].try_into().unwrap(); __arr }; let __v_17: G = __loaded[0]; @@ -57078,20 +56806,20 @@ fn aiur_fn_673( let __v_28: G = __loaded[11]; match __v_17.as_canonical_u64() { 6u64 => { - let __r_arr: [G; OUT_672] = { let __args: [G; IN_672] = [__v_11, __v_14, __v_10]; let __cu = unconstrained; if let Some(result) = record.function_queries[672].get_mut(&__args[..]) { if !__cu && *result.multiplicity == G::ZERO { aiur_fn_672(__args, record, io_buffer, false)? } else { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_672] = unsafe { *(result.output.as_ptr() as *const [G; OUT_672]) }; __ret } } else { aiur_fn_672(__args, record, io_buffer, __cu)? } }; + let __r_arr: [G; OUT_668] = { let __args: [G; IN_668] = [__v_11, __v_14, __v_10]; let __cu = unconstrained; if let Some(result) = record.function_queries[668].get_mut(&__args[..]) { if !__cu && *result.multiplicity == G::ZERO { aiur_fn_668(__args, record, io_buffer, false)? } else { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_668] = unsafe { *(result.output.as_ptr() as *const [G; OUT_668]) }; __ret } } else { aiur_fn_668(__args, record, io_buffer, __cu)? } }; let __v_29: G = __r_arr[0]; - let __r_arr: [G; OUT_679] = { let __args: [G; IN_679] = [__v_29, __v_19, __v_23, __v_1, __v_2, __v_3, __v_4, __v_5, __v_6, __v_7, __v_13, __v_8, __v_9]; let __cu = unconstrained; if let Some(result) = record.function_queries[679].get_mut(&__args[..]) { if !__cu && *result.multiplicity == G::ZERO { aiur_fn_679(__args, record, io_buffer, false)? } else { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_679] = unsafe { *(result.output.as_ptr() as *const [G; OUT_679]) }; __ret } } else { aiur_fn_679(__args, record, io_buffer, __cu)? } }; + let __r_arr: [G; OUT_675] = { let __args: [G; IN_675] = [__v_29, __v_19, __v_23, __v_1, __v_2, __v_3, __v_4, __v_5, __v_6, __v_7, __v_13, __v_8, __v_9]; let __cu = unconstrained; if let Some(result) = record.function_queries[675].get_mut(&__args[..]) { if !__cu && *result.multiplicity == G::ZERO { aiur_fn_675(__args, record, io_buffer, false)? } else { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_675] = unsafe { *(result.output.as_ptr() as *const [G; OUT_675]) }; __ret } } else { aiur_fn_675(__args, record, io_buffer, __cu)? } }; let __v_30: G = __r_arr[0]; let __v_31: G = G::from_u64(0); let __v_32: G = G::from_u64(1); let __v_33: G = (__v_13 + __v_32); let __v_34: G = G::from_u64(1); let __v_35: G = (__v_14 + __v_34); - let __r_arr: [G; OUT_673] = { let __args: [G; IN_673] = [__v_0, __v_1, __v_2, __v_3, __v_4, __v_5, __v_6, __v_7, __v_8, __v_9, __v_10, __v_11, __v_12, __v_33, __v_35]; let __cu = unconstrained; if let Some(result) = record.function_queries[673].get_mut(&__args[..]) { if !__cu && *result.multiplicity == G::ZERO { aiur_fn_673(__args, record, io_buffer, false)? } else { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_673] = unsafe { *(result.output.as_ptr() as *const [G; OUT_673]) }; __ret } } else { aiur_fn_673(__args, record, io_buffer, __cu)? } }; + let __r_arr: [G; OUT_669] = { let __args: [G; IN_669] = [__v_0, __v_1, __v_2, __v_3, __v_4, __v_5, __v_6, __v_7, __v_8, __v_9, __v_10, __v_11, __v_12, __v_33, __v_35]; let __cu = unconstrained; if let Some(result) = record.function_queries[669].get_mut(&__args[..]) { if !__cu && *result.multiplicity == G::ZERO { aiur_fn_669(__args, record, io_buffer, false)? } else { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_669] = unsafe { *(result.output.as_ptr() as *const [G; OUT_669]) }; __ret } } else { aiur_fn_669(__args, record, io_buffer, __cu)? } }; let __v_36: G = __r_arr[0]; let __v_37: G = { let __values: [G; 3] = [__v_31, __v_30, __v_36]; let __mq = record.memory_queries.get_mut(&3).ok_or(ExecError::InvalidMemorySize(3))?; if let Some(result) = __mq.get_mut(&__values[..]) { if !unconstrained { *result.multiplicity += G::ONE; } result.output[0] } else { let __ptr = G::from_usize(__mq.len()); __mq.insert(&__values[..], &[__ptr], G::from_bool(!unconstrained)); __ptr } }; - let __ret: [G; OUT_673] = [__v_37]; - if let Some(result) = record.function_queries[673].get_mut(&inp[..]) { debug_assert_eq!(result.output, &__ret[..]); if !unconstrained { *result.multiplicity += G::ONE; } } else { record.function_queries[673].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained)); }; + let __ret: [G; OUT_669] = [__v_37]; + if let Some(result) = record.function_queries[669].get_mut(&inp[..]) { debug_assert_eq!(result.output, &__ret[..]); if !unconstrained { *result.multiplicity += G::ONE; } } else { record.function_queries[669].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained)); }; return Ok(__ret); }, _ => { @@ -57103,15 +56831,15 @@ fn aiur_fn_673( }) } -const INPUT_SIZE_674: usize = 5; -const IN_674: usize = 5; -const OUT_674: usize = 1; -fn aiur_fn_674( - inp: [G; IN_674], +const INPUT_SIZE_670: usize = 5; +const IN_670: usize = 5; +const OUT_670: usize = 1; +fn aiur_fn_670( + inp: [G; IN_670], record: &mut QueryRecord, io_buffer: &mut IOBuffer, unconstrained: bool, -) -> Result<[G; OUT_674], ExecError> { +) -> Result<[G; OUT_670], ExecError> { stacker::maybe_grow(64 * 1024, 4 * 1024 * 1024, || { let __v_0: G = inp[0]; let __v_1: G = inp[1]; @@ -57120,23 +56848,23 @@ fn aiur_fn_674( let __v_4: G = inp[4]; let __v_5: G = G::from_u64(0); let __v_6: G = G::from_u64(0); - let __r_arr: [G; OUT_675] = { let __args: [G; IN_675] = [__v_0, __v_0, __v_1, __v_2, __v_3, __v_4, __v_5, __v_6]; let __cu = unconstrained; if let Some(result) = record.function_queries[675].get_mut(&__args[..]) { if !__cu && *result.multiplicity == G::ZERO { aiur_fn_675(__args, record, io_buffer, false)? } else { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_675] = unsafe { *(result.output.as_ptr() as *const [G; OUT_675]) }; __ret } } else { aiur_fn_675(__args, record, io_buffer, __cu)? } }; + let __r_arr: [G; OUT_671] = { let __args: [G; IN_671] = [__v_0, __v_0, __v_1, __v_2, __v_3, __v_4, __v_5, __v_6]; let __cu = unconstrained; if let Some(result) = record.function_queries[671].get_mut(&__args[..]) { if !__cu && *result.multiplicity == G::ZERO { aiur_fn_671(__args, record, io_buffer, false)? } else { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_671] = unsafe { *(result.output.as_ptr() as *const [G; OUT_671]) }; __ret } } else { aiur_fn_671(__args, record, io_buffer, __cu)? } }; let __v_7: G = __r_arr[0]; - let __ret: [G; OUT_674] = [__v_7]; - if let Some(result) = record.function_queries[674].get_mut(&inp[..]) { debug_assert_eq!(result.output, &__ret[..]); if !unconstrained { *result.multiplicity += G::ONE; } } else { record.function_queries[674].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained)); }; + let __ret: [G; OUT_670] = [__v_7]; + if let Some(result) = record.function_queries[670].get_mut(&inp[..]) { debug_assert_eq!(result.output, &__ret[..]); if !unconstrained { *result.multiplicity += G::ONE; } } else { record.function_queries[670].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained)); }; return Ok(__ret); }) } -const INPUT_SIZE_675: usize = 8; -const IN_675: usize = 8; -const OUT_675: usize = 1; -fn aiur_fn_675( - inp: [G; IN_675], +const INPUT_SIZE_671: usize = 8; +const IN_671: usize = 8; +const OUT_671: usize = 1; +fn aiur_fn_671( + inp: [G; IN_671], record: &mut QueryRecord, io_buffer: &mut IOBuffer, unconstrained: bool, -) -> Result<[G; OUT_675], ExecError> { +) -> Result<[G; OUT_671], ExecError> { stacker::maybe_grow(64 * 1024, 4 * 1024 * 1024, || { let __v_0: G = inp[0]; let __v_1: G = inp[1]; @@ -57158,12 +56886,12 @@ fn aiur_fn_675( let __v_14: G = G::from_u64(1); let __v_15: G = G::from_u64(1); let __v_16: G = { let __values: [G; 3] = [__v_14, __v_15, __v_15]; let __mq = record.memory_queries.get_mut(&3).ok_or(ExecError::InvalidMemorySize(3))?; if let Some(result) = __mq.get_mut(&__values[..]) { if !unconstrained { *result.multiplicity += G::ONE; } result.output[0] } else { let __ptr = G::from_usize(__mq.len()); __mq.insert(&__values[..], &[__ptr], G::from_bool(!unconstrained)); __ptr } }; - let __ret: [G; OUT_675] = [__v_16]; - if let Some(result) = record.function_queries[675].get_mut(&inp[..]) { debug_assert_eq!(result.output, &__ret[..]); if !unconstrained { *result.multiplicity += G::ONE; } } else { record.function_queries[675].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained)); }; + let __ret: [G; OUT_671] = [__v_16]; + if let Some(result) = record.function_queries[671].get_mut(&inp[..]) { debug_assert_eq!(result.output, &__ret[..]); if !unconstrained { *result.multiplicity += G::ONE; } } else { record.function_queries[671].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained)); }; return Ok(__ret); }, 0u64 => { - let __r_arr: [G; OUT_287] = { let __args: [G; IN_287] = [__v_9]; let __cu = unconstrained; if let Some(result) = record.function_queries[287].get_mut(&__args[..]) { if !__cu && *result.multiplicity == G::ZERO { aiur_fn_287(__args, record, io_buffer, false)? } else { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_287] = unsafe { *(result.output.as_ptr() as *const [G; OUT_287]) }; __ret } } else { aiur_fn_287(__args, record, io_buffer, __cu)? } }; + let __r_arr: [G; OUT_283] = { let __args: [G; IN_283] = [__v_9]; let __cu = unconstrained; if let Some(result) = record.function_queries[283].get_mut(&__args[..]) { if !__cu && *result.multiplicity == G::ZERO { aiur_fn_283(__args, record, io_buffer, false)? } else { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_283] = unsafe { *(result.output.as_ptr() as *const [G; OUT_283]) }; __ret } } else { aiur_fn_283(__args, record, io_buffer, __cu)? } }; let __v_14: G = __r_arr[0]; let __loaded: [G; 12] = { let __mq = record.memory_queries.get_mut(&12).ok_or(ExecError::InvalidMemorySize(12))?; let __ptr_u64 = __v_14.as_canonical_u64(); let __ptr_usize = usize::try_from(__ptr_u64).ok().ok_or(ExecError::PointerTooLarge(__ptr_u64))?; let (__args, __mult) = __mq.get_index_mut(__ptr_usize).ok_or(ExecError::UnboundPointer { ptr: __ptr_u64, size: 12 })?; if !unconstrained { *__mult += G::ONE; } let __arr: [G; 12] = __args[..12].try_into().unwrap(); __arr }; let __v_15: G = __loaded[0]; @@ -57181,28 +56909,28 @@ fn aiur_fn_675( match __v_15.as_canonical_u64() { 5u64 => { let __v_27: G = G::from_u64(0); - let __r_arr: [G; OUT_673] = { let __args: [G; IN_673] = [__v_9, __v_10, __v_11, __v_12, __v_1, __v_2, __v_3, __v_4, __v_5, __v_7, __v_22, __v_23, __v_20, __v_6, __v_27]; let __cu = unconstrained; if let Some(result) = record.function_queries[673].get_mut(&__args[..]) { if !__cu && *result.multiplicity == G::ZERO { aiur_fn_673(__args, record, io_buffer, false)? } else { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_673] = unsafe { *(result.output.as_ptr() as *const [G; OUT_673]) }; __ret } } else { aiur_fn_673(__args, record, io_buffer, __cu)? } }; + let __r_arr: [G; OUT_669] = { let __args: [G; IN_669] = [__v_9, __v_10, __v_11, __v_12, __v_1, __v_2, __v_3, __v_4, __v_5, __v_7, __v_22, __v_23, __v_20, __v_6, __v_27]; let __cu = unconstrained; if let Some(result) = record.function_queries[669].get_mut(&__args[..]) { if !__cu && *result.multiplicity == G::ZERO { aiur_fn_669(__args, record, io_buffer, false)? } else { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_669] = unsafe { *(result.output.as_ptr() as *const [G; OUT_669]) }; __ret } } else { aiur_fn_669(__args, record, io_buffer, __cu)? } }; let __v_28: G = __r_arr[0]; - let __r_arr: [G; OUT_764] = { let __args: [G; IN_764] = [__v_28]; let __cu = unconstrained; if let Some(result) = record.function_queries[764].get_mut(&__args[..]) { if !__cu && *result.multiplicity == G::ZERO { aiur_fn_764(__args, record, io_buffer, false)? } else { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_764] = unsafe { *(result.output.as_ptr() as *const [G; OUT_764]) }; __ret } } else { aiur_fn_764(__args, record, io_buffer, __cu)? } }; + let __r_arr: [G; OUT_760] = { let __args: [G; IN_760] = [__v_28]; let __cu = unconstrained; if let Some(result) = record.function_queries[760].get_mut(&__args[..]) { if !__cu && *result.multiplicity == G::ZERO { aiur_fn_760(__args, record, io_buffer, false)? } else { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_760] = unsafe { *(result.output.as_ptr() as *const [G; OUT_760]) }; __ret } } else { aiur_fn_760(__args, record, io_buffer, __cu)? } }; let __v_29: G = __r_arr[0]; let __v_30: G = (__v_6 + __v_29); let __v_31: G = G::from_u64(1); let __v_32: G = (__v_7 + __v_31); - let __r_arr: [G; OUT_675] = { let __args: [G; IN_675] = [__v_13, __v_1, __v_2, __v_3, __v_4, __v_5, __v_30, __v_32]; let __cu = unconstrained; if let Some(result) = record.function_queries[675].get_mut(&__args[..]) { if !__cu && *result.multiplicity == G::ZERO { aiur_fn_675(__args, record, io_buffer, false)? } else { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_675] = unsafe { *(result.output.as_ptr() as *const [G; OUT_675]) }; __ret } } else { aiur_fn_675(__args, record, io_buffer, __cu)? } }; + let __r_arr: [G; OUT_671] = { let __args: [G; IN_671] = [__v_13, __v_1, __v_2, __v_3, __v_4, __v_5, __v_30, __v_32]; let __cu = unconstrained; if let Some(result) = record.function_queries[671].get_mut(&__args[..]) { if !__cu && *result.multiplicity == G::ZERO { aiur_fn_671(__args, record, io_buffer, false)? } else { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_671] = unsafe { *(result.output.as_ptr() as *const [G; OUT_671]) }; __ret } } else { aiur_fn_671(__args, record, io_buffer, __cu)? } }; let __v_33: G = __r_arr[0]; - let __r_arr: [G; OUT_763] = { let __args: [G; IN_763] = [__v_28, __v_33]; let __cu = unconstrained; if let Some(result) = record.function_queries[763].get_mut(&__args[..]) { if !__cu && *result.multiplicity == G::ZERO { aiur_fn_763(__args, record, io_buffer, false)? } else { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_763] = unsafe { *(result.output.as_ptr() as *const [G; OUT_763]) }; __ret } } else { aiur_fn_763(__args, record, io_buffer, __cu)? } }; + let __r_arr: [G; OUT_759] = { let __args: [G; IN_759] = [__v_28, __v_33]; let __cu = unconstrained; if let Some(result) = record.function_queries[759].get_mut(&__args[..]) { if !__cu && *result.multiplicity == G::ZERO { aiur_fn_759(__args, record, io_buffer, false)? } else { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_759] = unsafe { *(result.output.as_ptr() as *const [G; OUT_759]) }; __ret } } else { aiur_fn_759(__args, record, io_buffer, __cu)? } }; let __v_34: G = __r_arr[0]; - let __ret: [G; OUT_675] = [__v_34]; - if let Some(result) = record.function_queries[675].get_mut(&inp[..]) { debug_assert_eq!(result.output, &__ret[..]); if !unconstrained { *result.multiplicity += G::ONE; } } else { record.function_queries[675].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained)); }; + let __ret: [G; OUT_671] = [__v_34]; + if let Some(result) = record.function_queries[671].get_mut(&inp[..]) { debug_assert_eq!(result.output, &__ret[..]); if !unconstrained { *result.multiplicity += G::ONE; } } else { record.function_queries[671].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained)); }; return Ok(__ret); }, _ => { let __v_27: G = G::from_u64(1); let __v_28: G = (__v_7 + __v_27); - let __r_arr: [G; OUT_675] = { let __args: [G; IN_675] = [__v_13, __v_1, __v_2, __v_3, __v_4, __v_5, __v_6, __v_28]; let __cu = unconstrained; if let Some(result) = record.function_queries[675].get_mut(&__args[..]) { if !__cu && *result.multiplicity == G::ZERO { aiur_fn_675(__args, record, io_buffer, false)? } else { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_675] = unsafe { *(result.output.as_ptr() as *const [G; OUT_675]) }; __ret } } else { aiur_fn_675(__args, record, io_buffer, __cu)? } }; + let __r_arr: [G; OUT_671] = { let __args: [G; IN_671] = [__v_13, __v_1, __v_2, __v_3, __v_4, __v_5, __v_6, __v_28]; let __cu = unconstrained; if let Some(result) = record.function_queries[671].get_mut(&__args[..]) { if !__cu && *result.multiplicity == G::ZERO { aiur_fn_671(__args, record, io_buffer, false)? } else { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_671] = unsafe { *(result.output.as_ptr() as *const [G; OUT_671]) }; __ret } } else { aiur_fn_671(__args, record, io_buffer, __cu)? } }; let __v_29: G = __r_arr[0]; - let __ret: [G; OUT_675] = [__v_29]; - if let Some(result) = record.function_queries[675].get_mut(&inp[..]) { debug_assert_eq!(result.output, &__ret[..]); if !unconstrained { *result.multiplicity += G::ONE; } } else { record.function_queries[675].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained)); }; + let __ret: [G; OUT_671] = [__v_29]; + if let Some(result) = record.function_queries[671].get_mut(&inp[..]) { debug_assert_eq!(result.output, &__ret[..]); if !unconstrained { *result.multiplicity += G::ONE; } } else { record.function_queries[671].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained)); }; return Ok(__ret); }, } @@ -57214,15 +56942,15 @@ fn aiur_fn_675( }) } -const INPUT_SIZE_676: usize = 5; -const IN_676: usize = 5; -const OUT_676: usize = 1; -fn aiur_fn_676( - inp: [G; IN_676], +const INPUT_SIZE_672: usize = 5; +const IN_672: usize = 5; +const OUT_672: usize = 1; +fn aiur_fn_672( + inp: [G; IN_672], record: &mut QueryRecord, io_buffer: &mut IOBuffer, unconstrained: bool, -) -> Result<[G; OUT_676], ExecError> { +) -> Result<[G; OUT_672], ExecError> { stacker::maybe_grow(64 * 1024, 4 * 1024 * 1024, || { let __v_0: G = inp[0]; let __v_1: G = inp[1]; @@ -57237,23 +56965,23 @@ fn aiur_fn_676( let __v_8: G = (__v_7 - __v_0); let __v_9: G = G::from_u64(0); let __v_10: G = { let __values: [G; 4] = [__v_5, __v_8, __v_9, __v_9]; let __mq = record.memory_queries.get_mut(&4).ok_or(ExecError::InvalidMemorySize(4))?; if let Some(result) = __mq.get_mut(&__values[..]) { if !unconstrained { *result.multiplicity += G::ONE; } result.output[0] } else { let __ptr = G::from_usize(__mq.len()); __mq.insert(&__values[..], &[__ptr], G::from_bool(!unconstrained)); __ptr } }; - let __ret: [G; OUT_676] = [__v_10]; - if let Some(result) = record.function_queries[676].get_mut(&inp[..]) { debug_assert_eq!(result.output, &__ret[..]); if !unconstrained { *result.multiplicity += G::ONE; } } else { record.function_queries[676].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained)); }; + let __ret: [G; OUT_672] = [__v_10]; + if let Some(result) = record.function_queries[672].get_mut(&inp[..]) { debug_assert_eq!(result.output, &__ret[..]); if !unconstrained { *result.multiplicity += G::ONE; } } else { record.function_queries[672].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained)); }; return Ok(__ret); }, _ => { - let __r_arr: [G; OUT_764] = { let __args: [G; IN_764] = [__v_4]; let __cu = unconstrained; if let Some(result) = record.function_queries[764].get_mut(&__args[..]) { if !__cu && *result.multiplicity == G::ZERO { aiur_fn_764(__args, record, io_buffer, false)? } else { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_764] = unsafe { *(result.output.as_ptr() as *const [G; OUT_764]) }; __ret } } else { aiur_fn_764(__args, record, io_buffer, __cu)? } }; + let __r_arr: [G; OUT_760] = { let __args: [G; IN_760] = [__v_4]; let __cu = unconstrained; if let Some(result) = record.function_queries[760].get_mut(&__args[..]) { if !__cu && *result.multiplicity == G::ZERO { aiur_fn_760(__args, record, io_buffer, false)? } else { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_760] = unsafe { *(result.output.as_ptr() as *const [G; OUT_760]) }; __ret } } else { aiur_fn_760(__args, record, io_buffer, __cu)? } }; let __v_5: G = __r_arr[0]; let __v_6: G = { let __a_val = __v_0.as_canonical_u64(); let __b_val = __v_5.as_canonical_u64(); let __a_u32 = u32::try_from(__a_val).ok().ok_or(ExecError::U32OutOfRange(__a_val))?; let __b_u32 = u32::try_from(__b_val).ok().ok_or(ExecError::U32OutOfRange(__b_val))?; let __result = G::from_bool(__a_u32 < __b_u32); if !unconstrained { let __x_bytes = __a_u32.to_le_bytes(); let __z_bytes = __b_u32.to_le_bytes(); let __c_u32 = __b_u32.wrapping_sub(__a_u32).wrapping_sub(1); let __y_bytes = __c_u32.to_le_bytes(); record.bytes2_queries.bump_range_check(&G::from_u8(__x_bytes[0]), &G::from_u8(__x_bytes[1])); record.bytes2_queries.bump_range_check(&G::from_u8(__x_bytes[2]), &G::from_u8(__x_bytes[3])); record.bytes2_queries.bump_range_check(&G::from_u8(__y_bytes[0]), &G::from_u8(__y_bytes[1])); record.bytes2_queries.bump_range_check(&G::from_u8(__y_bytes[2]), &G::from_u8(__y_bytes[3])); record.bytes2_queries.bump_range_check(&G::from_u8(__z_bytes[0]), &G::from_u8(__z_bytes[1])); record.bytes2_queries.bump_range_check(&G::from_u8(__z_bytes[2]), &G::from_u8(__z_bytes[3])); } __result }; match __v_6.as_canonical_u64() { 1u64 => { - let __r_arr: [G; OUT_766] = { let __args: [G; IN_766] = [__v_4, __v_0]; let __cu = unconstrained; if let Some(result) = record.function_queries[766].get_mut(&__args[..]) { if !__cu && *result.multiplicity == G::ZERO { aiur_fn_766(__args, record, io_buffer, false)? } else { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_766] = unsafe { *(result.output.as_ptr() as *const [G; OUT_766]) }; __ret } } else { aiur_fn_766(__args, record, io_buffer, __cu)? } }; + let __r_arr: [G; OUT_762] = { let __args: [G; IN_762] = [__v_4, __v_0]; let __cu = unconstrained; if let Some(result) = record.function_queries[762].get_mut(&__args[..]) { if !__cu && *result.multiplicity == G::ZERO { aiur_fn_762(__args, record, io_buffer, false)? } else { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_762] = unsafe { *(result.output.as_ptr() as *const [G; OUT_762]) }; __ret } } else { aiur_fn_762(__args, record, io_buffer, __cu)? } }; let __v_7: G = __r_arr[0]; let __v_8: G = G::from_u64(0); - let __r_arr: [G; OUT_359] = { let __args: [G; IN_359] = [__v_7, __v_2, __v_8]; let __cu = unconstrained; if let Some(result) = record.function_queries[359].get_mut(&__args[..]) { if !__cu && *result.multiplicity == G::ZERO { aiur_fn_359(__args, record, io_buffer, false)? } else { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_359] = unsafe { *(result.output.as_ptr() as *const [G; OUT_359]) }; __ret } } else { aiur_fn_359(__args, record, io_buffer, __cu)? } }; + let __r_arr: [G; OUT_355] = { let __args: [G; IN_355] = [__v_7, __v_2, __v_8]; let __cu = unconstrained; if let Some(result) = record.function_queries[355].get_mut(&__args[..]) { if !__cu && *result.multiplicity == G::ZERO { aiur_fn_355(__args, record, io_buffer, false)? } else { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_355] = unsafe { *(result.output.as_ptr() as *const [G; OUT_355]) }; __ret } } else { aiur_fn_355(__args, record, io_buffer, __cu)? } }; let __v_9: G = __r_arr[0]; - let __ret: [G; OUT_676] = [__v_9]; - if let Some(result) = record.function_queries[676].get_mut(&inp[..]) { debug_assert_eq!(result.output, &__ret[..]); if !unconstrained { *result.multiplicity += G::ONE; } } else { record.function_queries[676].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained)); }; + let __ret: [G; OUT_672] = [__v_9]; + if let Some(result) = record.function_queries[672].get_mut(&inp[..]) { debug_assert_eq!(result.output, &__ret[..]); if !unconstrained { *result.multiplicity += G::ONE; } } else { record.function_queries[672].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained)); }; return Ok(__ret); }, _ => { @@ -57263,8 +56991,8 @@ fn aiur_fn_676( let __v_10: G = (__v_9 - __v_0); let __v_11: G = G::from_u64(0); let __v_12: G = { let __values: [G; 4] = [__v_7, __v_10, __v_11, __v_11]; let __mq = record.memory_queries.get_mut(&4).ok_or(ExecError::InvalidMemorySize(4))?; if let Some(result) = __mq.get_mut(&__values[..]) { if !unconstrained { *result.multiplicity += G::ONE; } result.output[0] } else { let __ptr = G::from_usize(__mq.len()); __mq.insert(&__values[..], &[__ptr], G::from_bool(!unconstrained)); __ptr } }; - let __ret: [G; OUT_676] = [__v_12]; - if let Some(result) = record.function_queries[676].get_mut(&inp[..]) { debug_assert_eq!(result.output, &__ret[..]); if !unconstrained { *result.multiplicity += G::ONE; } } else { record.function_queries[676].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained)); }; + let __ret: [G; OUT_672] = [__v_12]; + if let Some(result) = record.function_queries[672].get_mut(&inp[..]) { debug_assert_eq!(result.output, &__ret[..]); if !unconstrained { *result.multiplicity += G::ONE; } } else { record.function_queries[672].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained)); }; return Ok(__ret); }, } @@ -57273,15 +57001,15 @@ fn aiur_fn_676( }) } -const INPUT_SIZE_677: usize = 2; -const IN_677: usize = 2; -const OUT_677: usize = 1; -fn aiur_fn_677( - inp: [G; IN_677], +const INPUT_SIZE_673: usize = 2; +const IN_673: usize = 2; +const OUT_673: usize = 1; +fn aiur_fn_673( + inp: [G; IN_673], record: &mut QueryRecord, io_buffer: &mut IOBuffer, unconstrained: bool, -) -> Result<[G; OUT_677], ExecError> { +) -> Result<[G; OUT_673], ExecError> { stacker::maybe_grow(64 * 1024, 4 * 1024 * 1024, || { let __v_0: G = inp[0]; let __v_1: G = inp[1]; @@ -57294,30 +57022,30 @@ fn aiur_fn_677( 5u64 => { let __v_6: G = G::from_u64(1); let __v_7: G = (__v_1 + __v_6); - let __r_arr: [G; OUT_677] = { let __args: [G; IN_677] = [__v_4, __v_7]; let __cu = unconstrained; if let Some(result) = record.function_queries[677].get_mut(&__args[..]) { if !__cu && *result.multiplicity == G::ZERO { aiur_fn_677(__args, record, io_buffer, false)? } else { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_677] = unsafe { *(result.output.as_ptr() as *const [G; OUT_677]) }; __ret } } else { aiur_fn_677(__args, record, io_buffer, __cu)? } }; + let __r_arr: [G; OUT_673] = { let __args: [G; IN_673] = [__v_4, __v_7]; let __cu = unconstrained; if let Some(result) = record.function_queries[673].get_mut(&__args[..]) { if !__cu && *result.multiplicity == G::ZERO { aiur_fn_673(__args, record, io_buffer, false)? } else { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_673] = unsafe { *(result.output.as_ptr() as *const [G; OUT_673]) }; __ret } } else { aiur_fn_673(__args, record, io_buffer, __cu)? } }; let __v_8: G = __r_arr[0]; - let __ret: [G; OUT_677] = [__v_8]; - if let Some(result) = record.function_queries[677].get_mut(&inp[..]) { debug_assert_eq!(result.output, &__ret[..]); if !unconstrained { *result.multiplicity += G::ONE; } } else { record.function_queries[677].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained)); }; + let __ret: [G; OUT_673] = [__v_8]; + if let Some(result) = record.function_queries[673].get_mut(&inp[..]) { debug_assert_eq!(result.output, &__ret[..]); if !unconstrained { *result.multiplicity += G::ONE; } } else { record.function_queries[673].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained)); }; return Ok(__ret); }, _ => { - let __ret: [G; OUT_677] = [__v_1]; - if let Some(result) = record.function_queries[677].get_mut(&inp[..]) { debug_assert_eq!(result.output, &__ret[..]); if !unconstrained { *result.multiplicity += G::ONE; } } else { record.function_queries[677].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained)); }; + let __ret: [G; OUT_673] = [__v_1]; + if let Some(result) = record.function_queries[673].get_mut(&inp[..]) { debug_assert_eq!(result.output, &__ret[..]); if !unconstrained { *result.multiplicity += G::ONE; } } else { record.function_queries[673].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained)); }; return Ok(__ret); }, } }) } -const INPUT_SIZE_678: usize = 7; -const IN_678: usize = 7; -const OUT_678: usize = 1; -fn aiur_fn_678( - inp: [G; IN_678], +const INPUT_SIZE_674: usize = 7; +const IN_674: usize = 7; +const OUT_674: usize = 1; +fn aiur_fn_674( + inp: [G; IN_674], record: &mut QueryRecord, io_buffer: &mut IOBuffer, unconstrained: bool, -) -> Result<[G; OUT_678], ExecError> { +) -> Result<[G; OUT_674], ExecError> { stacker::maybe_grow(64 * 1024, 4 * 1024 * 1024, || { let __v_0: G = inp[0]; let __v_1: G = inp[1]; @@ -57328,8 +57056,8 @@ fn aiur_fn_678( let __v_6: G = inp[6]; match __v_1.as_canonical_u64() { 0u64 => { - let __ret: [G; OUT_678] = [__v_0]; - if let Some(result) = record.function_queries[678].get_mut(&inp[..]) { debug_assert_eq!(result.output, &__ret[..]); if !unconstrained { *result.multiplicity += G::ONE; } } else { record.function_queries[678].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained)); }; + let __ret: [G; OUT_674] = [__v_0]; + if let Some(result) = record.function_queries[674].get_mut(&inp[..]) { debug_assert_eq!(result.output, &__ret[..]); if !unconstrained { *result.multiplicity += G::ONE; } } else { record.function_queries[674].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained)); }; return Ok(__ret); }, _ => { @@ -57340,26 +57068,26 @@ fn aiur_fn_678( let __v_10: G = __loaded[3]; match __v_7.as_canonical_u64() { 5u64 => { - let __r_arr: [G; OUT_676] = { let __args: [G; IN_676] = [__v_6, __v_2, __v_3, __v_4, __v_5]; let __cu = unconstrained; if let Some(result) = record.function_queries[676].get_mut(&__args[..]) { if !__cu && *result.multiplicity == G::ZERO { aiur_fn_676(__args, record, io_buffer, false)? } else { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_676] = unsafe { *(result.output.as_ptr() as *const [G; OUT_676]) }; __ret } } else { aiur_fn_676(__args, record, io_buffer, __cu)? } }; + let __r_arr: [G; OUT_672] = { let __args: [G; IN_672] = [__v_6, __v_2, __v_3, __v_4, __v_5]; let __cu = unconstrained; if let Some(result) = record.function_queries[672].get_mut(&__args[..]) { if !__cu && *result.multiplicity == G::ZERO { aiur_fn_672(__args, record, io_buffer, false)? } else { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_672] = unsafe { *(result.output.as_ptr() as *const [G; OUT_672]) }; __ret } } else { aiur_fn_672(__args, record, io_buffer, __cu)? } }; let __v_11: G = __r_arr[0]; let __v_12: G = G::from_u64(0); - let __r_arr: [G; OUT_368] = { let __args: [G; IN_368] = [__v_9, __v_11, __v_12]; let __cu = unconstrained; if let Some(result) = record.function_queries[368].get_mut(&__args[..]) { if !__cu && *result.multiplicity == G::ZERO { aiur_fn_368(__args, record, io_buffer, false)? } else { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_368] = unsafe { *(result.output.as_ptr() as *const [G; OUT_368]) }; __ret } } else { aiur_fn_368(__args, record, io_buffer, __cu)? } }; + let __r_arr: [G; OUT_364] = { let __args: [G; IN_364] = [__v_9, __v_11, __v_12]; let __cu = unconstrained; if let Some(result) = record.function_queries[364].get_mut(&__args[..]) { if !__cu && *result.multiplicity == G::ZERO { aiur_fn_364(__args, record, io_buffer, false)? } else { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_364] = unsafe { *(result.output.as_ptr() as *const [G; OUT_364]) }; __ret } } else { aiur_fn_364(__args, record, io_buffer, __cu)? } }; let __v_13: G = __r_arr[0]; let __v_14: G = G::from_u64(1); let __v_15: G = (__v_1 - __v_14); let __v_16: G = G::from_u64(1); let __v_17: G = (__v_6 + __v_16); - let __r_arr: [G; OUT_678] = { let __args: [G; IN_678] = [__v_13, __v_15, __v_2, __v_3, __v_4, __v_5, __v_17]; let __cu = unconstrained; if let Some(result) = record.function_queries[678].get_mut(&__args[..]) { if !__cu && *result.multiplicity == G::ZERO { aiur_fn_678(__args, record, io_buffer, false)? } else { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_678] = unsafe { *(result.output.as_ptr() as *const [G; OUT_678]) }; __ret } } else { aiur_fn_678(__args, record, io_buffer, __cu)? } }; + let __r_arr: [G; OUT_674] = { let __args: [G; IN_674] = [__v_13, __v_15, __v_2, __v_3, __v_4, __v_5, __v_17]; let __cu = unconstrained; if let Some(result) = record.function_queries[674].get_mut(&__args[..]) { if !__cu && *result.multiplicity == G::ZERO { aiur_fn_674(__args, record, io_buffer, false)? } else { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_674] = unsafe { *(result.output.as_ptr() as *const [G; OUT_674]) }; __ret } } else { aiur_fn_674(__args, record, io_buffer, __cu)? } }; let __v_18: G = __r_arr[0]; - let __ret: [G; OUT_678] = [__v_18]; - if let Some(result) = record.function_queries[678].get_mut(&inp[..]) { debug_assert_eq!(result.output, &__ret[..]); if !unconstrained { *result.multiplicity += G::ONE; } } else { record.function_queries[678].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained)); }; + let __ret: [G; OUT_674] = [__v_18]; + if let Some(result) = record.function_queries[674].get_mut(&inp[..]) { debug_assert_eq!(result.output, &__ret[..]); if !unconstrained { *result.multiplicity += G::ONE; } } else { record.function_queries[674].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained)); }; return Ok(__ret); }, _ => { let __v_11: G = G::from_u64(1); let __v_12: G = G::from_u64(1); let __v_13: G = { let __values: [G; 3] = [__v_11, __v_12, __v_12]; let __mq = record.memory_queries.get_mut(&3).ok_or(ExecError::InvalidMemorySize(3))?; if let Some(result) = __mq.get_mut(&__values[..]) { if !unconstrained { *result.multiplicity += G::ONE; } result.output[0] } else { let __ptr = G::from_usize(__mq.len()); __mq.insert(&__values[..], &[__ptr], G::from_bool(!unconstrained)); __ptr } }; - let __r_arr: [G; OUT_418] = { let __args: [G; IN_418] = [__v_0, __v_13]; let __cu = unconstrained; if let Some(result) = record.function_queries[418].get_mut(&__args[..]) { if !__cu && *result.multiplicity == G::ZERO { aiur_fn_418(__args, record, io_buffer, false)? } else { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_418] = unsafe { *(result.output.as_ptr() as *const [G; OUT_418]) }; __ret } } else { aiur_fn_418(__args, record, io_buffer, __cu)? } }; + let __r_arr: [G; OUT_414] = { let __args: [G; IN_414] = [__v_0, __v_13]; let __cu = unconstrained; if let Some(result) = record.function_queries[414].get_mut(&__args[..]) { if !__cu && *result.multiplicity == G::ZERO { aiur_fn_414(__args, record, io_buffer, false)? } else { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_414] = unsafe { *(result.output.as_ptr() as *const [G; OUT_414]) }; __ret } } else { aiur_fn_414(__args, record, io_buffer, __cu)? } }; let __v_14: G = __r_arr[0]; let __loaded: [G; 4] = { let __mq = record.memory_queries.get_mut(&4).ok_or(ExecError::InvalidMemorySize(4))?; let __ptr_u64 = __v_14.as_canonical_u64(); let __ptr_usize = usize::try_from(__ptr_u64).ok().ok_or(ExecError::PointerTooLarge(__ptr_u64))?; let (__args, __mult) = __mq.get_index_mut(__ptr_usize).ok_or(ExecError::UnboundPointer { ptr: __ptr_u64, size: 4 })?; if !unconstrained { *__mult += G::ONE; } let __arr: [G; 4] = __args[..4].try_into().unwrap(); __arr }; let __v_15: G = __loaded[0]; @@ -57368,19 +57096,19 @@ fn aiur_fn_678( let __v_18: G = __loaded[3]; match __v_15.as_canonical_u64() { 5u64 => { - let __r_arr: [G; OUT_676] = { let __args: [G; IN_676] = [__v_6, __v_2, __v_3, __v_4, __v_5]; let __cu = unconstrained; if let Some(result) = record.function_queries[676].get_mut(&__args[..]) { if !__cu && *result.multiplicity == G::ZERO { aiur_fn_676(__args, record, io_buffer, false)? } else { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_676] = unsafe { *(result.output.as_ptr() as *const [G; OUT_676]) }; __ret } } else { aiur_fn_676(__args, record, io_buffer, __cu)? } }; + let __r_arr: [G; OUT_672] = { let __args: [G; IN_672] = [__v_6, __v_2, __v_3, __v_4, __v_5]; let __cu = unconstrained; if let Some(result) = record.function_queries[672].get_mut(&__args[..]) { if !__cu && *result.multiplicity == G::ZERO { aiur_fn_672(__args, record, io_buffer, false)? } else { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_672] = unsafe { *(result.output.as_ptr() as *const [G; OUT_672]) }; __ret } } else { aiur_fn_672(__args, record, io_buffer, __cu)? } }; let __v_19: G = __r_arr[0]; let __v_20: G = G::from_u64(0); - let __r_arr: [G; OUT_368] = { let __args: [G; IN_368] = [__v_17, __v_19, __v_20]; let __cu = unconstrained; if let Some(result) = record.function_queries[368].get_mut(&__args[..]) { if !__cu && *result.multiplicity == G::ZERO { aiur_fn_368(__args, record, io_buffer, false)? } else { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_368] = unsafe { *(result.output.as_ptr() as *const [G; OUT_368]) }; __ret } } else { aiur_fn_368(__args, record, io_buffer, __cu)? } }; + let __r_arr: [G; OUT_364] = { let __args: [G; IN_364] = [__v_17, __v_19, __v_20]; let __cu = unconstrained; if let Some(result) = record.function_queries[364].get_mut(&__args[..]) { if !__cu && *result.multiplicity == G::ZERO { aiur_fn_364(__args, record, io_buffer, false)? } else { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_364] = unsafe { *(result.output.as_ptr() as *const [G; OUT_364]) }; __ret } } else { aiur_fn_364(__args, record, io_buffer, __cu)? } }; let __v_21: G = __r_arr[0]; let __v_22: G = G::from_u64(1); let __v_23: G = (__v_1 - __v_22); let __v_24: G = G::from_u64(1); let __v_25: G = (__v_6 + __v_24); - let __r_arr: [G; OUT_678] = { let __args: [G; IN_678] = [__v_21, __v_23, __v_2, __v_3, __v_4, __v_5, __v_25]; let __cu = unconstrained; if let Some(result) = record.function_queries[678].get_mut(&__args[..]) { if !__cu && *result.multiplicity == G::ZERO { aiur_fn_678(__args, record, io_buffer, false)? } else { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_678] = unsafe { *(result.output.as_ptr() as *const [G; OUT_678]) }; __ret } } else { aiur_fn_678(__args, record, io_buffer, __cu)? } }; + let __r_arr: [G; OUT_674] = { let __args: [G; IN_674] = [__v_21, __v_23, __v_2, __v_3, __v_4, __v_5, __v_25]; let __cu = unconstrained; if let Some(result) = record.function_queries[674].get_mut(&__args[..]) { if !__cu && *result.multiplicity == G::ZERO { aiur_fn_674(__args, record, io_buffer, false)? } else { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_674] = unsafe { *(result.output.as_ptr() as *const [G; OUT_674]) }; __ret } } else { aiur_fn_674(__args, record, io_buffer, __cu)? } }; let __v_26: G = __r_arr[0]; - let __ret: [G; OUT_678] = [__v_26]; - if let Some(result) = record.function_queries[678].get_mut(&inp[..]) { debug_assert_eq!(result.output, &__ret[..]); if !unconstrained { *result.multiplicity += G::ONE; } } else { record.function_queries[678].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained)); }; + let __ret: [G; OUT_674] = [__v_26]; + if let Some(result) = record.function_queries[674].get_mut(&inp[..]) { debug_assert_eq!(result.output, &__ret[..]); if !unconstrained { *result.multiplicity += G::ONE; } } else { record.function_queries[674].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained)); }; return Ok(__ret); }, _ => { @@ -57394,15 +57122,15 @@ fn aiur_fn_678( }) } -const INPUT_SIZE_679: usize = 13; -const IN_679: usize = 13; -const OUT_679: usize = 1; -fn aiur_fn_679( - inp: [G; IN_679], +const INPUT_SIZE_675: usize = 13; +const IN_675: usize = 13; +const OUT_675: usize = 1; +fn aiur_fn_675( + inp: [G; IN_675], record: &mut QueryRecord, io_buffer: &mut IOBuffer, unconstrained: bool, -) -> Result<[G; OUT_679], ExecError> { +) -> Result<[G; OUT_675], ExecError> { stacker::maybe_grow(64 * 1024, 4 * 1024 * 1024, || { let __v_0: G = inp[0]; let __v_1: G = inp[1]; @@ -57417,13 +57145,13 @@ fn aiur_fn_679( let __v_10: G = inp[10]; let __v_11: G = inp[11]; let __v_12: G = inp[12]; - let __r_arr: [G; OUT_336] = { let __args: [G; IN_336] = [__v_1, __v_5]; let __cu = unconstrained; if let Some(result) = record.function_queries[336].get_mut(&__args[..]) { if !__cu && *result.multiplicity == G::ZERO { aiur_fn_336(__args, record, io_buffer, false)? } else { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_336] = unsafe { *(result.output.as_ptr() as *const [G; OUT_336]) }; __ret } } else { aiur_fn_336(__args, record, io_buffer, __cu)? } }; + let __r_arr: [G; OUT_332] = { let __args: [G; IN_332] = [__v_1, __v_5]; let __cu = unconstrained; if let Some(result) = record.function_queries[332].get_mut(&__args[..]) { if !__cu && *result.multiplicity == G::ZERO { aiur_fn_332(__args, record, io_buffer, false)? } else { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_332] = unsafe { *(result.output.as_ptr() as *const [G; OUT_332]) }; __ret } } else { aiur_fn_332(__args, record, io_buffer, __cu)? } }; let __v_13: G = __r_arr[0]; let __v_14: G = (__v_9 + __v_10); let __v_15: G = (__v_8 + __v_14); let __v_16: G = (__v_9 + __v_10); let __v_17: G = G::from_u64(0); - let __r_arr: [G; OUT_678] = { let __args: [G; IN_678] = [__v_13, __v_2, __v_15, __v_16, __v_3, __v_4, __v_17]; let __cu = unconstrained; if let Some(result) = record.function_queries[678].get_mut(&__args[..]) { if !__cu && *result.multiplicity == G::ZERO { aiur_fn_678(__args, record, io_buffer, false)? } else { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_678] = unsafe { *(result.output.as_ptr() as *const [G; OUT_678]) }; __ret } } else { aiur_fn_678(__args, record, io_buffer, __cu)? } }; + let __r_arr: [G; OUT_674] = { let __args: [G; IN_674] = [__v_13, __v_2, __v_15, __v_16, __v_3, __v_4, __v_17]; let __cu = unconstrained; if let Some(result) = record.function_queries[674].get_mut(&__args[..]) { if !__cu && *result.multiplicity == G::ZERO { aiur_fn_674(__args, record, io_buffer, false)? } else { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_674] = unsafe { *(result.output.as_ptr() as *const [G; OUT_674]) }; __ret } } else { aiur_fn_674(__args, record, io_buffer, __cu)? } }; let __v_18: G = __r_arr[0]; let __v_19: G = G::from_u64(1); let __v_20: G = G::from_u64(1); @@ -57435,24 +57163,24 @@ fn aiur_fn_679( let __v_26: G = G::from_u64(1); let __v_27: G = { let __values: [G; 3] = [__v_25, __v_26, __v_26]; let __mq = record.memory_queries.get_mut(&3).ok_or(ExecError::InvalidMemorySize(3))?; if let Some(result) = __mq.get_mut(&__values[..]) { if !unconstrained { *result.multiplicity += G::ONE; } result.output[0] } else { let __ptr = G::from_usize(__mq.len()); __mq.insert(&__values[..], &[__ptr], G::from_bool(!unconstrained)); __ptr } }; let __v_28: G = G::from_u64(0); - let __r_arr: [G; OUT_690] = { let __args: [G; IN_690] = [__v_18, __v_6, __v_21, __v_24, __v_27, __v_28, __v_16]; let __cu = unconstrained; if let Some(result) = record.function_queries[690].get_mut(&__args[..]) { if !__cu && *result.multiplicity == G::ZERO { aiur_fn_690(__args, record, io_buffer, false)? } else { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_690] = unsafe { *(result.output.as_ptr() as *const [G; OUT_690]) }; __ret } } else { aiur_fn_690(__args, record, io_buffer, __cu)? } }; + let __r_arr: [G; OUT_686] = { let __args: [G; IN_686] = [__v_18, __v_6, __v_21, __v_24, __v_27, __v_28, __v_16]; let __cu = unconstrained; if let Some(result) = record.function_queries[686].get_mut(&__args[..]) { if !__cu && *result.multiplicity == G::ZERO { aiur_fn_686(__args, record, io_buffer, false)? } else { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_686] = unsafe { *(result.output.as_ptr() as *const [G; OUT_686]) }; __ret } } else { aiur_fn_686(__args, record, io_buffer, __cu)? } }; let __v_29: G = __r_arr[0]; let __v_30: G = __r_arr[1]; let __v_31: G = __r_arr[2]; let __v_32: G = __r_arr[3]; - let __r_arr: [G; OUT_764] = { let __args: [G; IN_764] = [__v_29]; let __cu = unconstrained; if let Some(result) = record.function_queries[764].get_mut(&__args[..]) { if !__cu && *result.multiplicity == G::ZERO { aiur_fn_764(__args, record, io_buffer, false)? } else { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_764] = unsafe { *(result.output.as_ptr() as *const [G; OUT_764]) }; __ret } } else { aiur_fn_764(__args, record, io_buffer, __cu)? } }; + let __r_arr: [G; OUT_760] = { let __args: [G; IN_760] = [__v_29]; let __cu = unconstrained; if let Some(result) = record.function_queries[760].get_mut(&__args[..]) { if !__cu && *result.multiplicity == G::ZERO { aiur_fn_760(__args, record, io_buffer, false)? } else { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_760] = unsafe { *(result.output.as_ptr() as *const [G; OUT_760]) }; __ret } } else { aiur_fn_760(__args, record, io_buffer, __cu)? } }; let __v_33: G = __r_arr[0]; - let __r_arr: [G; OUT_764] = { let __args: [G; IN_764] = [__v_30]; let __cu = unconstrained; if let Some(result) = record.function_queries[764].get_mut(&__args[..]) { if !__cu && *result.multiplicity == G::ZERO { aiur_fn_764(__args, record, io_buffer, false)? } else { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_764] = unsafe { *(result.output.as_ptr() as *const [G; OUT_764]) }; __ret } } else { aiur_fn_764(__args, record, io_buffer, __cu)? } }; + let __r_arr: [G; OUT_760] = { let __args: [G; IN_760] = [__v_30]; let __cu = unconstrained; if let Some(result) = record.function_queries[760].get_mut(&__args[..]) { if !__cu && *result.multiplicity == G::ZERO { aiur_fn_760(__args, record, io_buffer, false)? } else { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_760] = unsafe { *(result.output.as_ptr() as *const [G; OUT_760]) }; __ret } } else { aiur_fn_760(__args, record, io_buffer, __cu)? } }; let __v_34: G = __r_arr[0]; let __v_35: G = (__v_33 + __v_34); let __v_36: G = (__v_15 + __v_35); let __r_arr: [G; OUT_111] = { let __args: [G; IN_111] = [__v_32]; let __cu = unconstrained; if let Some(result) = record.function_queries[111].get_mut(&__args[..]) { if !__cu && *result.multiplicity == G::ZERO { aiur_fn_111(__args, record, io_buffer, false)? } else { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_111] = unsafe { *(result.output.as_ptr() as *const [G; OUT_111]) }; __ret } } else { aiur_fn_111(__args, record, io_buffer, __cu)? } }; let __v_37: G = __r_arr[0]; let __v_38: G = __r_arr[1]; - let __r_arr: [G; OUT_775] = { let __args: [G; IN_775] = [__v_38, __v_2]; let __cu = unconstrained; if let Some(result) = record.function_queries[775].get_mut(&__args[..]) { if !__cu && *result.multiplicity == G::ZERO { aiur_fn_775(__args, record, io_buffer, false)? } else { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_775] = unsafe { *(result.output.as_ptr() as *const [G; OUT_775]) }; __ret } } else { aiur_fn_775(__args, record, io_buffer, __cu)? } }; + let __r_arr: [G; OUT_771] = { let __args: [G; IN_771] = [__v_38, __v_2]; let __cu = unconstrained; if let Some(result) = record.function_queries[771].get_mut(&__args[..]) { if !__cu && *result.multiplicity == G::ZERO { aiur_fn_771(__args, record, io_buffer, false)? } else { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_771] = unsafe { *(result.output.as_ptr() as *const [G; OUT_771]) }; __ret } } else { aiur_fn_771(__args, record, io_buffer, __cu)? } }; let __v_39: G = __r_arr[0]; let __v_40: G = G::from_u64(0); - let __r_arr: [G; OUT_683] = { let __args: [G; IN_683] = [__v_39, __v_34, __v_40]; let __cu = unconstrained; if let Some(result) = record.function_queries[683].get_mut(&__args[..]) { if !__cu && *result.multiplicity == G::ZERO { aiur_fn_683(__args, record, io_buffer, false)? } else { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_683] = unsafe { *(result.output.as_ptr() as *const [G; OUT_683]) }; __ret } } else { aiur_fn_683(__args, record, io_buffer, __cu)? } }; + let __r_arr: [G; OUT_679] = { let __args: [G; IN_679] = [__v_39, __v_34, __v_40]; let __cu = unconstrained; if let Some(result) = record.function_queries[679].get_mut(&__args[..]) { if !__cu && *result.multiplicity == G::ZERO { aiur_fn_679(__args, record, io_buffer, false)? } else { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_679] = unsafe { *(result.output.as_ptr() as *const [G; OUT_679]) }; __ret } } else { aiur_fn_679(__args, record, io_buffer, __cu)? } }; let __v_41: G = __r_arr[0]; let __v_42: G = G::from_u64(1); let __v_43: G = (__v_36 - __v_42); @@ -57461,66 +57189,66 @@ fn aiur_fn_679( let __v_46: G = G::from_u64(0); let __v_47: G = G::from_u64(0); let __v_48: G = { let __values: [G; 4] = [__v_46, __v_45, __v_47, __v_47]; let __mq = record.memory_queries.get_mut(&4).ok_or(ExecError::InvalidMemorySize(4))?; if let Some(result) = __mq.get_mut(&__values[..]) { if !unconstrained { *result.multiplicity += G::ONE; } result.output[0] } else { let __ptr = G::from_usize(__mq.len()); __mq.insert(&__values[..], &[__ptr], G::from_bool(!unconstrained)); __ptr } }; - let __r_arr: [G; OUT_255] = { let __args: [G; IN_255] = [__v_48, __v_41]; let __cu = unconstrained; if let Some(result) = record.function_queries[255].get_mut(&__args[..]) { if !__cu && *result.multiplicity == G::ZERO { aiur_fn_255(__args, record, io_buffer, false)? } else { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_255] = unsafe { *(result.output.as_ptr() as *const [G; OUT_255]) }; __ret } } else { aiur_fn_255(__args, record, io_buffer, __cu)? } }; + let __r_arr: [G; OUT_251] = { let __args: [G; IN_251] = [__v_48, __v_41]; let __cu = unconstrained; if let Some(result) = record.function_queries[251].get_mut(&__args[..]) { if !__cu && *result.multiplicity == G::ZERO { aiur_fn_251(__args, record, io_buffer, false)? } else { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_251] = unsafe { *(result.output.as_ptr() as *const [G; OUT_251]) }; __ret } } else { aiur_fn_251(__args, record, io_buffer, __cu)? } }; let __v_49: G = __r_arr[0]; let __v_50: G = G::from_u64(2); let __v_51: G = G::from_u64(0); let __v_52: G = { let __values: [G; 4] = [__v_50, __v_0, __v_5, __v_51]; let __mq = record.memory_queries.get_mut(&4).ok_or(ExecError::InvalidMemorySize(4))?; if let Some(result) = __mq.get_mut(&__values[..]) { if !unconstrained { *result.multiplicity += G::ONE; } result.output[0] } else { let __ptr = G::from_usize(__mq.len()); __mq.insert(&__values[..], &[__ptr], G::from_bool(!unconstrained)); __ptr } }; - let __r_arr: [G; OUT_685] = { let __args: [G; IN_685] = [__v_52, __v_2, __v_8, __v_36, __v_3, __v_4]; let __cu = unconstrained; if let Some(result) = record.function_queries[685].get_mut(&__args[..]) { if !__cu && *result.multiplicity == G::ZERO { aiur_fn_685(__args, record, io_buffer, false)? } else { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_685] = unsafe { *(result.output.as_ptr() as *const [G; OUT_685]) }; __ret } } else { aiur_fn_685(__args, record, io_buffer, __cu)? } }; + let __r_arr: [G; OUT_681] = { let __args: [G; IN_681] = [__v_52, __v_2, __v_8, __v_36, __v_3, __v_4]; let __cu = unconstrained; if let Some(result) = record.function_queries[681].get_mut(&__args[..]) { if !__cu && *result.multiplicity == G::ZERO { aiur_fn_681(__args, record, io_buffer, false)? } else { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_681] = unsafe { *(result.output.as_ptr() as *const [G; OUT_681]) }; __ret } } else { aiur_fn_681(__args, record, io_buffer, __cu)? } }; let __v_53: G = __r_arr[0]; let __v_54: G = G::from_u64(0); - let __r_arr: [G; OUT_684] = { let __args: [G; IN_684] = [__v_53, __v_33, __v_35, __v_54]; let __cu = unconstrained; if let Some(result) = record.function_queries[684].get_mut(&__args[..]) { if !__cu && *result.multiplicity == G::ZERO { aiur_fn_684(__args, record, io_buffer, false)? } else { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_684] = unsafe { *(result.output.as_ptr() as *const [G; OUT_684]) }; __ret } } else { aiur_fn_684(__args, record, io_buffer, __cu)? } }; + let __r_arr: [G; OUT_680] = { let __args: [G; IN_680] = [__v_53, __v_33, __v_35, __v_54]; let __cu = unconstrained; if let Some(result) = record.function_queries[680].get_mut(&__args[..]) { if !__cu && *result.multiplicity == G::ZERO { aiur_fn_680(__args, record, io_buffer, false)? } else { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_680] = unsafe { *(result.output.as_ptr() as *const [G; OUT_680]) }; __ret } } else { aiur_fn_680(__args, record, io_buffer, __cu)? } }; let __v_55: G = __r_arr[0]; let __v_56: G = G::from_u64(3); let __v_57: G = G::from_u64(0); let __v_58: G = { let __values: [G; 4] = [__v_56, __v_49, __v_55, __v_57]; let __mq = record.memory_queries.get_mut(&4).ok_or(ExecError::InvalidMemorySize(4))?; if let Some(result) = __mq.get_mut(&__values[..]) { if !unconstrained { *result.multiplicity += G::ONE; } result.output[0] } else { let __ptr = G::from_usize(__mq.len()); __mq.insert(&__values[..], &[__ptr], G::from_bool(!unconstrained)); __ptr } }; let __v_59: G = G::from_u64(0); - let __r_arr: [G; OUT_682] = { let __args: [G; IN_682] = [__v_30, __v_31, __v_29, __v_7, __v_11, __v_33, __v_15, __v_59]; let __cu = unconstrained; if let Some(result) = record.function_queries[682].get_mut(&__args[..]) { if !__cu && *result.multiplicity == G::ZERO { aiur_fn_682(__args, record, io_buffer, false)? } else { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_682] = unsafe { *(result.output.as_ptr() as *const [G; OUT_682]) }; __ret } } else { aiur_fn_682(__args, record, io_buffer, __cu)? } }; + let __r_arr: [G; OUT_678] = { let __args: [G; IN_678] = [__v_30, __v_31, __v_29, __v_7, __v_11, __v_33, __v_15, __v_59]; let __cu = unconstrained; if let Some(result) = record.function_queries[678].get_mut(&__args[..]) { if !__cu && *result.multiplicity == G::ZERO { aiur_fn_678(__args, record, io_buffer, false)? } else { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_678] = unsafe { *(result.output.as_ptr() as *const [G; OUT_678]) }; __ret } } else { aiur_fn_678(__args, record, io_buffer, __cu)? } }; let __v_60: G = __r_arr[0]; - let __r_arr: [G; OUT_650] = { let __args: [G; IN_650] = [__v_58, __v_60]; let __cu = unconstrained; if let Some(result) = record.function_queries[650].get_mut(&__args[..]) { if !__cu && *result.multiplicity == G::ZERO { aiur_fn_650(__args, record, io_buffer, false)? } else { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_650] = unsafe { *(result.output.as_ptr() as *const [G; OUT_650]) }; __ret } } else { aiur_fn_650(__args, record, io_buffer, __cu)? } }; + let __r_arr: [G; OUT_646] = { let __args: [G; IN_646] = [__v_58, __v_60]; let __cu = unconstrained; if let Some(result) = record.function_queries[646].get_mut(&__args[..]) { if !__cu && *result.multiplicity == G::ZERO { aiur_fn_646(__args, record, io_buffer, false)? } else { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_646] = unsafe { *(result.output.as_ptr() as *const [G; OUT_646]) }; __ret } } else { aiur_fn_646(__args, record, io_buffer, __cu)? } }; let __v_61: G = __r_arr[0]; - let __r_arr: [G; OUT_650] = { let __args: [G; IN_650] = [__v_61, __v_29]; let __cu = unconstrained; if let Some(result) = record.function_queries[650].get_mut(&__args[..]) { if !__cu && *result.multiplicity == G::ZERO { aiur_fn_650(__args, record, io_buffer, false)? } else { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_650] = unsafe { *(result.output.as_ptr() as *const [G; OUT_650]) }; __ret } } else { aiur_fn_650(__args, record, io_buffer, __cu)? } }; + let __r_arr: [G; OUT_646] = { let __args: [G; IN_646] = [__v_61, __v_29]; let __cu = unconstrained; if let Some(result) = record.function_queries[646].get_mut(&__args[..]) { if !__cu && *result.multiplicity == G::ZERO { aiur_fn_646(__args, record, io_buffer, false)? } else { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_646] = unsafe { *(result.output.as_ptr() as *const [G; OUT_646]) }; __ret } } else { aiur_fn_646(__args, record, io_buffer, __cu)? } }; let __v_62: G = __r_arr[0]; - let __ret: [G; OUT_679] = [__v_62]; - if let Some(result) = record.function_queries[679].get_mut(&inp[..]) { debug_assert_eq!(result.output, &__ret[..]); if !unconstrained { *result.multiplicity += G::ONE; } } else { record.function_queries[679].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained)); }; + let __ret: [G; OUT_675] = [__v_62]; + if let Some(result) = record.function_queries[675].get_mut(&inp[..]) { debug_assert_eq!(result.output, &__ret[..]); if !unconstrained { *result.multiplicity += G::ONE; } } else { record.function_queries[675].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained)); }; return Ok(__ret); }) } -const INPUT_SIZE_680: usize = 1; -const IN_680: usize = 1; -const OUT_680: usize = 2; -fn aiur_fn_680( - inp: [G; IN_680], +const INPUT_SIZE_676: usize = 1; +const IN_676: usize = 1; +const OUT_676: usize = 2; +fn aiur_fn_676( + inp: [G; IN_676], record: &mut QueryRecord, io_buffer: &mut IOBuffer, unconstrained: bool, -) -> Result<[G; OUT_680], ExecError> { +) -> Result<[G; OUT_676], ExecError> { stacker::maybe_grow(64 * 1024, 4 * 1024 * 1024, || { let __v_0: G = inp[0]; let __v_1: G = G::from_u64(1); let __v_2: G = G::from_u64(1); let __v_3: G = { let __values: [G; 3] = [__v_1, __v_2, __v_2]; let __mq = record.memory_queries.get_mut(&3).ok_or(ExecError::InvalidMemorySize(3))?; if let Some(result) = __mq.get_mut(&__values[..]) { if !unconstrained { *result.multiplicity += G::ONE; } result.output[0] } else { let __ptr = G::from_usize(__mq.len()); __mq.insert(&__values[..], &[__ptr], G::from_bool(!unconstrained)); __ptr } }; - let __r_arr: [G; OUT_681] = { let __args: [G; IN_681] = [__v_0, __v_3]; let __cu = unconstrained; if let Some(result) = record.function_queries[681].get_mut(&__args[..]) { if !__cu && *result.multiplicity == G::ZERO { aiur_fn_681(__args, record, io_buffer, false)? } else { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_681] = unsafe { *(result.output.as_ptr() as *const [G; OUT_681]) }; __ret } } else { aiur_fn_681(__args, record, io_buffer, __cu)? } }; + let __r_arr: [G; OUT_677] = { let __args: [G; IN_677] = [__v_0, __v_3]; let __cu = unconstrained; if let Some(result) = record.function_queries[677].get_mut(&__args[..]) { if !__cu && *result.multiplicity == G::ZERO { aiur_fn_677(__args, record, io_buffer, false)? } else { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_677] = unsafe { *(result.output.as_ptr() as *const [G; OUT_677]) }; __ret } } else { aiur_fn_677(__args, record, io_buffer, __cu)? } }; let __v_4: G = __r_arr[0]; let __v_5: G = __r_arr[1]; - let __r_arr: [G; OUT_762] = { let __args: [G; IN_762] = [__v_4]; let __cu = unconstrained; if let Some(result) = record.function_queries[762].get_mut(&__args[..]) { if !__cu && *result.multiplicity == G::ZERO { aiur_fn_762(__args, record, io_buffer, false)? } else { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_762] = unsafe { *(result.output.as_ptr() as *const [G; OUT_762]) }; __ret } } else { aiur_fn_762(__args, record, io_buffer, __cu)? } }; + let __r_arr: [G; OUT_758] = { let __args: [G; IN_758] = [__v_4]; let __cu = unconstrained; if let Some(result) = record.function_queries[758].get_mut(&__args[..]) { if !__cu && *result.multiplicity == G::ZERO { aiur_fn_758(__args, record, io_buffer, false)? } else { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_758] = unsafe { *(result.output.as_ptr() as *const [G; OUT_758]) }; __ret } } else { aiur_fn_758(__args, record, io_buffer, __cu)? } }; let __v_6: G = __r_arr[0]; - let __ret: [G; OUT_680] = [__v_6, __v_5]; - if let Some(result) = record.function_queries[680].get_mut(&inp[..]) { debug_assert_eq!(result.output, &__ret[..]); if !unconstrained { *result.multiplicity += G::ONE; } } else { record.function_queries[680].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained)); }; + let __ret: [G; OUT_676] = [__v_6, __v_5]; + if let Some(result) = record.function_queries[676].get_mut(&inp[..]) { debug_assert_eq!(result.output, &__ret[..]); if !unconstrained { *result.multiplicity += G::ONE; } } else { record.function_queries[676].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained)); }; return Ok(__ret); }) } -const INPUT_SIZE_681: usize = 2; -const IN_681: usize = 2; -const OUT_681: usize = 2; -fn aiur_fn_681( - inp: [G; IN_681], +const INPUT_SIZE_677: usize = 2; +const IN_677: usize = 2; +const OUT_677: usize = 2; +fn aiur_fn_677( + inp: [G; IN_677], record: &mut QueryRecord, io_buffer: &mut IOBuffer, unconstrained: bool, -) -> Result<[G; OUT_681], ExecError> { +) -> Result<[G; OUT_677], ExecError> { stacker::maybe_grow(64 * 1024, 4 * 1024 * 1024, || { let __v_0: G = inp[0]; let __v_1: G = inp[1]; @@ -57533,31 +57261,31 @@ fn aiur_fn_681( 5u64 => { let __v_6: G = G::from_u64(0); let __v_7: G = { let __values: [G; 3] = [__v_6, __v_3, __v_1]; let __mq = record.memory_queries.get_mut(&3).ok_or(ExecError::InvalidMemorySize(3))?; if let Some(result) = __mq.get_mut(&__values[..]) { if !unconstrained { *result.multiplicity += G::ONE; } result.output[0] } else { let __ptr = G::from_usize(__mq.len()); __mq.insert(&__values[..], &[__ptr], G::from_bool(!unconstrained)); __ptr } }; - let __r_arr: [G; OUT_681] = { let __args: [G; IN_681] = [__v_4, __v_7]; let __cu = unconstrained; if let Some(result) = record.function_queries[681].get_mut(&__args[..]) { if !__cu && *result.multiplicity == G::ZERO { aiur_fn_681(__args, record, io_buffer, false)? } else { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_681] = unsafe { *(result.output.as_ptr() as *const [G; OUT_681]) }; __ret } } else { aiur_fn_681(__args, record, io_buffer, __cu)? } }; + let __r_arr: [G; OUT_677] = { let __args: [G; IN_677] = [__v_4, __v_7]; let __cu = unconstrained; if let Some(result) = record.function_queries[677].get_mut(&__args[..]) { if !__cu && *result.multiplicity == G::ZERO { aiur_fn_677(__args, record, io_buffer, false)? } else { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_677] = unsafe { *(result.output.as_ptr() as *const [G; OUT_677]) }; __ret } } else { aiur_fn_677(__args, record, io_buffer, __cu)? } }; let __v_8: G = __r_arr[0]; let __v_9: G = __r_arr[1]; - let __ret: [G; OUT_681] = [__v_8, __v_9]; - if let Some(result) = record.function_queries[681].get_mut(&inp[..]) { debug_assert_eq!(result.output, &__ret[..]); if !unconstrained { *result.multiplicity += G::ONE; } } else { record.function_queries[681].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained)); }; + let __ret: [G; OUT_677] = [__v_8, __v_9]; + if let Some(result) = record.function_queries[677].get_mut(&inp[..]) { debug_assert_eq!(result.output, &__ret[..]); if !unconstrained { *result.multiplicity += G::ONE; } } else { record.function_queries[677].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained)); }; return Ok(__ret); }, _ => { - let __ret: [G; OUT_681] = [__v_1, __v_0]; - if let Some(result) = record.function_queries[681].get_mut(&inp[..]) { debug_assert_eq!(result.output, &__ret[..]); if !unconstrained { *result.multiplicity += G::ONE; } } else { record.function_queries[681].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained)); }; + let __ret: [G; OUT_677] = [__v_1, __v_0]; + if let Some(result) = record.function_queries[677].get_mut(&inp[..]) { debug_assert_eq!(result.output, &__ret[..]); if !unconstrained { *result.multiplicity += G::ONE; } } else { record.function_queries[677].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained)); }; return Ok(__ret); }, } }) } -const INPUT_SIZE_682: usize = 8; -const IN_682: usize = 8; -const OUT_682: usize = 1; -fn aiur_fn_682( - inp: [G; IN_682], +const INPUT_SIZE_678: usize = 8; +const IN_678: usize = 8; +const OUT_678: usize = 1; +fn aiur_fn_678( + inp: [G; IN_678], record: &mut QueryRecord, io_buffer: &mut IOBuffer, unconstrained: bool, -) -> Result<[G; OUT_682], ExecError> { +) -> Result<[G; OUT_678], ExecError> { stacker::maybe_grow(64 * 1024, 4 * 1024 * 1024, || { let __v_0: G = inp[0]; let __v_1: G = inp[1]; @@ -57576,30 +57304,30 @@ fn aiur_fn_682( let __v_11: G = G::from_u64(1); let __v_12: G = G::from_u64(1); let __v_13: G = { let __values: [G; 3] = [__v_11, __v_12, __v_12]; let __mq = record.memory_queries.get_mut(&3).ok_or(ExecError::InvalidMemorySize(3))?; if let Some(result) = __mq.get_mut(&__values[..]) { if !unconstrained { *result.multiplicity += G::ONE; } result.output[0] } else { let __ptr = G::from_usize(__mq.len()); __mq.insert(&__values[..], &[__ptr], G::from_bool(!unconstrained)); __ptr } }; - let __ret: [G; OUT_682] = [__v_13]; - if let Some(result) = record.function_queries[682].get_mut(&inp[..]) { debug_assert_eq!(result.output, &__ret[..]); if !unconstrained { *result.multiplicity += G::ONE; } } else { record.function_queries[682].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained)); }; + let __ret: [G; OUT_678] = [__v_13]; + if let Some(result) = record.function_queries[678].get_mut(&inp[..]) { debug_assert_eq!(result.output, &__ret[..]); if !unconstrained { *result.multiplicity += G::ONE; } } else { record.function_queries[678].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained)); }; return Ok(__ret); }, 0u64 => { let __v_11: G = G::from_u64(0); - let __r_arr: [G; OUT_756] = { let __args: [G; IN_756] = [__v_1, __v_7, __v_11]; let __cu = unconstrained; if let Some(result) = record.function_queries[756].get_mut(&__args[..]) { if !__cu && *result.multiplicity == G::ZERO { aiur_fn_756(__args, record, io_buffer, false)? } else { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_756] = unsafe { *(result.output.as_ptr() as *const [G; OUT_756]) }; __ret } } else { aiur_fn_756(__args, record, io_buffer, __cu)? } }; + let __r_arr: [G; OUT_752] = { let __args: [G; IN_752] = [__v_1, __v_7, __v_11]; let __cu = unconstrained; if let Some(result) = record.function_queries[752].get_mut(&__args[..]) { if !__cu && *result.multiplicity == G::ZERO { aiur_fn_752(__args, record, io_buffer, false)? } else { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_752] = unsafe { *(result.output.as_ptr() as *const [G; OUT_752]) }; __ret } } else { aiur_fn_752(__args, record, io_buffer, __cu)? } }; let __v_12: G = __r_arr[0]; let __v_13: G = G::from_u64(0); - let __r_arr: [G; OUT_756] = { let __args: [G; IN_756] = [__v_3, __v_12, __v_13]; let __cu = unconstrained; if let Some(result) = record.function_queries[756].get_mut(&__args[..]) { if !__cu && *result.multiplicity == G::ZERO { aiur_fn_756(__args, record, io_buffer, false)? } else { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_756] = unsafe { *(result.output.as_ptr() as *const [G; OUT_756]) }; __ret } } else { aiur_fn_756(__args, record, io_buffer, __cu)? } }; + let __r_arr: [G; OUT_752] = { let __args: [G; IN_752] = [__v_3, __v_12, __v_13]; let __cu = unconstrained; if let Some(result) = record.function_queries[752].get_mut(&__args[..]) { if !__cu && *result.multiplicity == G::ZERO { aiur_fn_752(__args, record, io_buffer, false)? } else { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_752] = unsafe { *(result.output.as_ptr() as *const [G; OUT_752]) }; __ret } } else { aiur_fn_752(__args, record, io_buffer, __cu)? } }; let __v_14: G = __r_arr[0]; let __v_15: G = (__v_5 + __v_7); let __v_16: G = (__v_6 + __v_15); - let __r_arr: [G; OUT_766] = { let __args: [G; IN_766] = [__v_2, __v_9]; let __cu = unconstrained; if let Some(result) = record.function_queries[766].get_mut(&__args[..]) { if !__cu && *result.multiplicity == G::ZERO { aiur_fn_766(__args, record, io_buffer, false)? } else { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_766] = unsafe { *(result.output.as_ptr() as *const [G; OUT_766]) }; __ret } } else { aiur_fn_766(__args, record, io_buffer, __cu)? } }; + let __r_arr: [G; OUT_762] = { let __args: [G; IN_762] = [__v_2, __v_9]; let __cu = unconstrained; if let Some(result) = record.function_queries[762].get_mut(&__args[..]) { if !__cu && *result.multiplicity == G::ZERO { aiur_fn_762(__args, record, io_buffer, false)? } else { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_762] = unsafe { *(result.output.as_ptr() as *const [G; OUT_762]) }; __ret } } else { aiur_fn_762(__args, record, io_buffer, __cu)? } }; let __v_17: G = __r_arr[0]; let __v_18: G = (__v_5 - __v_9); let __v_19: G = (__v_18 + __v_7); let __v_20: G = G::from_u64(0); - let __r_arr: [G; OUT_359] = { let __args: [G; IN_359] = [__v_17, __v_19, __v_20]; let __cu = unconstrained; if let Some(result) = record.function_queries[359].get_mut(&__args[..]) { if !__cu && *result.multiplicity == G::ZERO { aiur_fn_359(__args, record, io_buffer, false)? } else { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_359] = unsafe { *(result.output.as_ptr() as *const [G; OUT_359]) }; __ret } } else { aiur_fn_359(__args, record, io_buffer, __cu)? } }; + let __r_arr: [G; OUT_355] = { let __args: [G; IN_355] = [__v_17, __v_19, __v_20]; let __cu = unconstrained; if let Some(result) = record.function_queries[355].get_mut(&__args[..]) { if !__cu && *result.multiplicity == G::ZERO { aiur_fn_355(__args, record, io_buffer, false)? } else { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_355] = unsafe { *(result.output.as_ptr() as *const [G; OUT_355]) }; __ret } } else { aiur_fn_355(__args, record, io_buffer, __cu)? } }; let __v_21: G = __r_arr[0]; - let __r_arr: [G; OUT_680] = { let __args: [G; IN_680] = [__v_21]; let __cu = unconstrained; if let Some(result) = record.function_queries[680].get_mut(&__args[..]) { if !__cu && *result.multiplicity == G::ZERO { aiur_fn_680(__args, record, io_buffer, false)? } else { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_680] = unsafe { *(result.output.as_ptr() as *const [G; OUT_680]) }; __ret } } else { aiur_fn_680(__args, record, io_buffer, __cu)? } }; + let __r_arr: [G; OUT_676] = { let __args: [G; IN_676] = [__v_21]; let __cu = unconstrained; if let Some(result) = record.function_queries[676].get_mut(&__args[..]) { if !__cu && *result.multiplicity == G::ZERO { aiur_fn_676(__args, record, io_buffer, false)? } else { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_676] = unsafe { *(result.output.as_ptr() as *const [G; OUT_676]) }; __ret } } else { aiur_fn_676(__args, record, io_buffer, __cu)? } }; let __v_22: G = __r_arr[0]; let __v_23: G = __r_arr[1]; - let __r_arr: [G; OUT_764] = { let __args: [G; IN_764] = [__v_22]; let __cu = unconstrained; if let Some(result) = record.function_queries[764].get_mut(&__args[..]) { if !__cu && *result.multiplicity == G::ZERO { aiur_fn_764(__args, record, io_buffer, false)? } else { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_764] = unsafe { *(result.output.as_ptr() as *const [G; OUT_764]) }; __ret } } else { aiur_fn_764(__args, record, io_buffer, __cu)? } }; + let __r_arr: [G; OUT_760] = { let __args: [G; IN_760] = [__v_22]; let __cu = unconstrained; if let Some(result) = record.function_queries[760].get_mut(&__args[..]) { if !__cu && *result.multiplicity == G::ZERO { aiur_fn_760(__args, record, io_buffer, false)? } else { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_760] = unsafe { *(result.output.as_ptr() as *const [G; OUT_760]) }; __ret } } else { aiur_fn_760(__args, record, io_buffer, __cu)? } }; let __v_24: G = __r_arr[0]; let __v_25: G = (__v_16 + __v_24); let __v_26: G = G::from_u64(1); @@ -57613,37 +57341,37 @@ fn aiur_fn_682( let __v_34: G = G::from_u64(1); let __v_35: G = G::from_u64(1); let __v_36: G = { let __values: [G; 3] = [__v_34, __v_35, __v_35]; let __mq = record.memory_queries.get_mut(&3).ok_or(ExecError::InvalidMemorySize(3))?; if let Some(result) = __mq.get_mut(&__values[..]) { if !unconstrained { *result.multiplicity += G::ONE; } result.output[0] } else { let __ptr = G::from_usize(__mq.len()); __mq.insert(&__values[..], &[__ptr], G::from_bool(!unconstrained)); __ptr } }; - let __r_arr: [G; OUT_418] = { let __args: [G; IN_418] = [__v_23, __v_36]; let __cu = unconstrained; if let Some(result) = record.function_queries[418].get_mut(&__args[..]) { if !__cu && *result.multiplicity == G::ZERO { aiur_fn_418(__args, record, io_buffer, false)? } else { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_418] = unsafe { *(result.output.as_ptr() as *const [G; OUT_418]) }; __ret } } else { aiur_fn_418(__args, record, io_buffer, __cu)? } }; + let __r_arr: [G; OUT_414] = { let __args: [G; IN_414] = [__v_23, __v_36]; let __cu = unconstrained; if let Some(result) = record.function_queries[414].get_mut(&__args[..]) { if !__cu && *result.multiplicity == G::ZERO { aiur_fn_414(__args, record, io_buffer, false)? } else { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_414] = unsafe { *(result.output.as_ptr() as *const [G; OUT_414]) }; __ret } } else { aiur_fn_414(__args, record, io_buffer, __cu)? } }; let __v_37: G = __r_arr[0]; let __r_arr: [G; OUT_111] = { let __args: [G; IN_111] = [__v_37]; let __cu = unconstrained; if let Some(result) = record.function_queries[111].get_mut(&__args[..]) { if !__cu && *result.multiplicity == G::ZERO { aiur_fn_111(__args, record, io_buffer, false)? } else { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_111] = unsafe { *(result.output.as_ptr() as *const [G; OUT_111]) }; __ret } } else { aiur_fn_111(__args, record, io_buffer, __cu)? } }; let __v_38: G = __r_arr[0]; let __v_39: G = __r_arr[1]; - let __r_arr: [G; OUT_775] = { let __args: [G; IN_775] = [__v_39, __v_14]; let __cu = unconstrained; if let Some(result) = record.function_queries[775].get_mut(&__args[..]) { if !__cu && *result.multiplicity == G::ZERO { aiur_fn_775(__args, record, io_buffer, false)? } else { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_775] = unsafe { *(result.output.as_ptr() as *const [G; OUT_775]) }; __ret } } else { aiur_fn_775(__args, record, io_buffer, __cu)? } }; + let __r_arr: [G; OUT_771] = { let __args: [G; IN_771] = [__v_39, __v_14]; let __cu = unconstrained; if let Some(result) = record.function_queries[771].get_mut(&__args[..]) { if !__cu && *result.multiplicity == G::ZERO { aiur_fn_771(__args, record, io_buffer, false)? } else { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_771] = unsafe { *(result.output.as_ptr() as *const [G; OUT_771]) }; __ret } } else { aiur_fn_771(__args, record, io_buffer, __cu)? } }; let __v_40: G = __r_arr[0]; let __v_41: G = G::from_u64(0); let __v_42: G = G::from_u64(0); let __v_43: G = { let __values: [G; 4] = [__v_41, __v_29, __v_42, __v_42]; let __mq = record.memory_queries.get_mut(&4).ok_or(ExecError::InvalidMemorySize(4))?; if let Some(result) = __mq.get_mut(&__values[..]) { if !unconstrained { *result.multiplicity += G::ONE; } result.output[0] } else { let __ptr = G::from_usize(__mq.len()); __mq.insert(&__values[..], &[__ptr], G::from_bool(!unconstrained)); __ptr } }; - let __r_arr: [G; OUT_255] = { let __args: [G; IN_255] = [__v_43, __v_40]; let __cu = unconstrained; if let Some(result) = record.function_queries[255].get_mut(&__args[..]) { if !__cu && *result.multiplicity == G::ZERO { aiur_fn_255(__args, record, io_buffer, false)? } else { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_255] = unsafe { *(result.output.as_ptr() as *const [G; OUT_255]) }; __ret } } else { aiur_fn_255(__args, record, io_buffer, __cu)? } }; + let __r_arr: [G; OUT_251] = { let __args: [G; IN_251] = [__v_43, __v_40]; let __cu = unconstrained; if let Some(result) = record.function_queries[251].get_mut(&__args[..]) { if !__cu && *result.multiplicity == G::ZERO { aiur_fn_251(__args, record, io_buffer, false)? } else { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_251] = unsafe { *(result.output.as_ptr() as *const [G; OUT_251]) }; __ret } } else { aiur_fn_251(__args, record, io_buffer, __cu)? } }; let __v_44: G = __r_arr[0]; let __v_45: G = G::from_u64(0); let __v_46: G = G::from_u64(0); let __v_47: G = { let __values: [G; 4] = [__v_45, __v_33, __v_46, __v_46]; let __mq = record.memory_queries.get_mut(&4).ok_or(ExecError::InvalidMemorySize(4))?; if let Some(result) = __mq.get_mut(&__values[..]) { if !unconstrained { *result.multiplicity += G::ONE; } result.output[0] } else { let __ptr = G::from_usize(__mq.len()); __mq.insert(&__values[..], &[__ptr], G::from_bool(!unconstrained)); __ptr } }; let __v_48: G = G::from_u64(0); - let __r_arr: [G; OUT_649] = { let __args: [G; IN_649] = [__v_47, __v_24, __v_48]; let __cu = unconstrained; if let Some(result) = record.function_queries[649].get_mut(&__args[..]) { if !__cu && *result.multiplicity == G::ZERO { aiur_fn_649(__args, record, io_buffer, false)? } else { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_649] = unsafe { *(result.output.as_ptr() as *const [G; OUT_649]) }; __ret } } else { aiur_fn_649(__args, record, io_buffer, __cu)? } }; + let __r_arr: [G; OUT_645] = { let __args: [G; IN_645] = [__v_47, __v_24, __v_48]; let __cu = unconstrained; if let Some(result) = record.function_queries[645].get_mut(&__args[..]) { if !__cu && *result.multiplicity == G::ZERO { aiur_fn_645(__args, record, io_buffer, false)? } else { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_645] = unsafe { *(result.output.as_ptr() as *const [G; OUT_645]) }; __ret } } else { aiur_fn_645(__args, record, io_buffer, __cu)? } }; let __v_49: G = __r_arr[0]; let __v_50: G = G::from_u64(3); let __v_51: G = G::from_u64(0); let __v_52: G = { let __values: [G; 4] = [__v_50, __v_44, __v_49, __v_51]; let __mq = record.memory_queries.get_mut(&4).ok_or(ExecError::InvalidMemorySize(4))?; if let Some(result) = __mq.get_mut(&__values[..]) { if !unconstrained { *result.multiplicity += G::ONE; } result.output[0] } else { let __ptr = G::from_usize(__mq.len()); __mq.insert(&__values[..], &[__ptr], G::from_bool(!unconstrained)); __ptr } }; - let __r_arr: [G; OUT_650] = { let __args: [G; IN_650] = [__v_52, __v_22]; let __cu = unconstrained; if let Some(result) = record.function_queries[650].get_mut(&__args[..]) { if !__cu && *result.multiplicity == G::ZERO { aiur_fn_650(__args, record, io_buffer, false)? } else { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_650] = unsafe { *(result.output.as_ptr() as *const [G; OUT_650]) }; __ret } } else { aiur_fn_650(__args, record, io_buffer, __cu)? } }; + let __r_arr: [G; OUT_646] = { let __args: [G; IN_646] = [__v_52, __v_22]; let __cu = unconstrained; if let Some(result) = record.function_queries[646].get_mut(&__args[..]) { if !__cu && *result.multiplicity == G::ZERO { aiur_fn_646(__args, record, io_buffer, false)? } else { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_646] = unsafe { *(result.output.as_ptr() as *const [G; OUT_646]) }; __ret } } else { aiur_fn_646(__args, record, io_buffer, __cu)? } }; let __v_53: G = __r_arr[0]; let __v_54: G = G::from_u64(0); let __v_55: G = G::from_u64(1); let __v_56: G = (__v_7 + __v_55); - let __r_arr: [G; OUT_682] = { let __args: [G; IN_682] = [__v_10, __v_1, __v_2, __v_3, __v_4, __v_5, __v_6, __v_56]; let __cu = unconstrained; if let Some(result) = record.function_queries[682].get_mut(&__args[..]) { if !__cu && *result.multiplicity == G::ZERO { aiur_fn_682(__args, record, io_buffer, false)? } else { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_682] = unsafe { *(result.output.as_ptr() as *const [G; OUT_682]) }; __ret } } else { aiur_fn_682(__args, record, io_buffer, __cu)? } }; + let __r_arr: [G; OUT_678] = { let __args: [G; IN_678] = [__v_10, __v_1, __v_2, __v_3, __v_4, __v_5, __v_6, __v_56]; let __cu = unconstrained; if let Some(result) = record.function_queries[678].get_mut(&__args[..]) { if !__cu && *result.multiplicity == G::ZERO { aiur_fn_678(__args, record, io_buffer, false)? } else { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_678] = unsafe { *(result.output.as_ptr() as *const [G; OUT_678]) }; __ret } } else { aiur_fn_678(__args, record, io_buffer, __cu)? } }; let __v_57: G = __r_arr[0]; let __v_58: G = { let __values: [G; 3] = [__v_54, __v_53, __v_57]; let __mq = record.memory_queries.get_mut(&3).ok_or(ExecError::InvalidMemorySize(3))?; if let Some(result) = __mq.get_mut(&__values[..]) { if !unconstrained { *result.multiplicity += G::ONE; } result.output[0] } else { let __ptr = G::from_usize(__mq.len()); __mq.insert(&__values[..], &[__ptr], G::from_bool(!unconstrained)); __ptr } }; - let __ret: [G; OUT_682] = [__v_58]; - if let Some(result) = record.function_queries[682].get_mut(&inp[..]) { debug_assert_eq!(result.output, &__ret[..]); if !unconstrained { *result.multiplicity += G::ONE; } } else { record.function_queries[682].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained)); }; + let __ret: [G; OUT_678] = [__v_58]; + if let Some(result) = record.function_queries[678].get_mut(&inp[..]) { debug_assert_eq!(result.output, &__ret[..]); if !unconstrained { *result.multiplicity += G::ONE; } } else { record.function_queries[678].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained)); }; return Ok(__ret); }, _ => { @@ -57653,15 +57381,15 @@ fn aiur_fn_682( }) } -const INPUT_SIZE_683: usize = 3; -const IN_683: usize = 3; -const OUT_683: usize = 1; -fn aiur_fn_683( - inp: [G; IN_683], +const INPUT_SIZE_679: usize = 3; +const IN_679: usize = 3; +const OUT_679: usize = 1; +fn aiur_fn_679( + inp: [G; IN_679], record: &mut QueryRecord, io_buffer: &mut IOBuffer, unconstrained: bool, -) -> Result<[G; OUT_683], ExecError> { +) -> Result<[G; OUT_679], ExecError> { stacker::maybe_grow(64 * 1024, 4 * 1024 * 1024, || { let __v_0: G = inp[0]; let __v_1: G = inp[1]; @@ -57675,19 +57403,19 @@ fn aiur_fn_683( let __v_6: G = G::from_u64(1); let __v_7: G = G::from_u64(1); let __v_8: G = { let __values: [G; 3] = [__v_6, __v_7, __v_7]; let __mq = record.memory_queries.get_mut(&3).ok_or(ExecError::InvalidMemorySize(3))?; if let Some(result) = __mq.get_mut(&__values[..]) { if !unconstrained { *result.multiplicity += G::ONE; } result.output[0] } else { let __ptr = G::from_usize(__mq.len()); __mq.insert(&__values[..], &[__ptr], G::from_bool(!unconstrained)); __ptr } }; - let __ret: [G; OUT_683] = [__v_8]; - if let Some(result) = record.function_queries[683].get_mut(&inp[..]) { debug_assert_eq!(result.output, &__ret[..]); if !unconstrained { *result.multiplicity += G::ONE; } } else { record.function_queries[683].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained)); }; + let __ret: [G; OUT_679] = [__v_8]; + if let Some(result) = record.function_queries[679].get_mut(&inp[..]) { debug_assert_eq!(result.output, &__ret[..]); if !unconstrained { *result.multiplicity += G::ONE; } } else { record.function_queries[679].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained)); }; return Ok(__ret); }, 0u64 => { let __v_6: G = G::from_u64(0); - let __r_arr: [G; OUT_359] = { let __args: [G; IN_359] = [__v_4, __v_1, __v_2]; let __cu = unconstrained; if let Some(result) = record.function_queries[359].get_mut(&__args[..]) { if !__cu && *result.multiplicity == G::ZERO { aiur_fn_359(__args, record, io_buffer, false)? } else { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_359] = unsafe { *(result.output.as_ptr() as *const [G; OUT_359]) }; __ret } } else { aiur_fn_359(__args, record, io_buffer, __cu)? } }; + let __r_arr: [G; OUT_355] = { let __args: [G; IN_355] = [__v_4, __v_1, __v_2]; let __cu = unconstrained; if let Some(result) = record.function_queries[355].get_mut(&__args[..]) { if !__cu && *result.multiplicity == G::ZERO { aiur_fn_355(__args, record, io_buffer, false)? } else { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_355] = unsafe { *(result.output.as_ptr() as *const [G; OUT_355]) }; __ret } } else { aiur_fn_355(__args, record, io_buffer, __cu)? } }; let __v_7: G = __r_arr[0]; - let __r_arr: [G; OUT_683] = { let __args: [G; IN_683] = [__v_5, __v_1, __v_2]; let __cu = unconstrained; if let Some(result) = record.function_queries[683].get_mut(&__args[..]) { if !__cu && *result.multiplicity == G::ZERO { aiur_fn_683(__args, record, io_buffer, false)? } else { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_683] = unsafe { *(result.output.as_ptr() as *const [G; OUT_683]) }; __ret } } else { aiur_fn_683(__args, record, io_buffer, __cu)? } }; + let __r_arr: [G; OUT_679] = { let __args: [G; IN_679] = [__v_5, __v_1, __v_2]; let __cu = unconstrained; if let Some(result) = record.function_queries[679].get_mut(&__args[..]) { if !__cu && *result.multiplicity == G::ZERO { aiur_fn_679(__args, record, io_buffer, false)? } else { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_679] = unsafe { *(result.output.as_ptr() as *const [G; OUT_679]) }; __ret } } else { aiur_fn_679(__args, record, io_buffer, __cu)? } }; let __v_8: G = __r_arr[0]; let __v_9: G = { let __values: [G; 3] = [__v_6, __v_7, __v_8]; let __mq = record.memory_queries.get_mut(&3).ok_or(ExecError::InvalidMemorySize(3))?; if let Some(result) = __mq.get_mut(&__values[..]) { if !unconstrained { *result.multiplicity += G::ONE; } result.output[0] } else { let __ptr = G::from_usize(__mq.len()); __mq.insert(&__values[..], &[__ptr], G::from_bool(!unconstrained)); __ptr } }; - let __ret: [G; OUT_683] = [__v_9]; - if let Some(result) = record.function_queries[683].get_mut(&inp[..]) { debug_assert_eq!(result.output, &__ret[..]); if !unconstrained { *result.multiplicity += G::ONE; } } else { record.function_queries[683].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained)); }; + let __ret: [G; OUT_679] = [__v_9]; + if let Some(result) = record.function_queries[679].get_mut(&inp[..]) { debug_assert_eq!(result.output, &__ret[..]); if !unconstrained { *result.multiplicity += G::ONE; } } else { record.function_queries[679].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained)); }; return Ok(__ret); }, _ => { @@ -57697,15 +57425,15 @@ fn aiur_fn_683( }) } -const INPUT_SIZE_684: usize = 4; -const IN_684: usize = 4; -const OUT_684: usize = 1; -fn aiur_fn_684( - inp: [G; IN_684], +const INPUT_SIZE_680: usize = 4; +const IN_680: usize = 4; +const OUT_680: usize = 1; +fn aiur_fn_680( + inp: [G; IN_680], record: &mut QueryRecord, io_buffer: &mut IOBuffer, unconstrained: bool, -) -> Result<[G; OUT_684], ExecError> { +) -> Result<[G; OUT_680], ExecError> { stacker::maybe_grow(64 * 1024, 4 * 1024 * 1024, || { let __v_0: G = inp[0]; let __v_1: G = inp[1]; @@ -57714,8 +57442,8 @@ fn aiur_fn_684( let __v_4: G = (__v_1 - __v_3); match __v_4.as_canonical_u64() { 0u64 => { - let __ret: [G; OUT_684] = [__v_0]; - if let Some(result) = record.function_queries[684].get_mut(&inp[..]) { debug_assert_eq!(result.output, &__ret[..]); if !unconstrained { *result.multiplicity += G::ONE; } } else { record.function_queries[684].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained)); }; + let __ret: [G; OUT_680] = [__v_0]; + if let Some(result) = record.function_queries[680].get_mut(&inp[..]) { debug_assert_eq!(result.output, &__ret[..]); if !unconstrained { *result.multiplicity += G::ONE; } } else { record.function_queries[680].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained)); }; return Ok(__ret); }, _ => { @@ -57730,25 +57458,25 @@ fn aiur_fn_684( let __v_13: G = { let __values: [G; 4] = [__v_11, __v_0, __v_10, __v_12]; let __mq = record.memory_queries.get_mut(&4).ok_or(ExecError::InvalidMemorySize(4))?; if let Some(result) = __mq.get_mut(&__values[..]) { if !unconstrained { *result.multiplicity += G::ONE; } result.output[0] } else { let __ptr = G::from_usize(__mq.len()); __mq.insert(&__values[..], &[__ptr], G::from_bool(!unconstrained)); __ptr } }; let __v_14: G = G::from_u64(1); let __v_15: G = (__v_3 + __v_14); - let __r_arr: [G; OUT_684] = { let __args: [G; IN_684] = [__v_13, __v_1, __v_2, __v_15]; let __cu = unconstrained; if let Some(result) = record.function_queries[684].get_mut(&__args[..]) { if !__cu && *result.multiplicity == G::ZERO { aiur_fn_684(__args, record, io_buffer, false)? } else { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_684] = unsafe { *(result.output.as_ptr() as *const [G; OUT_684]) }; __ret } } else { aiur_fn_684(__args, record, io_buffer, __cu)? } }; + let __r_arr: [G; OUT_680] = { let __args: [G; IN_680] = [__v_13, __v_1, __v_2, __v_15]; let __cu = unconstrained; if let Some(result) = record.function_queries[680].get_mut(&__args[..]) { if !__cu && *result.multiplicity == G::ZERO { aiur_fn_680(__args, record, io_buffer, false)? } else { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_680] = unsafe { *(result.output.as_ptr() as *const [G; OUT_680]) }; __ret } } else { aiur_fn_680(__args, record, io_buffer, __cu)? } }; let __v_16: G = __r_arr[0]; - let __ret: [G; OUT_684] = [__v_16]; - if let Some(result) = record.function_queries[684].get_mut(&inp[..]) { debug_assert_eq!(result.output, &__ret[..]); if !unconstrained { *result.multiplicity += G::ONE; } } else { record.function_queries[684].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained)); }; + let __ret: [G; OUT_680] = [__v_16]; + if let Some(result) = record.function_queries[680].get_mut(&inp[..]) { debug_assert_eq!(result.output, &__ret[..]); if !unconstrained { *result.multiplicity += G::ONE; } } else { record.function_queries[680].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained)); }; return Ok(__ret); }, } }) } -const INPUT_SIZE_685: usize = 6; -const IN_685: usize = 6; -const OUT_685: usize = 1; -fn aiur_fn_685( - inp: [G; IN_685], +const INPUT_SIZE_681: usize = 6; +const IN_681: usize = 6; +const OUT_681: usize = 1; +fn aiur_fn_681( + inp: [G; IN_681], record: &mut QueryRecord, io_buffer: &mut IOBuffer, unconstrained: bool, -) -> Result<[G; OUT_685], ExecError> { +) -> Result<[G; OUT_681], ExecError> { stacker::maybe_grow(64 * 1024, 4 * 1024 * 1024, || { let __v_0: G = inp[0]; let __v_1: G = inp[1]; @@ -57761,55 +57489,55 @@ fn aiur_fn_685( let __v_6: G = G::from_u64(1); let __v_7: G = (__v_3 - __v_6); let __v_8: G = G::from_u64(0); - let __r_arr: [G; OUT_657] = { let __args: [G; IN_657] = [__v_0, __v_2, __v_7, __v_8]; let __cu = unconstrained; if let Some(result) = record.function_queries[657].get_mut(&__args[..]) { if !__cu && *result.multiplicity == G::ZERO { aiur_fn_657(__args, record, io_buffer, false)? } else { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_657] = unsafe { *(result.output.as_ptr() as *const [G; OUT_657]) }; __ret } } else { aiur_fn_657(__args, record, io_buffer, __cu)? } }; + let __r_arr: [G; OUT_653] = { let __args: [G; IN_653] = [__v_0, __v_2, __v_7, __v_8]; let __cu = unconstrained; if let Some(result) = record.function_queries[653].get_mut(&__args[..]) { if !__cu && *result.multiplicity == G::ZERO { aiur_fn_653(__args, record, io_buffer, false)? } else { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_653] = unsafe { *(result.output.as_ptr() as *const [G; OUT_653]) }; __ret } } else { aiur_fn_653(__args, record, io_buffer, __cu)? } }; let __v_9: G = __r_arr[0]; - let __ret: [G; OUT_685] = [__v_9]; - if let Some(result) = record.function_queries[685].get_mut(&inp[..]) { debug_assert_eq!(result.output, &__ret[..]); if !unconstrained { *result.multiplicity += G::ONE; } } else { record.function_queries[685].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained)); }; + let __ret: [G; OUT_681] = [__v_9]; + if let Some(result) = record.function_queries[681].get_mut(&inp[..]) { debug_assert_eq!(result.output, &__ret[..]); if !unconstrained { *result.multiplicity += G::ONE; } } else { record.function_queries[681].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained)); }; return Ok(__ret); }, _ => { let __v_6: G = (__v_3 - __v_2); - let __r_arr: [G; OUT_647] = { let __args: [G; IN_647] = [__v_0, __v_5, __v_6]; let __cu = unconstrained; if let Some(result) = record.function_queries[647].get_mut(&__args[..]) { if !__cu && *result.multiplicity == G::ZERO { aiur_fn_647(__args, record, io_buffer, false)? } else { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_647] = unsafe { *(result.output.as_ptr() as *const [G; OUT_647]) }; __ret } } else { aiur_fn_647(__args, record, io_buffer, __cu)? } }; + let __r_arr: [G; OUT_643] = { let __args: [G; IN_643] = [__v_0, __v_5, __v_6]; let __cu = unconstrained; if let Some(result) = record.function_queries[643].get_mut(&__args[..]) { if !__cu && *result.multiplicity == G::ZERO { aiur_fn_643(__args, record, io_buffer, false)? } else { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_643] = unsafe { *(result.output.as_ptr() as *const [G; OUT_643]) }; __ret } } else { aiur_fn_643(__args, record, io_buffer, __cu)? } }; let __v_7: G = __r_arr[0]; - let __ret: [G; OUT_685] = [__v_7]; - if let Some(result) = record.function_queries[685].get_mut(&inp[..]) { debug_assert_eq!(result.output, &__ret[..]); if !unconstrained { *result.multiplicity += G::ONE; } } else { record.function_queries[685].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained)); }; + let __ret: [G; OUT_681] = [__v_7]; + if let Some(result) = record.function_queries[681].get_mut(&inp[..]) { debug_assert_eq!(result.output, &__ret[..]); if !unconstrained { *result.multiplicity += G::ONE; } } else { record.function_queries[681].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained)); }; return Ok(__ret); }, } }) } -const INPUT_SIZE_686: usize = 3; -const IN_686: usize = 3; -const OUT_686: usize = 2; -fn aiur_fn_686( - inp: [G; IN_686], +const INPUT_SIZE_682: usize = 3; +const IN_682: usize = 3; +const OUT_682: usize = 2; +fn aiur_fn_682( + inp: [G; IN_682], record: &mut QueryRecord, io_buffer: &mut IOBuffer, unconstrained: bool, -) -> Result<[G; OUT_686], ExecError> { +) -> Result<[G; OUT_682], ExecError> { stacker::maybe_grow(64 * 1024, 4 * 1024 * 1024, || { let __v_0: G = inp[0]; let __v_1: G = inp[1]; let __v_2: G = inp[2]; - let __r_arr: [G; OUT_687] = { let __args: [G; IN_687] = [__v_0, __v_1, __v_2]; let __cu = unconstrained; if let Some(result) = record.function_queries[687].get_mut(&__args[..]) { if !__cu && *result.multiplicity == G::ZERO { aiur_fn_687(__args, record, io_buffer, false)? } else { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_687] = unsafe { *(result.output.as_ptr() as *const [G; OUT_687]) }; __ret } } else { aiur_fn_687(__args, record, io_buffer, __cu)? } }; + let __r_arr: [G; OUT_683] = { let __args: [G; IN_683] = [__v_0, __v_1, __v_2]; let __cu = unconstrained; if let Some(result) = record.function_queries[683].get_mut(&__args[..]) { if !__cu && *result.multiplicity == G::ZERO { aiur_fn_683(__args, record, io_buffer, false)? } else { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_683] = unsafe { *(result.output.as_ptr() as *const [G; OUT_683]) }; __ret } } else { aiur_fn_683(__args, record, io_buffer, __cu)? } }; let __v_3: G = __r_arr[0]; let __v_4: G = __r_arr[1]; - let __ret: [G; OUT_686] = [__v_3, __v_4]; - if let Some(result) = record.function_queries[686].get_mut(&inp[..]) { debug_assert_eq!(result.output, &__ret[..]); if !unconstrained { *result.multiplicity += G::ONE; } } else { record.function_queries[686].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained)); }; + let __ret: [G; OUT_682] = [__v_3, __v_4]; + if let Some(result) = record.function_queries[682].get_mut(&inp[..]) { debug_assert_eq!(result.output, &__ret[..]); if !unconstrained { *result.multiplicity += G::ONE; } } else { record.function_queries[682].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained)); }; return Ok(__ret); }) } -const INPUT_SIZE_687: usize = 3; -const IN_687: usize = 3; -const OUT_687: usize = 2; -fn aiur_fn_687( - inp: [G; IN_687], +const INPUT_SIZE_683: usize = 3; +const IN_683: usize = 3; +const OUT_683: usize = 2; +fn aiur_fn_683( + inp: [G; IN_683], record: &mut QueryRecord, io_buffer: &mut IOBuffer, unconstrained: bool, -) -> Result<[G; OUT_687], ExecError> { +) -> Result<[G; OUT_683], ExecError> { stacker::maybe_grow(64 * 1024, 4 * 1024 * 1024, || { let __v_0: G = inp[0]; let __v_1: G = inp[1]; @@ -57817,7 +57545,7 @@ fn aiur_fn_687( let __v_3: G = G::from_u64(1); let __v_4: G = G::from_u64(1); let __v_5: G = { let __values: [G; 3] = [__v_3, __v_4, __v_4]; let __mq = record.memory_queries.get_mut(&3).ok_or(ExecError::InvalidMemorySize(3))?; if let Some(result) = __mq.get_mut(&__values[..]) { if !unconstrained { *result.multiplicity += G::ONE; } result.output[0] } else { let __ptr = G::from_usize(__mq.len()); __mq.insert(&__values[..], &[__ptr], G::from_bool(!unconstrained)); __ptr } }; - let __r_arr: [G; OUT_418] = { let __args: [G; IN_418] = [__v_0, __v_5]; let __cu = unconstrained; if let Some(result) = record.function_queries[418].get_mut(&__args[..]) { if !__cu && *result.multiplicity == G::ZERO { aiur_fn_418(__args, record, io_buffer, false)? } else { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_418] = unsafe { *(result.output.as_ptr() as *const [G; OUT_418]) }; __ret } } else { aiur_fn_418(__args, record, io_buffer, __cu)? } }; + let __r_arr: [G; OUT_414] = { let __args: [G; IN_414] = [__v_0, __v_5]; let __cu = unconstrained; if let Some(result) = record.function_queries[414].get_mut(&__args[..]) { if !__cu && *result.multiplicity == G::ZERO { aiur_fn_414(__args, record, io_buffer, false)? } else { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_414] = unsafe { *(result.output.as_ptr() as *const [G; OUT_414]) }; __ret } } else { aiur_fn_414(__args, record, io_buffer, __cu)? } }; let __v_6: G = __r_arr[0]; let __loaded: [G; 4] = { let __mq = record.memory_queries.get_mut(&4).ok_or(ExecError::InvalidMemorySize(4))?; let __ptr_u64 = __v_6.as_canonical_u64(); let __ptr_usize = usize::try_from(__ptr_u64).ok().ok_or(ExecError::PointerTooLarge(__ptr_u64))?; let (__args, __mult) = __mq.get_index_mut(__ptr_usize).ok_or(ExecError::UnboundPointer { ptr: __ptr_u64, size: 4 })?; if !unconstrained { *__mult += G::ONE; } let __arr: [G; 4] = __args[..4].try_into().unwrap(); __arr }; let __v_7: G = __loaded[0]; @@ -57826,11 +57554,11 @@ fn aiur_fn_687( let __v_10: G = __loaded[3]; match __v_7.as_canonical_u64() { 5u64 => { - let __r_arr: [G; OUT_687] = { let __args: [G; IN_687] = [__v_9, __v_1, __v_2]; let __cu = unconstrained; if let Some(result) = record.function_queries[687].get_mut(&__args[..]) { if !__cu && *result.multiplicity == G::ZERO { aiur_fn_687(__args, record, io_buffer, false)? } else { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_687] = unsafe { *(result.output.as_ptr() as *const [G; OUT_687]) }; __ret } } else { aiur_fn_687(__args, record, io_buffer, __cu)? } }; + let __r_arr: [G; OUT_683] = { let __args: [G; IN_683] = [__v_9, __v_1, __v_2]; let __cu = unconstrained; if let Some(result) = record.function_queries[683].get_mut(&__args[..]) { if !__cu && *result.multiplicity == G::ZERO { aiur_fn_683(__args, record, io_buffer, false)? } else { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_683] = unsafe { *(result.output.as_ptr() as *const [G; OUT_683]) }; __ret } } else { aiur_fn_683(__args, record, io_buffer, __cu)? } }; let __v_11: G = __r_arr[0]; let __v_12: G = __r_arr[1]; - let __ret: [G; OUT_687] = [__v_11, __v_12]; - if let Some(result) = record.function_queries[687].get_mut(&inp[..]) { debug_assert_eq!(result.output, &__ret[..]); if !unconstrained { *result.multiplicity += G::ONE; } } else { record.function_queries[687].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained)); }; + let __ret: [G; OUT_683] = [__v_11, __v_12]; + if let Some(result) = record.function_queries[683].get_mut(&inp[..]) { debug_assert_eq!(result.output, &__ret[..]); if !unconstrained { *result.multiplicity += G::ONE; } } else { record.function_queries[683].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained)); }; return Ok(__ret); }, _ => { @@ -57845,18 +57573,18 @@ fn aiur_fn_687( match __v_13.as_canonical_u64() { 2u64 => { let __v_17: G = G::from_u64(0); - let __r_arr: [G; OUT_688] = { let __args: [G; IN_688] = [__v_1, __v_14, __v_12, __v_2, __v_17]; let __cu = unconstrained; if let Some(result) = record.function_queries[688].get_mut(&__args[..]) { if !__cu && *result.multiplicity == G::ZERO { aiur_fn_688(__args, record, io_buffer, false)? } else { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_688] = unsafe { *(result.output.as_ptr() as *const [G; OUT_688]) }; __ret } } else { aiur_fn_688(__args, record, io_buffer, __cu)? } }; + let __r_arr: [G; OUT_684] = { let __args: [G; IN_684] = [__v_1, __v_14, __v_12, __v_2, __v_17]; let __cu = unconstrained; if let Some(result) = record.function_queries[684].get_mut(&__args[..]) { if !__cu && *result.multiplicity == G::ZERO { aiur_fn_684(__args, record, io_buffer, false)? } else { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_684] = unsafe { *(result.output.as_ptr() as *const [G; OUT_684]) }; __ret } } else { aiur_fn_684(__args, record, io_buffer, __cu)? } }; let __v_18: G = __r_arr[0]; let __v_19: G = __r_arr[1]; - let __ret: [G; OUT_687] = [__v_18, __v_19]; - if let Some(result) = record.function_queries[687].get_mut(&inp[..]) { debug_assert_eq!(result.output, &__ret[..]); if !unconstrained { *result.multiplicity += G::ONE; } } else { record.function_queries[687].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained)); }; + let __ret: [G; OUT_683] = [__v_18, __v_19]; + if let Some(result) = record.function_queries[683].get_mut(&inp[..]) { debug_assert_eq!(result.output, &__ret[..]); if !unconstrained { *result.multiplicity += G::ONE; } } else { record.function_queries[683].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained)); }; return Ok(__ret); }, _ => { let __v_17: G = G::from_u64(0); let __v_18: G = G::from_u64(0); - let __ret: [G; OUT_687] = [__v_17, __v_18]; - if let Some(result) = record.function_queries[687].get_mut(&inp[..]) { debug_assert_eq!(result.output, &__ret[..]); if !unconstrained { *result.multiplicity += G::ONE; } } else { record.function_queries[687].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained)); }; + let __ret: [G; OUT_683] = [__v_17, __v_18]; + if let Some(result) = record.function_queries[683].get_mut(&inp[..]) { debug_assert_eq!(result.output, &__ret[..]); if !unconstrained { *result.multiplicity += G::ONE; } } else { record.function_queries[683].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained)); }; return Ok(__ret); }, } @@ -57865,15 +57593,15 @@ fn aiur_fn_687( }) } -const INPUT_SIZE_688: usize = 5; -const IN_688: usize = 5; -const OUT_688: usize = 2; -fn aiur_fn_688( - inp: [G; IN_688], +const INPUT_SIZE_684: usize = 5; +const IN_684: usize = 5; +const OUT_684: usize = 2; +fn aiur_fn_684( + inp: [G; IN_684], record: &mut QueryRecord, io_buffer: &mut IOBuffer, unconstrained: bool, -) -> Result<[G; OUT_688], ExecError> { +) -> Result<[G; OUT_684], ExecError> { stacker::maybe_grow(64 * 1024, 4 * 1024 * 1024, || { let __v_0: G = inp[0]; let __v_1: G = inp[1]; @@ -57891,8 +57619,8 @@ fn aiur_fn_688( 1u64 => { let __v_11: G = G::from_u64(0); let __v_12: G = G::from_u64(0); - let __ret: [G; OUT_688] = [__v_11, __v_12]; - if let Some(result) = record.function_queries[688].get_mut(&inp[..]) { debug_assert_eq!(result.output, &__ret[..]); if !unconstrained { *result.multiplicity += G::ONE; } } else { record.function_queries[688].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained)); }; + let __ret: [G; OUT_684] = [__v_11, __v_12]; + if let Some(result) = record.function_queries[684].get_mut(&inp[..]) { debug_assert_eq!(result.output, &__ret[..]); if !unconstrained { *result.multiplicity += G::ONE; } } else { record.function_queries[684].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained)); }; return Ok(__ret); }, 0u64 => { @@ -57904,7 +57632,7 @@ fn aiur_fn_688( break '__mc_0 [__v_12]; }, _ => { - let __r_arr: [G; OUT_689] = { let __args: [G; IN_689] = [__v_8, __v_2, __v_3]; let __cu = unconstrained; if let Some(result) = record.function_queries[689].get_mut(&__args[..]) { if !__cu && *result.multiplicity == G::ZERO { aiur_fn_689(__args, record, io_buffer, false)? } else { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_689] = unsafe { *(result.output.as_ptr() as *const [G; OUT_689]) }; __ret } } else { aiur_fn_689(__args, record, io_buffer, __cu)? } }; + let __r_arr: [G; OUT_685] = { let __args: [G; IN_685] = [__v_8, __v_2, __v_3]; let __cu = unconstrained; if let Some(result) = record.function_queries[685].get_mut(&__args[..]) { if !__cu && *result.multiplicity == G::ZERO { aiur_fn_685(__args, record, io_buffer, false)? } else { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_685] = unsafe { *(result.output.as_ptr() as *const [G; OUT_685]) }; __ret } } else { aiur_fn_685(__args, record, io_buffer, __cu)? } }; let __v_12: G = __r_arr[0]; break '__mc_0 [__v_12]; }, @@ -57915,18 +57643,18 @@ fn aiur_fn_688( match __v_13.as_canonical_u64() { 1u64 => { let __v_14: G = G::from_u64(1); - let __ret: [G; OUT_688] = [__v_14, __v_4]; - if let Some(result) = record.function_queries[688].get_mut(&inp[..]) { debug_assert_eq!(result.output, &__ret[..]); if !unconstrained { *result.multiplicity += G::ONE; } } else { record.function_queries[688].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained)); }; + let __ret: [G; OUT_684] = [__v_14, __v_4]; + if let Some(result) = record.function_queries[684].get_mut(&inp[..]) { debug_assert_eq!(result.output, &__ret[..]); if !unconstrained { *result.multiplicity += G::ONE; } } else { record.function_queries[684].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained)); }; return Ok(__ret); }, _ => { let __v_14: G = G::from_u64(1); let __v_15: G = (__v_4 + __v_14); - let __r_arr: [G; OUT_688] = { let __args: [G; IN_688] = [__v_10, __v_1, __v_2, __v_3, __v_15]; let __cu = unconstrained; if let Some(result) = record.function_queries[688].get_mut(&__args[..]) { if !__cu && *result.multiplicity == G::ZERO { aiur_fn_688(__args, record, io_buffer, false)? } else { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_688] = unsafe { *(result.output.as_ptr() as *const [G; OUT_688]) }; __ret } } else { aiur_fn_688(__args, record, io_buffer, __cu)? } }; + let __r_arr: [G; OUT_684] = { let __args: [G; IN_684] = [__v_10, __v_1, __v_2, __v_3, __v_15]; let __cu = unconstrained; if let Some(result) = record.function_queries[684].get_mut(&__args[..]) { if !__cu && *result.multiplicity == G::ZERO { aiur_fn_684(__args, record, io_buffer, false)? } else { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_684] = unsafe { *(result.output.as_ptr() as *const [G; OUT_684]) }; __ret } } else { aiur_fn_684(__args, record, io_buffer, __cu)? } }; let __v_16: G = __r_arr[0]; let __v_17: G = __r_arr[1]; - let __ret: [G; OUT_688] = [__v_16, __v_17]; - if let Some(result) = record.function_queries[688].get_mut(&inp[..]) { debug_assert_eq!(result.output, &__ret[..]); if !unconstrained { *result.multiplicity += G::ONE; } } else { record.function_queries[688].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained)); }; + let __ret: [G; OUT_684] = [__v_16, __v_17]; + if let Some(result) = record.function_queries[684].get_mut(&inp[..]) { debug_assert_eq!(result.output, &__ret[..]); if !unconstrained { *result.multiplicity += G::ONE; } } else { record.function_queries[684].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained)); }; return Ok(__ret); }, } @@ -57938,15 +57666,15 @@ fn aiur_fn_688( }) } -const INPUT_SIZE_689: usize = 3; -const IN_689: usize = 3; -const OUT_689: usize = 1; -fn aiur_fn_689( - inp: [G; IN_689], +const INPUT_SIZE_685: usize = 3; +const IN_685: usize = 3; +const OUT_685: usize = 1; +fn aiur_fn_685( + inp: [G; IN_685], record: &mut QueryRecord, io_buffer: &mut IOBuffer, unconstrained: bool, -) -> Result<[G; OUT_689], ExecError> { +) -> Result<[G; OUT_685], ExecError> { stacker::maybe_grow(64 * 1024, 4 * 1024 * 1024, || { let __v_0: G = inp[0]; let __v_1: G = inp[1]; @@ -57958,8 +57686,8 @@ fn aiur_fn_689( match __v_3.as_canonical_u64() { 1u64 => { let __v_6: G = G::from_u64(1); - let __ret: [G; OUT_689] = [__v_6]; - if let Some(result) = record.function_queries[689].get_mut(&inp[..]) { debug_assert_eq!(result.output, &__ret[..]); if !unconstrained { *result.multiplicity += G::ONE; } } else { record.function_queries[689].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained)); }; + let __ret: [G; OUT_685] = [__v_6]; + if let Some(result) = record.function_queries[685].get_mut(&inp[..]) { debug_assert_eq!(result.output, &__ret[..]); if !unconstrained { *result.multiplicity += G::ONE; } } else { record.function_queries[685].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained)); }; return Ok(__ret); }, 0u64 => { @@ -57970,28 +57698,28 @@ fn aiur_fn_689( match __v_6.as_canonical_u64() { 1u64 => { let __v_9: G = G::from_u64(0); - let __ret: [G; OUT_689] = [__v_9]; - if let Some(result) = record.function_queries[689].get_mut(&inp[..]) { debug_assert_eq!(result.output, &__ret[..]); if !unconstrained { *result.multiplicity += G::ONE; } } else { record.function_queries[689].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained)); }; + let __ret: [G; OUT_685] = [__v_9]; + if let Some(result) = record.function_queries[685].get_mut(&inp[..]) { debug_assert_eq!(result.output, &__ret[..]); if !unconstrained { *result.multiplicity += G::ONE; } } else { record.function_queries[685].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained)); }; return Ok(__ret); }, 0u64 => { let __v_9: G = G::from_u64(0); - let __r_arr: [G; OUT_359] = { let __args: [G; IN_359] = [__v_4, __v_2, __v_9]; let __cu = unconstrained; if let Some(result) = record.function_queries[359].get_mut(&__args[..]) { if !__cu && *result.multiplicity == G::ZERO { aiur_fn_359(__args, record, io_buffer, false)? } else { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_359] = unsafe { *(result.output.as_ptr() as *const [G; OUT_359]) }; __ret } } else { aiur_fn_359(__args, record, io_buffer, __cu)? } }; + let __r_arr: [G; OUT_355] = { let __args: [G; IN_355] = [__v_4, __v_2, __v_9]; let __cu = unconstrained; if let Some(result) = record.function_queries[355].get_mut(&__args[..]) { if !__cu && *result.multiplicity == G::ZERO { aiur_fn_355(__args, record, io_buffer, false)? } else { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_355] = unsafe { *(result.output.as_ptr() as *const [G; OUT_355]) }; __ret } } else { aiur_fn_355(__args, record, io_buffer, __cu)? } }; let __v_10: G = __r_arr[0]; - let __r_arr: [G; OUT_631] = { let __args: [G; IN_631] = [__v_10, __v_7]; let __cu = unconstrained; if let Some(result) = record.function_queries[631].get_mut(&__args[..]) { if !__cu && *result.multiplicity == G::ZERO { aiur_fn_631(__args, record, io_buffer, false)? } else { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_631] = unsafe { *(result.output.as_ptr() as *const [G; OUT_631]) }; __ret } } else { aiur_fn_631(__args, record, io_buffer, __cu)? } }; + let __r_arr: [G; OUT_627] = { let __args: [G; IN_627] = [__v_10, __v_7]; let __cu = unconstrained; if let Some(result) = record.function_queries[627].get_mut(&__args[..]) { if !__cu && *result.multiplicity == G::ZERO { aiur_fn_627(__args, record, io_buffer, false)? } else { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_627] = unsafe { *(result.output.as_ptr() as *const [G; OUT_627]) }; __ret } } else { aiur_fn_627(__args, record, io_buffer, __cu)? } }; let __v_11: G = __r_arr[0]; match __v_11.as_canonical_u64() { 1u64 => { - let __r_arr: [G; OUT_689] = { let __args: [G; IN_689] = [__v_5, __v_8, __v_2]; let __cu = unconstrained; if let Some(result) = record.function_queries[689].get_mut(&__args[..]) { if !__cu && *result.multiplicity == G::ZERO { aiur_fn_689(__args, record, io_buffer, false)? } else { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_689] = unsafe { *(result.output.as_ptr() as *const [G; OUT_689]) }; __ret } } else { aiur_fn_689(__args, record, io_buffer, __cu)? } }; + let __r_arr: [G; OUT_685] = { let __args: [G; IN_685] = [__v_5, __v_8, __v_2]; let __cu = unconstrained; if let Some(result) = record.function_queries[685].get_mut(&__args[..]) { if !__cu && *result.multiplicity == G::ZERO { aiur_fn_685(__args, record, io_buffer, false)? } else { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_685] = unsafe { *(result.output.as_ptr() as *const [G; OUT_685]) }; __ret } } else { aiur_fn_685(__args, record, io_buffer, __cu)? } }; let __v_12: G = __r_arr[0]; - let __ret: [G; OUT_689] = [__v_12]; - if let Some(result) = record.function_queries[689].get_mut(&inp[..]) { debug_assert_eq!(result.output, &__ret[..]); if !unconstrained { *result.multiplicity += G::ONE; } } else { record.function_queries[689].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained)); }; + let __ret: [G; OUT_685] = [__v_12]; + if let Some(result) = record.function_queries[685].get_mut(&inp[..]) { debug_assert_eq!(result.output, &__ret[..]); if !unconstrained { *result.multiplicity += G::ONE; } } else { record.function_queries[685].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained)); }; return Ok(__ret); }, _ => { let __v_12: G = G::from_u64(0); - let __ret: [G; OUT_689] = [__v_12]; - if let Some(result) = record.function_queries[689].get_mut(&inp[..]) { debug_assert_eq!(result.output, &__ret[..]); if !unconstrained { *result.multiplicity += G::ONE; } } else { record.function_queries[689].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained)); }; + let __ret: [G; OUT_685] = [__v_12]; + if let Some(result) = record.function_queries[685].get_mut(&inp[..]) { debug_assert_eq!(result.output, &__ret[..]); if !unconstrained { *result.multiplicity += G::ONE; } } else { record.function_queries[685].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained)); }; return Ok(__ret); }, } @@ -58008,15 +57736,15 @@ fn aiur_fn_689( }) } -const INPUT_SIZE_690: usize = 7; -const IN_690: usize = 7; -const OUT_690: usize = 4; -fn aiur_fn_690( - inp: [G; IN_690], +const INPUT_SIZE_686: usize = 7; +const IN_686: usize = 7; +const OUT_686: usize = 4; +fn aiur_fn_686( + inp: [G; IN_686], record: &mut QueryRecord, io_buffer: &mut IOBuffer, unconstrained: bool, -) -> Result<[G; OUT_690], ExecError> { +) -> Result<[G; OUT_686], ExecError> { stacker::maybe_grow(64 * 1024, 4 * 1024 * 1024, || { let __v_0: G = inp[0]; let __v_1: G = inp[1]; @@ -58033,7 +57761,7 @@ fn aiur_fn_690( match __v_7.as_canonical_u64() { 5u64 => { let __v_11: G = (__v_6 + __v_5); - let __r_arr: [G; OUT_686] = { let __args: [G; IN_686] = [__v_8, __v_1, __v_11]; let __cu = unconstrained; if let Some(result) = record.function_queries[686].get_mut(&__args[..]) { if !__cu && *result.multiplicity == G::ZERO { aiur_fn_686(__args, record, io_buffer, false)? } else { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_686] = unsafe { *(result.output.as_ptr() as *const [G; OUT_686]) }; __ret } } else { aiur_fn_686(__args, record, io_buffer, __cu)? } }; + let __r_arr: [G; OUT_682] = { let __args: [G; IN_682] = [__v_8, __v_1, __v_11]; let __cu = unconstrained; if let Some(result) = record.function_queries[682].get_mut(&__args[..]) { if !__cu && *result.multiplicity == G::ZERO { aiur_fn_682(__args, record, io_buffer, false)? } else { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_682] = unsafe { *(result.output.as_ptr() as *const [G; OUT_682]) }; __ret } } else { aiur_fn_682(__args, record, io_buffer, __cu)? } }; let __v_12: G = __r_arr[0]; let __v_13: G = __r_arr[1]; let __v_14: G = G::from_u64(0); @@ -58046,53 +57774,53 @@ fn aiur_fn_690( let __v_19: G = { let __values: [G; 3] = [__v_18, __v_13, __v_4]; let __mq = record.memory_queries.get_mut(&3).ok_or(ExecError::InvalidMemorySize(3))?; if let Some(result) = __mq.get_mut(&__values[..]) { if !unconstrained { *result.multiplicity += G::ONE; } result.output[0] } else { let __ptr = G::from_usize(__mq.len()); __mq.insert(&__values[..], &[__ptr], G::from_bool(!unconstrained)); __ptr } }; let __v_20: G = G::from_u64(1); let __v_21: G = (__v_5 + __v_20); - let __r_arr: [G; OUT_690] = { let __args: [G; IN_690] = [__v_9, __v_1, __v_15, __v_17, __v_19, __v_21, __v_6]; let __cu = unconstrained; if let Some(result) = record.function_queries[690].get_mut(&__args[..]) { if !__cu && *result.multiplicity == G::ZERO { aiur_fn_690(__args, record, io_buffer, false)? } else { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_690] = unsafe { *(result.output.as_ptr() as *const [G; OUT_690]) }; __ret } } else { aiur_fn_690(__args, record, io_buffer, __cu)? } }; + let __r_arr: [G; OUT_686] = { let __args: [G; IN_686] = [__v_9, __v_1, __v_15, __v_17, __v_19, __v_21, __v_6]; let __cu = unconstrained; if let Some(result) = record.function_queries[686].get_mut(&__args[..]) { if !__cu && *result.multiplicity == G::ZERO { aiur_fn_686(__args, record, io_buffer, false)? } else { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_686] = unsafe { *(result.output.as_ptr() as *const [G; OUT_686]) }; __ret } } else { aiur_fn_686(__args, record, io_buffer, __cu)? } }; let __v_22: G = __r_arr[0]; let __v_23: G = __r_arr[1]; let __v_24: G = __r_arr[2]; let __v_25: G = __r_arr[3]; - let __ret: [G; OUT_690] = [__v_22, __v_23, __v_24, __v_25]; - if let Some(result) = record.function_queries[690].get_mut(&inp[..]) { debug_assert_eq!(result.output, &__ret[..]); if !unconstrained { *result.multiplicity += G::ONE; } } else { record.function_queries[690].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained)); }; + let __ret: [G; OUT_686] = [__v_22, __v_23, __v_24, __v_25]; + if let Some(result) = record.function_queries[686].get_mut(&inp[..]) { debug_assert_eq!(result.output, &__ret[..]); if !unconstrained { *result.multiplicity += G::ONE; } } else { record.function_queries[686].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained)); }; return Ok(__ret); }, _ => { let __v_16: G = G::from_u64(1); let __v_17: G = (__v_5 + __v_16); - let __r_arr: [G; OUT_690] = { let __args: [G; IN_690] = [__v_9, __v_1, __v_15, __v_3, __v_4, __v_17, __v_6]; let __cu = unconstrained; if let Some(result) = record.function_queries[690].get_mut(&__args[..]) { if !__cu && *result.multiplicity == G::ZERO { aiur_fn_690(__args, record, io_buffer, false)? } else { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_690] = unsafe { *(result.output.as_ptr() as *const [G; OUT_690]) }; __ret } } else { aiur_fn_690(__args, record, io_buffer, __cu)? } }; + let __r_arr: [G; OUT_686] = { let __args: [G; IN_686] = [__v_9, __v_1, __v_15, __v_3, __v_4, __v_17, __v_6]; let __cu = unconstrained; if let Some(result) = record.function_queries[686].get_mut(&__args[..]) { if !__cu && *result.multiplicity == G::ZERO { aiur_fn_686(__args, record, io_buffer, false)? } else { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_686] = unsafe { *(result.output.as_ptr() as *const [G; OUT_686]) }; __ret } } else { aiur_fn_686(__args, record, io_buffer, __cu)? } }; let __v_18: G = __r_arr[0]; let __v_19: G = __r_arr[1]; let __v_20: G = __r_arr[2]; let __v_21: G = __r_arr[3]; - let __ret: [G; OUT_690] = [__v_18, __v_19, __v_20, __v_21]; - if let Some(result) = record.function_queries[690].get_mut(&inp[..]) { debug_assert_eq!(result.output, &__ret[..]); if !unconstrained { *result.multiplicity += G::ONE; } } else { record.function_queries[690].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained)); }; + let __ret: [G; OUT_686] = [__v_18, __v_19, __v_20, __v_21]; + if let Some(result) = record.function_queries[686].get_mut(&inp[..]) { debug_assert_eq!(result.output, &__ret[..]); if !unconstrained { *result.multiplicity += G::ONE; } } else { record.function_queries[686].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained)); }; return Ok(__ret); }, } }, _ => { - let __r_arr: [G; OUT_762] = { let __args: [G; IN_762] = [__v_2]; let __cu = unconstrained; if let Some(result) = record.function_queries[762].get_mut(&__args[..]) { if !__cu && *result.multiplicity == G::ZERO { aiur_fn_762(__args, record, io_buffer, false)? } else { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_762] = unsafe { *(result.output.as_ptr() as *const [G; OUT_762]) }; __ret } } else { aiur_fn_762(__args, record, io_buffer, __cu)? } }; + let __r_arr: [G; OUT_758] = { let __args: [G; IN_758] = [__v_2]; let __cu = unconstrained; if let Some(result) = record.function_queries[758].get_mut(&__args[..]) { if !__cu && *result.multiplicity == G::ZERO { aiur_fn_758(__args, record, io_buffer, false)? } else { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_758] = unsafe { *(result.output.as_ptr() as *const [G; OUT_758]) }; __ret } } else { aiur_fn_758(__args, record, io_buffer, __cu)? } }; let __v_11: G = __r_arr[0]; - let __r_arr: [G; OUT_762] = { let __args: [G; IN_762] = [__v_3]; let __cu = unconstrained; if let Some(result) = record.function_queries[762].get_mut(&__args[..]) { if !__cu && *result.multiplicity == G::ZERO { aiur_fn_762(__args, record, io_buffer, false)? } else { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_762] = unsafe { *(result.output.as_ptr() as *const [G; OUT_762]) }; __ret } } else { aiur_fn_762(__args, record, io_buffer, __cu)? } }; + let __r_arr: [G; OUT_758] = { let __args: [G; IN_758] = [__v_3]; let __cu = unconstrained; if let Some(result) = record.function_queries[758].get_mut(&__args[..]) { if !__cu && *result.multiplicity == G::ZERO { aiur_fn_758(__args, record, io_buffer, false)? } else { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_758] = unsafe { *(result.output.as_ptr() as *const [G; OUT_758]) }; __ret } } else { aiur_fn_758(__args, record, io_buffer, __cu)? } }; let __v_12: G = __r_arr[0]; - let __r_arr: [G; OUT_762] = { let __args: [G; IN_762] = [__v_4]; let __cu = unconstrained; if let Some(result) = record.function_queries[762].get_mut(&__args[..]) { if !__cu && *result.multiplicity == G::ZERO { aiur_fn_762(__args, record, io_buffer, false)? } else { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_762] = unsafe { *(result.output.as_ptr() as *const [G; OUT_762]) }; __ret } } else { aiur_fn_762(__args, record, io_buffer, __cu)? } }; + let __r_arr: [G; OUT_758] = { let __args: [G; IN_758] = [__v_4]; let __cu = unconstrained; if let Some(result) = record.function_queries[758].get_mut(&__args[..]) { if !__cu && *result.multiplicity == G::ZERO { aiur_fn_758(__args, record, io_buffer, false)? } else { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_758] = unsafe { *(result.output.as_ptr() as *const [G; OUT_758]) }; __ret } } else { aiur_fn_758(__args, record, io_buffer, __cu)? } }; let __v_13: G = __r_arr[0]; - let __ret: [G; OUT_690] = [__v_11, __v_12, __v_13, __v_0]; - if let Some(result) = record.function_queries[690].get_mut(&inp[..]) { debug_assert_eq!(result.output, &__ret[..]); if !unconstrained { *result.multiplicity += G::ONE; } } else { record.function_queries[690].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained)); }; + let __ret: [G; OUT_686] = [__v_11, __v_12, __v_13, __v_0]; + if let Some(result) = record.function_queries[686].get_mut(&inp[..]) { debug_assert_eq!(result.output, &__ret[..]); if !unconstrained { *result.multiplicity += G::ONE; } } else { record.function_queries[686].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained)); }; return Ok(__ret); }, } }) } -const INPUT_SIZE_691: usize = 4; -const IN_691: usize = 4; -const OUT_691: usize = 1; -fn aiur_fn_691( - inp: [G; IN_691], +const INPUT_SIZE_687: usize = 4; +const IN_687: usize = 4; +const OUT_687: usize = 1; +fn aiur_fn_687( + inp: [G; IN_687], record: &mut QueryRecord, io_buffer: &mut IOBuffer, unconstrained: bool, -) -> Result<[G; OUT_691], ExecError> { +) -> Result<[G; OUT_687], ExecError> { stacker::maybe_grow(64 * 1024, 4 * 1024 * 1024, || { let __v_0: G = inp[0]; let __v_1: G = inp[1]; @@ -58110,12 +57838,12 @@ fn aiur_fn_691( let __v_10: G = G::from_u64(1); let __v_11: G = G::from_u64(1); let __v_12: G = { let __values: [G; 3] = [__v_10, __v_11, __v_11]; let __mq = record.memory_queries.get_mut(&3).ok_or(ExecError::InvalidMemorySize(3))?; if let Some(result) = __mq.get_mut(&__values[..]) { if !unconstrained { *result.multiplicity += G::ONE; } result.output[0] } else { let __ptr = G::from_usize(__mq.len()); __mq.insert(&__values[..], &[__ptr], G::from_bool(!unconstrained)); __ptr } }; - let __ret: [G; OUT_691] = [__v_12]; - if let Some(result) = record.function_queries[691].get_mut(&inp[..]) { debug_assert_eq!(result.output, &__ret[..]); if !unconstrained { *result.multiplicity += G::ONE; } } else { record.function_queries[691].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained)); }; + let __ret: [G; OUT_687] = [__v_12]; + if let Some(result) = record.function_queries[687].get_mut(&inp[..]) { debug_assert_eq!(result.output, &__ret[..]); if !unconstrained { *result.multiplicity += G::ONE; } } else { record.function_queries[687].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained)); }; return Ok(__ret); }, 0u64 => { - let __r_arr: [G; OUT_287] = { let __args: [G; IN_287] = [__v_5]; let __cu = unconstrained; if let Some(result) = record.function_queries[287].get_mut(&__args[..]) { if !__cu && *result.multiplicity == G::ZERO { aiur_fn_287(__args, record, io_buffer, false)? } else { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_287] = unsafe { *(result.output.as_ptr() as *const [G; OUT_287]) }; __ret } } else { aiur_fn_287(__args, record, io_buffer, __cu)? } }; + let __r_arr: [G; OUT_283] = { let __args: [G; IN_283] = [__v_5]; let __cu = unconstrained; if let Some(result) = record.function_queries[283].get_mut(&__args[..]) { if !__cu && *result.multiplicity == G::ZERO { aiur_fn_283(__args, record, io_buffer, false)? } else { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_283] = unsafe { *(result.output.as_ptr() as *const [G; OUT_283]) }; __ret } } else { aiur_fn_283(__args, record, io_buffer, __cu)? } }; let __v_10: G = __r_arr[0]; let __loaded: [G; 12] = { let __mq = record.memory_queries.get_mut(&12).ok_or(ExecError::InvalidMemorySize(12))?; let __ptr_u64 = __v_10.as_canonical_u64(); let __ptr_usize = usize::try_from(__ptr_u64).ok().ok_or(ExecError::PointerTooLarge(__ptr_u64))?; let (__args, __mult) = __mq.get_index_mut(__ptr_usize).ok_or(ExecError::UnboundPointer { ptr: __ptr_u64, size: 12 })?; if !unconstrained { *__mult += G::ONE; } let __arr: [G; 12] = __args[..12].try_into().unwrap(); __arr }; let __v_11: G = __loaded[0]; @@ -58132,26 +57860,26 @@ fn aiur_fn_691( let __v_22: G = __loaded[11]; match __v_11.as_canonical_u64() { 5u64 => { - let __r_arr: [G; OUT_655] = { let __args: [G; IN_655] = [__v_5, __v_13, __v_14, __v_15, __v_8, __v_1, __v_2, __v_6, __v_7]; let __cu = unconstrained; if let Some(result) = record.function_queries[655].get_mut(&__args[..]) { if !__cu && *result.multiplicity == G::ZERO { aiur_fn_655(__args, record, io_buffer, false)? } else { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_655] = unsafe { *(result.output.as_ptr() as *const [G; OUT_655]) }; __ret } } else { aiur_fn_655(__args, record, io_buffer, __cu)? } }; + let __r_arr: [G; OUT_651] = { let __args: [G; IN_651] = [__v_5, __v_13, __v_14, __v_15, __v_8, __v_1, __v_2, __v_6, __v_7]; let __cu = unconstrained; if let Some(result) = record.function_queries[651].get_mut(&__args[..]) { if !__cu && *result.multiplicity == G::ZERO { aiur_fn_651(__args, record, io_buffer, false)? } else { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_651] = unsafe { *(result.output.as_ptr() as *const [G; OUT_651]) }; __ret } } else { aiur_fn_651(__args, record, io_buffer, __cu)? } }; let __v_23: G = __r_arr[0]; let __v_24: G = G::from_u64(0); - let __r_arr: [G; OUT_359] = { let __args: [G; IN_359] = [__v_23, __v_3, __v_24]; let __cu = unconstrained; if let Some(result) = record.function_queries[359].get_mut(&__args[..]) { if !__cu && *result.multiplicity == G::ZERO { aiur_fn_359(__args, record, io_buffer, false)? } else { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_359] = unsafe { *(result.output.as_ptr() as *const [G; OUT_359]) }; __ret } } else { aiur_fn_359(__args, record, io_buffer, __cu)? } }; + let __r_arr: [G; OUT_355] = { let __args: [G; IN_355] = [__v_23, __v_3, __v_24]; let __cu = unconstrained; if let Some(result) = record.function_queries[355].get_mut(&__args[..]) { if !__cu && *result.multiplicity == G::ZERO { aiur_fn_355(__args, record, io_buffer, false)? } else { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_355] = unsafe { *(result.output.as_ptr() as *const [G; OUT_355]) }; __ret } } else { aiur_fn_355(__args, record, io_buffer, __cu)? } }; let __v_25: G = __r_arr[0]; let __v_26: G = G::from_u64(0); let __v_27: G = G::from_u64(1); let __v_28: G = (__v_3 + __v_27); - let __r_arr: [G; OUT_691] = { let __args: [G; IN_691] = [__v_9, __v_1, __v_2, __v_28]; let __cu = unconstrained; if let Some(result) = record.function_queries[691].get_mut(&__args[..]) { if !__cu && *result.multiplicity == G::ZERO { aiur_fn_691(__args, record, io_buffer, false)? } else { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_691] = unsafe { *(result.output.as_ptr() as *const [G; OUT_691]) }; __ret } } else { aiur_fn_691(__args, record, io_buffer, __cu)? } }; + let __r_arr: [G; OUT_687] = { let __args: [G; IN_687] = [__v_9, __v_1, __v_2, __v_28]; let __cu = unconstrained; if let Some(result) = record.function_queries[687].get_mut(&__args[..]) { if !__cu && *result.multiplicity == G::ZERO { aiur_fn_687(__args, record, io_buffer, false)? } else { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_687] = unsafe { *(result.output.as_ptr() as *const [G; OUT_687]) }; __ret } } else { aiur_fn_687(__args, record, io_buffer, __cu)? } }; let __v_29: G = __r_arr[0]; let __v_30: G = { let __values: [G; 3] = [__v_26, __v_25, __v_29]; let __mq = record.memory_queries.get_mut(&3).ok_or(ExecError::InvalidMemorySize(3))?; if let Some(result) = __mq.get_mut(&__values[..]) { if !unconstrained { *result.multiplicity += G::ONE; } result.output[0] } else { let __ptr = G::from_usize(__mq.len()); __mq.insert(&__values[..], &[__ptr], G::from_bool(!unconstrained)); __ptr } }; - let __ret: [G; OUT_691] = [__v_30]; - if let Some(result) = record.function_queries[691].get_mut(&inp[..]) { debug_assert_eq!(result.output, &__ret[..]); if !unconstrained { *result.multiplicity += G::ONE; } } else { record.function_queries[691].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained)); }; + let __ret: [G; OUT_687] = [__v_30]; + if let Some(result) = record.function_queries[687].get_mut(&inp[..]) { debug_assert_eq!(result.output, &__ret[..]); if !unconstrained { *result.multiplicity += G::ONE; } } else { record.function_queries[687].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained)); }; return Ok(__ret); }, _ => { - let __r_arr: [G; OUT_691] = { let __args: [G; IN_691] = [__v_9, __v_1, __v_2, __v_3]; let __cu = unconstrained; if let Some(result) = record.function_queries[691].get_mut(&__args[..]) { if !__cu && *result.multiplicity == G::ZERO { aiur_fn_691(__args, record, io_buffer, false)? } else { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_691] = unsafe { *(result.output.as_ptr() as *const [G; OUT_691]) }; __ret } } else { aiur_fn_691(__args, record, io_buffer, __cu)? } }; + let __r_arr: [G; OUT_687] = { let __args: [G; IN_687] = [__v_9, __v_1, __v_2, __v_3]; let __cu = unconstrained; if let Some(result) = record.function_queries[687].get_mut(&__args[..]) { if !__cu && *result.multiplicity == G::ZERO { aiur_fn_687(__args, record, io_buffer, false)? } else { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_687] = unsafe { *(result.output.as_ptr() as *const [G; OUT_687]) }; __ret } } else { aiur_fn_687(__args, record, io_buffer, __cu)? } }; let __v_23: G = __r_arr[0]; - let __ret: [G; OUT_691] = [__v_23]; - if let Some(result) = record.function_queries[691].get_mut(&inp[..]) { debug_assert_eq!(result.output, &__ret[..]); if !unconstrained { *result.multiplicity += G::ONE; } } else { record.function_queries[691].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained)); }; + let __ret: [G; OUT_687] = [__v_23]; + if let Some(result) = record.function_queries[687].get_mut(&inp[..]) { debug_assert_eq!(result.output, &__ret[..]); if !unconstrained { *result.multiplicity += G::ONE; } } else { record.function_queries[687].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained)); }; return Ok(__ret); }, } @@ -58163,15 +57891,15 @@ fn aiur_fn_691( }) } -const INPUT_SIZE_692: usize = 13; -const IN_692: usize = 13; -const OUT_692: usize = 0; -fn aiur_fn_692( - inp: [G; IN_692], +const INPUT_SIZE_688: usize = 13; +const IN_688: usize = 13; +const OUT_688: usize = 0; +fn aiur_fn_688( + inp: [G; IN_688], record: &mut QueryRecord, io_buffer: &mut IOBuffer, unconstrained: bool, -) -> Result<[G; OUT_692], ExecError> { +) -> Result<[G; OUT_688], ExecError> { stacker::maybe_grow(64 * 1024, 4 * 1024 * 1024, || { let __v_0: G = inp[0]; let __v_1: G = inp[1]; @@ -58188,9 +57916,9 @@ fn aiur_fn_692( let __v_12: G = inp[12]; match __v_0.as_canonical_u64() { 7u64 => { - let __r_arr: [G; OUT_623] = { let __args: [G; IN_623] = [__v_2, __v_3, __v_5, __v_6, __v_4]; let __cu = unconstrained; if let Some(result) = record.function_queries[623].get_mut(&__args[..]) { if !__cu && *result.multiplicity == G::ZERO { aiur_fn_623(__args, record, io_buffer, false)? } else { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_623] = unsafe { *(result.output.as_ptr() as *const [G; OUT_623]) }; __ret } } else { aiur_fn_623(__args, record, io_buffer, __cu)? } }; + let __r_arr: [G; OUT_619] = { let __args: [G; IN_619] = [__v_2, __v_3, __v_5, __v_6, __v_4]; let __cu = unconstrained; if let Some(result) = record.function_queries[619].get_mut(&__args[..]) { if !__cu && *result.multiplicity == G::ZERO { aiur_fn_619(__args, record, io_buffer, false)? } else { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_619] = unsafe { *(result.output.as_ptr() as *const [G; OUT_619]) }; __ret } } else { aiur_fn_619(__args, record, io_buffer, __cu)? } }; let __v_13: G = __r_arr[0]; - let __r_arr: [G; OUT_287] = { let __args: [G; IN_287] = [__v_13]; let __cu = unconstrained; if let Some(result) = record.function_queries[287].get_mut(&__args[..]) { if !__cu && *result.multiplicity == G::ZERO { aiur_fn_287(__args, record, io_buffer, false)? } else { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_287] = unsafe { *(result.output.as_ptr() as *const [G; OUT_287]) }; __ret } } else { aiur_fn_287(__args, record, io_buffer, __cu)? } }; + let __r_arr: [G; OUT_283] = { let __args: [G; IN_283] = [__v_13]; let __cu = unconstrained; if let Some(result) = record.function_queries[283].get_mut(&__args[..]) { if !__cu && *result.multiplicity == G::ZERO { aiur_fn_283(__args, record, io_buffer, false)? } else { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_283] = unsafe { *(result.output.as_ptr() as *const [G; OUT_283]) }; __ret } } else { aiur_fn_283(__args, record, io_buffer, __cu)? } }; let __v_14: G = __r_arr[0]; let __loaded: [G; 12] = { let __mq = record.memory_queries.get_mut(&12).ok_or(ExecError::InvalidMemorySize(12))?; let __ptr_u64 = __v_14.as_canonical_u64(); let __ptr_usize = usize::try_from(__ptr_u64).ok().ok_or(ExecError::PointerTooLarge(__ptr_u64))?; let (__args, __mult) = __mq.get_index_mut(__ptr_usize).ok_or(ExecError::UnboundPointer { ptr: __ptr_u64, size: 12 })?; if !unconstrained { *__mult += G::ONE; } let __arr: [G; 12] = __args[..12].try_into().unwrap(); __arr }; let __v_15: G = __loaded[0]; @@ -58207,9 +57935,9 @@ fn aiur_fn_692( let __v_26: G = __loaded[11]; match __v_15.as_canonical_u64() { 5u64 => { - let __r_arr: [G; OUT_621] = { let __args: [G; IN_621] = [__v_10]; let __cu = unconstrained; if let Some(result) = record.function_queries[621].get_mut(&__args[..]) { if !__cu && *result.multiplicity == G::ZERO { aiur_fn_621(__args, record, io_buffer, false)? } else { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_621] = unsafe { *(result.output.as_ptr() as *const [G; OUT_621]) }; __ret } } else { aiur_fn_621(__args, record, io_buffer, __cu)? } }; + let __r_arr: [G; OUT_617] = { let __args: [G; IN_617] = [__v_10]; let __cu = unconstrained; if let Some(result) = record.function_queries[617].get_mut(&__args[..]) { if !__cu && *result.multiplicity == G::ZERO { aiur_fn_617(__args, record, io_buffer, false)? } else { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_617] = unsafe { *(result.output.as_ptr() as *const [G; OUT_617]) }; __ret } } else { aiur_fn_617(__args, record, io_buffer, __cu)? } }; let __v_27: G = __r_arr[0]; - let __r_arr: [G; OUT_621] = { let __args: [G; IN_621] = [__v_22]; let __cu = unconstrained; if let Some(result) = record.function_queries[621].get_mut(&__args[..]) { if !__cu && *result.multiplicity == G::ZERO { aiur_fn_621(__args, record, io_buffer, false)? } else { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_621] = unsafe { *(result.output.as_ptr() as *const [G; OUT_621]) }; __ret } } else { aiur_fn_621(__args, record, io_buffer, __cu)? } }; + let __r_arr: [G; OUT_617] = { let __args: [G; IN_617] = [__v_22]; let __cu = unconstrained; if let Some(result) = record.function_queries[617].get_mut(&__args[..]) { if !__cu && *result.multiplicity == G::ZERO { aiur_fn_617(__args, record, io_buffer, false)? } else { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_617] = unsafe { *(result.output.as_ptr() as *const [G; OUT_617]) }; __ret } } else { aiur_fn_617(__args, record, io_buffer, __cu)? } }; let __v_28: G = __r_arr[0]; let __v_29: G = G::from_u64(1); let __r_arr: [G; OUT_1] = { let __args: [G; IN_1] = [__v_10, __v_22]; let __cu = unconstrained; if let Some(result) = record.function_queries[1].get_mut(&__args[..]) { if !__cu && *result.multiplicity == G::ZERO { aiur_fn_1(__args, record, io_buffer, false)? } else { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_1] = unsafe { *(result.output.as_ptr() as *const [G; OUT_1]) }; __ret } } else { aiur_fn_1(__args, record, io_buffer, __cu)? } }; @@ -58222,11 +57950,11 @@ fn aiur_fn_692( let __v_36: G = (__v_34 + __v_35); let __v_37: G = G::from_u64(1); let __v_38: G = (__v_36 + __v_37); - let __r_arr: [G; OUT_586] = { let __args: [G; IN_586] = [__v_2, __v_38]; let __cu = unconstrained; if let Some(result) = record.function_queries[586].get_mut(&__args[..]) { if !__cu && *result.multiplicity == G::ZERO { aiur_fn_586(__args, record, io_buffer, false)? } else { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_586] = unsafe { *(result.output.as_ptr() as *const [G; OUT_586]) }; __ret } } else { aiur_fn_586(__args, record, io_buffer, __cu)? } }; + let __r_arr: [G; OUT_582] = { let __args: [G; IN_582] = [__v_2, __v_38]; let __cu = unconstrained; if let Some(result) = record.function_queries[582].get_mut(&__args[..]) { if !__cu && *result.multiplicity == G::ZERO { aiur_fn_582(__args, record, io_buffer, false)? } else { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_582] = unsafe { *(result.output.as_ptr() as *const [G; OUT_582]) }; __ret } } else { aiur_fn_582(__args, record, io_buffer, __cu)? } }; let __v_39: G = __r_arr[0]; let __v_40: G = (__v_5 + __v_6); let __v_41: G = (__v_3 + __v_40); - let __r_arr: [G; OUT_695] = { let __args: [G; IN_695] = [__v_7, __v_41, __v_1]; let __cu = unconstrained; if let Some(result) = record.function_queries[695].get_mut(&__args[..]) { if !__cu && *result.multiplicity == G::ZERO { aiur_fn_695(__args, record, io_buffer, false)? } else { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_695] = unsafe { *(result.output.as_ptr() as *const [G; OUT_695]) }; __ret } } else { aiur_fn_695(__args, record, io_buffer, __cu)? } }; + let __r_arr: [G; OUT_691] = { let __args: [G; IN_691] = [__v_7, __v_41, __v_1]; let __cu = unconstrained; if let Some(result) = record.function_queries[691].get_mut(&__args[..]) { if !__cu && *result.multiplicity == G::ZERO { aiur_fn_691(__args, record, io_buffer, false)? } else { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_691] = unsafe { *(result.output.as_ptr() as *const [G; OUT_691]) }; __ret } } else { aiur_fn_691(__args, record, io_buffer, __cu)? } }; let __mc_out___mc_0: [G; 0] = '__mc_0: { match __v_33.as_canonical_u64() { 1u64 => { break '__mc_0 []; @@ -58239,15 +57967,15 @@ fn aiur_fn_692( return Err(ExecError::AssertEqMismatch { lhs: __v_4.as_canonical_u64(), rhs: __v_19.as_canonical_u64(), msg: Some("recursor index count differs from its inductive's".to_string()) }); } let __v_42: G = (__v_18 + __v_19); - let __r_arr: [G; OUT_693] = { let __args: [G; IN_693] = [__v_2, __v_3, __v_5, __v_6, __v_4, __v_42]; let __cu = unconstrained; if let Some(result) = record.function_queries[693].get_mut(&__args[..]) { if !__cu && *result.multiplicity == G::ZERO { aiur_fn_693(__args, record, io_buffer, false)? } else { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_693] = unsafe { *(result.output.as_ptr() as *const [G; OUT_693]) }; __ret } } else { aiur_fn_693(__args, record, io_buffer, __cu)? } }; + let __r_arr: [G; OUT_689] = { let __args: [G; IN_689] = [__v_2, __v_3, __v_5, __v_6, __v_4, __v_42]; let __cu = unconstrained; if let Some(result) = record.function_queries[689].get_mut(&__args[..]) { if !__cu && *result.multiplicity == G::ZERO { aiur_fn_689(__args, record, io_buffer, false)? } else { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_689] = unsafe { *(result.output.as_ptr() as *const [G; OUT_689]) }; __ret } } else { aiur_fn_689(__args, record, io_buffer, __cu)? } }; break '__mc_0 []; }, } }; - let __r_arr: [G; OUT_619] = { let __args: [G; IN_619] = [__v_15, __v_16, __v_17, __v_18, __v_19, __v_20, __v_21, __v_22, __v_23, __v_24, __v_25, __v_26, __v_13]; let __cu = unconstrained; if let Some(result) = record.function_queries[619].get_mut(&__args[..]) { if !__cu && *result.multiplicity == G::ZERO { aiur_fn_619(__args, record, io_buffer, false)? } else { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_619] = unsafe { *(result.output.as_ptr() as *const [G; OUT_619]) }; __ret } } else { aiur_fn_619(__args, record, io_buffer, __cu)? } }; + let __r_arr: [G; OUT_615] = { let __args: [G; IN_615] = [__v_15, __v_16, __v_17, __v_18, __v_19, __v_20, __v_21, __v_22, __v_23, __v_24, __v_25, __v_26, __v_13]; let __cu = unconstrained; if let Some(result) = record.function_queries[615].get_mut(&__args[..]) { if !__cu && *result.multiplicity == G::ZERO { aiur_fn_615(__args, record, io_buffer, false)? } else { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_615] = unsafe { *(result.output.as_ptr() as *const [G; OUT_615]) }; __ret } } else { aiur_fn_615(__args, record, io_buffer, __cu)? } }; let __v_42: G = __r_arr[0]; - let __r_arr: [G; OUT_611] = { let __args: [G; IN_611] = [__v_15, __v_16, __v_17, __v_18, __v_19, __v_20, __v_21, __v_22, __v_23, __v_24, __v_25, __v_26]; let __cu = unconstrained; if let Some(result) = record.function_queries[611].get_mut(&__args[..]) { if !__cu && *result.multiplicity == G::ZERO { aiur_fn_611(__args, record, io_buffer, false)? } else { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_611] = unsafe { *(result.output.as_ptr() as *const [G; OUT_611]) }; __ret } } else { aiur_fn_611(__args, record, io_buffer, __cu)? } }; - let __r_arr: [G; OUT_776] = { let __args: [G; IN_776] = [__v_7]; let __cu = unconstrained; if let Some(result) = record.function_queries[776].get_mut(&__args[..]) { if !__cu && *result.multiplicity == G::ZERO { aiur_fn_776(__args, record, io_buffer, false)? } else { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_776] = unsafe { *(result.output.as_ptr() as *const [G; OUT_776]) }; __ret } } else { aiur_fn_776(__args, record, io_buffer, __cu)? } }; + let __r_arr: [G; OUT_607] = { let __args: [G; IN_607] = [__v_15, __v_16, __v_17, __v_18, __v_19, __v_20, __v_21, __v_22, __v_23, __v_24, __v_25, __v_26]; let __cu = unconstrained; if let Some(result) = record.function_queries[607].get_mut(&__args[..]) { if !__cu && *result.multiplicity == G::ZERO { aiur_fn_607(__args, record, io_buffer, false)? } else { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_607] = unsafe { *(result.output.as_ptr() as *const [G; OUT_607]) }; __ret } } else { aiur_fn_607(__args, record, io_buffer, __cu)? } }; + let __r_arr: [G; OUT_772] = { let __args: [G; IN_772] = [__v_7]; let __cu = unconstrained; if let Some(result) = record.function_queries[772].get_mut(&__args[..]) { if !__cu && *result.multiplicity == G::ZERO { aiur_fn_772(__args, record, io_buffer, false)? } else { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_772] = unsafe { *(result.output.as_ptr() as *const [G; OUT_772]) }; __ret } } else { aiur_fn_772(__args, record, io_buffer, __cu)? } }; let __v_43: G = __r_arr[0]; if (__v_43 != __v_20) { return Err(ExecError::AssertEqMismatch { lhs: __v_43.as_canonical_u64(), rhs: __v_20.as_canonical_u64(), msg: Some("recursor rule count differs from the inductive's ctor count".to_string()) }); @@ -58255,9 +57983,9 @@ fn aiur_fn_692( if (__v_8 != __v_42) { return Err(ExecError::AssertEqMismatch { lhs: __v_8.as_canonical_u64(), rhs: __v_42.as_canonical_u64(), msg: Some("recursor k_flag disagrees with its inductive's K eligibility".to_string()) }); } - let __r_arr: [G; OUT_661] = { let __args: [G; IN_661] = [__v_0, __v_1, __v_2, __v_3, __v_4, __v_5, __v_6, __v_7, __v_8, __v_9, __v_10, __v_11, __v_12, __v_15, __v_16, __v_17, __v_18, __v_19, __v_20, __v_21, __v_22, __v_23, __v_24, __v_25, __v_26, __v_13]; let __cu = unconstrained; if let Some(result) = record.function_queries[661].get_mut(&__args[..]) { if !__cu && *result.multiplicity == G::ZERO { aiur_fn_661(__args, record, io_buffer, false)? } else { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_661] = unsafe { *(result.output.as_ptr() as *const [G; OUT_661]) }; __ret } } else { aiur_fn_661(__args, record, io_buffer, __cu)? } }; - let __ret: [G; OUT_692] = []; - if let Some(result) = record.function_queries[692].get_mut(&inp[..]) { debug_assert_eq!(result.output, &__ret[..]); if !unconstrained { *result.multiplicity += G::ONE; } } else { record.function_queries[692].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained)); }; + let __r_arr: [G; OUT_657] = { let __args: [G; IN_657] = [__v_0, __v_1, __v_2, __v_3, __v_4, __v_5, __v_6, __v_7, __v_8, __v_9, __v_10, __v_11, __v_12, __v_15, __v_16, __v_17, __v_18, __v_19, __v_20, __v_21, __v_22, __v_23, __v_24, __v_25, __v_26, __v_13]; let __cu = unconstrained; if let Some(result) = record.function_queries[657].get_mut(&__args[..]) { if !__cu && *result.multiplicity == G::ZERO { aiur_fn_657(__args, record, io_buffer, false)? } else { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_657] = unsafe { *(result.output.as_ptr() as *const [G; OUT_657]) }; __ret } } else { aiur_fn_657(__args, record, io_buffer, __cu)? } }; + let __ret: [G; OUT_688] = []; + if let Some(result) = record.function_queries[688].get_mut(&inp[..]) { debug_assert_eq!(result.output, &__ret[..]); if !unconstrained { *result.multiplicity += G::ONE; } } else { record.function_queries[688].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained)); }; return Ok(__ret); }, _ => { @@ -58272,15 +58000,15 @@ fn aiur_fn_692( }) } -const INPUT_SIZE_693: usize = 6; -const IN_693: usize = 6; -const OUT_693: usize = 0; -fn aiur_fn_693( - inp: [G; IN_693], +const INPUT_SIZE_689: usize = 6; +const IN_689: usize = 6; +const OUT_689: usize = 0; +fn aiur_fn_689( + inp: [G; IN_689], record: &mut QueryRecord, io_buffer: &mut IOBuffer, unconstrained: bool, -) -> Result<[G; OUT_693], ExecError> { +) -> Result<[G; OUT_689], ExecError> { stacker::maybe_grow(64 * 1024, 4 * 1024 * 1024, || { let __v_0: G = inp[0]; let __v_1: G = inp[1]; @@ -58291,7 +58019,7 @@ fn aiur_fn_693( let __v_6: G = (__v_3 + __v_4); let __v_7: G = (__v_2 + __v_6); let __v_8: G = (__v_1 + __v_7); - let __r_arr: [G; OUT_586] = { let __args: [G; IN_586] = [__v_0, __v_8]; let __cu = unconstrained; if let Some(result) = record.function_queries[586].get_mut(&__args[..]) { if !__cu && *result.multiplicity == G::ZERO { aiur_fn_586(__args, record, io_buffer, false)? } else { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_586] = unsafe { *(result.output.as_ptr() as *const [G; OUT_586]) }; __ret } } else { aiur_fn_586(__args, record, io_buffer, __cu)? } }; + let __r_arr: [G; OUT_582] = { let __args: [G; IN_582] = [__v_0, __v_8]; let __cu = unconstrained; if let Some(result) = record.function_queries[582].get_mut(&__args[..]) { if !__cu && *result.multiplicity == G::ZERO { aiur_fn_582(__args, record, io_buffer, false)? } else { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_582] = unsafe { *(result.output.as_ptr() as *const [G; OUT_582]) }; __ret } } else { aiur_fn_582(__args, record, io_buffer, __cu)? } }; let __v_9: G = __r_arr[0]; let __loaded: [G; 4] = { let __mq = record.memory_queries.get_mut(&4).ok_or(ExecError::InvalidMemorySize(4))?; let __ptr_u64 = __v_9.as_canonical_u64(); let __ptr_usize = usize::try_from(__ptr_u64).ok().ok_or(ExecError::PointerTooLarge(__ptr_u64))?; let (__args, __mult) = __mq.get_index_mut(__ptr_usize).ok_or(ExecError::UnboundPointer { ptr: __ptr_u64, size: 4 })?; if !unconstrained { *__mult += G::ONE; } let __arr: [G; 4] = __args[..4].try_into().unwrap(); __arr }; let __v_10: G = __loaded[0]; @@ -58303,13 +58031,13 @@ fn aiur_fn_693( let __r_arr: [G; OUT_111] = { let __args: [G; IN_111] = [__v_11]; let __cu = unconstrained; if let Some(result) = record.function_queries[111].get_mut(&__args[..]) { if !__cu && *result.multiplicity == G::ZERO { aiur_fn_111(__args, record, io_buffer, false)? } else { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_111] = unsafe { *(result.output.as_ptr() as *const [G; OUT_111]) }; __ret } } else { aiur_fn_111(__args, record, io_buffer, __cu)? } }; let __v_14: G = __r_arr[0]; let __v_15: G = __r_arr[1]; - let __r_arr: [G; OUT_764] = { let __args: [G; IN_764] = [__v_15]; let __cu = unconstrained; if let Some(result) = record.function_queries[764].get_mut(&__args[..]) { if !__cu && *result.multiplicity == G::ZERO { aiur_fn_764(__args, record, io_buffer, false)? } else { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_764] = unsafe { *(result.output.as_ptr() as *const [G; OUT_764]) }; __ret } } else { aiur_fn_764(__args, record, io_buffer, __cu)? } }; + let __r_arr: [G; OUT_760] = { let __args: [G; IN_760] = [__v_15]; let __cu = unconstrained; if let Some(result) = record.function_queries[760].get_mut(&__args[..]) { if !__cu && *result.multiplicity == G::ZERO { aiur_fn_760(__args, record, io_buffer, false)? } else { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_760] = unsafe { *(result.output.as_ptr() as *const [G; OUT_760]) }; __ret } } else { aiur_fn_760(__args, record, io_buffer, __cu)? } }; let __v_16: G = __r_arr[0]; if (__v_16 != __v_5) { return Err(ExecError::AssertEqMismatch { lhs: __v_16.as_canonical_u64(), rhs: __v_5.as_canonical_u64(), msg: Some("recursor major premise has the wrong number of spine args".to_string()) }); } - let __ret: [G; OUT_693] = []; - if let Some(result) = record.function_queries[693].get_mut(&inp[..]) { debug_assert_eq!(result.output, &__ret[..]); if !unconstrained { *result.multiplicity += G::ONE; } } else { record.function_queries[693].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained)); }; + let __ret: [G; OUT_689] = []; + if let Some(result) = record.function_queries[689].get_mut(&inp[..]) { debug_assert_eq!(result.output, &__ret[..]); if !unconstrained { *result.multiplicity += G::ONE; } } else { record.function_queries[689].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained)); }; return Ok(__ret); }, _ => { @@ -58319,15 +58047,15 @@ fn aiur_fn_693( }) } -const INPUT_SIZE_694: usize = 2; -const IN_694: usize = 2; -const OUT_694: usize = 1; -fn aiur_fn_694( - inp: [G; IN_694], +const INPUT_SIZE_690: usize = 2; +const IN_690: usize = 2; +const OUT_690: usize = 1; +fn aiur_fn_690( + inp: [G; IN_690], record: &mut QueryRecord, io_buffer: &mut IOBuffer, unconstrained: bool, -) -> Result<[G; OUT_694], ExecError> { +) -> Result<[G; OUT_690], ExecError> { stacker::maybe_grow(64 * 1024, 4 * 1024 * 1024, || { let __v_0: G = inp[0]; let __v_1: G = inp[1]; @@ -58337,8 +58065,8 @@ fn aiur_fn_694( let __v_3: G = G::from_u64(1); let __v_4: G = G::from_u64(1); let __v_5: G = { let __values: [G; 3] = [__v_3, __v_4, __v_4]; let __mq = record.memory_queries.get_mut(&3).ok_or(ExecError::InvalidMemorySize(3))?; if let Some(result) = __mq.get_mut(&__values[..]) { if !unconstrained { *result.multiplicity += G::ONE; } result.output[0] } else { let __ptr = G::from_usize(__mq.len()); __mq.insert(&__values[..], &[__ptr], G::from_bool(!unconstrained)); __ptr } }; - let __ret: [G; OUT_694] = [__v_5]; - if let Some(result) = record.function_queries[694].get_mut(&inp[..]) { debug_assert_eq!(result.output, &__ret[..]); if !unconstrained { *result.multiplicity += G::ONE; } } else { record.function_queries[694].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained)); }; + let __ret: [G; OUT_690] = [__v_5]; + if let Some(result) = record.function_queries[690].get_mut(&inp[..]) { debug_assert_eq!(result.output, &__ret[..]); if !unconstrained { *result.multiplicity += G::ONE; } } else { record.function_queries[690].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained)); }; return Ok(__ret); }, _ => { @@ -58348,26 +58076,26 @@ fn aiur_fn_694( let __v_6: G = { let __values: [G; 3] = [__v_4, __v_1, __v_5]; let __mq = record.memory_queries.get_mut(&3).ok_or(ExecError::InvalidMemorySize(3))?; if let Some(result) = __mq.get_mut(&__values[..]) { if !unconstrained { *result.multiplicity += G::ONE; } result.output[0] } else { let __ptr = G::from_usize(__mq.len()); __mq.insert(&__values[..], &[__ptr], G::from_bool(!unconstrained)); __ptr } }; let __v_7: G = G::from_u64(1); let __v_8: G = (__v_1 + __v_7); - let __r_arr: [G; OUT_694] = { let __args: [G; IN_694] = [__v_0, __v_8]; let __cu = unconstrained; if let Some(result) = record.function_queries[694].get_mut(&__args[..]) { if !__cu && *result.multiplicity == G::ZERO { aiur_fn_694(__args, record, io_buffer, false)? } else { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_694] = unsafe { *(result.output.as_ptr() as *const [G; OUT_694]) }; __ret } } else { aiur_fn_694(__args, record, io_buffer, __cu)? } }; + let __r_arr: [G; OUT_690] = { let __args: [G; IN_690] = [__v_0, __v_8]; let __cu = unconstrained; if let Some(result) = record.function_queries[690].get_mut(&__args[..]) { if !__cu && *result.multiplicity == G::ZERO { aiur_fn_690(__args, record, io_buffer, false)? } else { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_690] = unsafe { *(result.output.as_ptr() as *const [G; OUT_690]) }; __ret } } else { aiur_fn_690(__args, record, io_buffer, __cu)? } }; let __v_9: G = __r_arr[0]; let __v_10: G = { let __values: [G; 3] = [__v_3, __v_6, __v_9]; let __mq = record.memory_queries.get_mut(&3).ok_or(ExecError::InvalidMemorySize(3))?; if let Some(result) = __mq.get_mut(&__values[..]) { if !unconstrained { *result.multiplicity += G::ONE; } result.output[0] } else { let __ptr = G::from_usize(__mq.len()); __mq.insert(&__values[..], &[__ptr], G::from_bool(!unconstrained)); __ptr } }; - let __ret: [G; OUT_694] = [__v_10]; - if let Some(result) = record.function_queries[694].get_mut(&inp[..]) { debug_assert_eq!(result.output, &__ret[..]); if !unconstrained { *result.multiplicity += G::ONE; } } else { record.function_queries[694].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained)); }; + let __ret: [G; OUT_690] = [__v_10]; + if let Some(result) = record.function_queries[690].get_mut(&inp[..]) { debug_assert_eq!(result.output, &__ret[..]); if !unconstrained { *result.multiplicity += G::ONE; } } else { record.function_queries[690].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained)); }; return Ok(__ret); }, } }) } -const INPUT_SIZE_695: usize = 3; -const IN_695: usize = 3; -const OUT_695: usize = 0; -fn aiur_fn_695( - inp: [G; IN_695], +const INPUT_SIZE_691: usize = 3; +const IN_691: usize = 3; +const OUT_691: usize = 0; +fn aiur_fn_691( + inp: [G; IN_691], record: &mut QueryRecord, io_buffer: &mut IOBuffer, unconstrained: bool, -) -> Result<[G; OUT_695], ExecError> { +) -> Result<[G; OUT_691], ExecError> { stacker::maybe_grow(64 * 1024, 4 * 1024 * 1024, || { let __v_0: G = inp[0]; let __v_1: G = inp[1]; @@ -58380,18 +58108,18 @@ fn aiur_fn_695( let __v_7: G = __loaded[4]; match __v_3.as_canonical_u64() { 1u64 => { - let __ret: [G; OUT_695] = []; - if let Some(result) = record.function_queries[695].get_mut(&inp[..]) { debug_assert_eq!(result.output, &__ret[..]); if !unconstrained { *result.multiplicity += G::ONE; } } else { record.function_queries[695].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained)); }; + let __ret: [G; OUT_691] = []; + if let Some(result) = record.function_queries[691].get_mut(&inp[..]) { debug_assert_eq!(result.output, &__ret[..]); if !unconstrained { *result.multiplicity += G::ONE; } } else { record.function_queries[691].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained)); }; return Ok(__ret); }, 0u64 => { match __v_4.as_canonical_u64() { _ => { let __v_8: G = (__v_1 + __v_5); - let __r_arr: [G; OUT_581] = { let __args: [G; IN_581] = [__v_6, __v_8, __v_2]; let __cu = unconstrained; if let Some(result) = record.function_queries[581].get_mut(&__args[..]) { if !__cu && *result.multiplicity == G::ZERO { aiur_fn_581(__args, record, io_buffer, false)? } else { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_581] = unsafe { *(result.output.as_ptr() as *const [G; OUT_581]) }; __ret } } else { aiur_fn_581(__args, record, io_buffer, __cu)? } }; - let __r_arr: [G; OUT_695] = { let __args: [G; IN_695] = [__v_7, __v_1, __v_2]; let __cu = unconstrained; if let Some(result) = record.function_queries[695].get_mut(&__args[..]) { if !__cu && *result.multiplicity == G::ZERO { aiur_fn_695(__args, record, io_buffer, false)? } else { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_695] = unsafe { *(result.output.as_ptr() as *const [G; OUT_695]) }; __ret } } else { aiur_fn_695(__args, record, io_buffer, __cu)? } }; - let __ret: [G; OUT_695] = []; - if let Some(result) = record.function_queries[695].get_mut(&inp[..]) { debug_assert_eq!(result.output, &__ret[..]); if !unconstrained { *result.multiplicity += G::ONE; } } else { record.function_queries[695].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained)); }; + let __r_arr: [G; OUT_577] = { let __args: [G; IN_577] = [__v_6, __v_8, __v_2]; let __cu = unconstrained; if let Some(result) = record.function_queries[577].get_mut(&__args[..]) { if !__cu && *result.multiplicity == G::ZERO { aiur_fn_577(__args, record, io_buffer, false)? } else { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_577] = unsafe { *(result.output.as_ptr() as *const [G; OUT_577]) }; __ret } } else { aiur_fn_577(__args, record, io_buffer, __cu)? } }; + let __r_arr: [G; OUT_691] = { let __args: [G; IN_691] = [__v_7, __v_1, __v_2]; let __cu = unconstrained; if let Some(result) = record.function_queries[691].get_mut(&__args[..]) { if !__cu && *result.multiplicity == G::ZERO { aiur_fn_691(__args, record, io_buffer, false)? } else { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_691] = unsafe { *(result.output.as_ptr() as *const [G; OUT_691]) }; __ret } } else { aiur_fn_691(__args, record, io_buffer, __cu)? } }; + let __ret: [G; OUT_691] = []; + if let Some(result) = record.function_queries[691].get_mut(&inp[..]) { debug_assert_eq!(result.output, &__ret[..]); if !unconstrained { *result.multiplicity += G::ONE; } } else { record.function_queries[691].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained)); }; return Ok(__ret); }, } @@ -58403,15 +58131,15 @@ fn aiur_fn_695( }) } -const INPUT_SIZE_696: usize = 4; -const IN_696: usize = 4; -const OUT_696: usize = 3; -fn aiur_fn_696( - inp: [G; IN_696], +const INPUT_SIZE_692: usize = 4; +const IN_692: usize = 4; +const OUT_692: usize = 3; +fn aiur_fn_692( + inp: [G; IN_692], record: &mut QueryRecord, io_buffer: &mut IOBuffer, unconstrained: bool, -) -> Result<[G; OUT_696], ExecError> { +) -> Result<[G; OUT_692], ExecError> { stacker::maybe_grow(64 * 1024, 4 * 1024 * 1024, || { let __v_0: G = inp[0]; let __v_1: G = inp[1]; @@ -58419,8 +58147,8 @@ fn aiur_fn_696( let __v_3: G = inp[3]; match __v_1.as_canonical_u64() { 0u64 => { - let __ret: [G; OUT_696] = [__v_0, __v_2, __v_3]; - if let Some(result) = record.function_queries[696].get_mut(&inp[..]) { debug_assert_eq!(result.output, &__ret[..]); if !unconstrained { *result.multiplicity += G::ONE; } } else { record.function_queries[696].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained)); }; + let __ret: [G; OUT_692] = [__v_0, __v_2, __v_3]; + if let Some(result) = record.function_queries[692].get_mut(&inp[..]) { debug_assert_eq!(result.output, &__ret[..]); if !unconstrained { *result.multiplicity += G::ONE; } } else { record.function_queries[692].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained)); }; return Ok(__ret); }, _ => { @@ -58437,17 +58165,17 @@ fn aiur_fn_696( let __v_11: G = (__v_2 + __v_10); let __v_12: G = G::from_u64(0); let __v_13: G = { let __values: [G; 3] = [__v_12, __v_5, __v_3]; let __mq = record.memory_queries.get_mut(&3).ok_or(ExecError::InvalidMemorySize(3))?; if let Some(result) = __mq.get_mut(&__values[..]) { if !unconstrained { *result.multiplicity += G::ONE; } result.output[0] } else { let __ptr = G::from_usize(__mq.len()); __mq.insert(&__values[..], &[__ptr], G::from_bool(!unconstrained)); __ptr } }; - let __r_arr: [G; OUT_696] = { let __args: [G; IN_696] = [__v_6, __v_9, __v_11, __v_13]; let __cu = unconstrained; if let Some(result) = record.function_queries[696].get_mut(&__args[..]) { if !__cu && *result.multiplicity == G::ZERO { aiur_fn_696(__args, record, io_buffer, false)? } else { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_696] = unsafe { *(result.output.as_ptr() as *const [G; OUT_696]) }; __ret } } else { aiur_fn_696(__args, record, io_buffer, __cu)? } }; + let __r_arr: [G; OUT_692] = { let __args: [G; IN_692] = [__v_6, __v_9, __v_11, __v_13]; let __cu = unconstrained; if let Some(result) = record.function_queries[692].get_mut(&__args[..]) { if !__cu && *result.multiplicity == G::ZERO { aiur_fn_692(__args, record, io_buffer, false)? } else { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_692] = unsafe { *(result.output.as_ptr() as *const [G; OUT_692]) }; __ret } } else { aiur_fn_692(__args, record, io_buffer, __cu)? } }; let __v_14: G = __r_arr[0]; let __v_15: G = __r_arr[1]; let __v_16: G = __r_arr[2]; - let __ret: [G; OUT_696] = [__v_14, __v_15, __v_16]; - if let Some(result) = record.function_queries[696].get_mut(&inp[..]) { debug_assert_eq!(result.output, &__ret[..]); if !unconstrained { *result.multiplicity += G::ONE; } } else { record.function_queries[696].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained)); }; + let __ret: [G; OUT_692] = [__v_14, __v_15, __v_16]; + if let Some(result) = record.function_queries[692].get_mut(&inp[..]) { debug_assert_eq!(result.output, &__ret[..]); if !unconstrained { *result.multiplicity += G::ONE; } } else { record.function_queries[692].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained)); }; return Ok(__ret); }, _ => { - let __ret: [G; OUT_696] = [__v_0, __v_2, __v_3]; - if let Some(result) = record.function_queries[696].get_mut(&inp[..]) { debug_assert_eq!(result.output, &__ret[..]); if !unconstrained { *result.multiplicity += G::ONE; } } else { record.function_queries[696].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained)); }; + let __ret: [G; OUT_692] = [__v_0, __v_2, __v_3]; + if let Some(result) = record.function_queries[692].get_mut(&inp[..]) { debug_assert_eq!(result.output, &__ret[..]); if !unconstrained { *result.multiplicity += G::ONE; } } else { record.function_queries[692].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained)); }; return Ok(__ret); }, } @@ -58456,15 +58184,15 @@ fn aiur_fn_696( }) } -const INPUT_SIZE_697: usize = 13; -const IN_697: usize = 13; -const OUT_697: usize = 0; -fn aiur_fn_697( - inp: [G; IN_697], +const INPUT_SIZE_693: usize = 13; +const IN_693: usize = 13; +const OUT_693: usize = 0; +fn aiur_fn_693( + inp: [G; IN_693], record: &mut QueryRecord, io_buffer: &mut IOBuffer, unconstrained: bool, -) -> Result<[G; OUT_697], ExecError> { +) -> Result<[G; OUT_693], ExecError> { stacker::maybe_grow(64 * 1024, 4 * 1024 * 1024, || { let __v_0: G = inp[0]; let __v_1: G = inp[1]; @@ -58479,58 +58207,58 @@ fn aiur_fn_697( let __v_10: G = inp[10]; let __v_11: G = inp[11]; let __v_12: G = inp[12]; - let __r_arr: [G; OUT_576] = { let __args: [G; IN_576] = [__v_0, __v_1, __v_2, __v_3, __v_4, __v_5, __v_6, __v_7, __v_8, __v_9, __v_10, __v_11]; let __cu = unconstrained; if let Some(result) = record.function_queries[576].get_mut(&__args[..]) { if !__cu && *result.multiplicity == G::ZERO { aiur_fn_576(__args, record, io_buffer, false)? } else { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_576] = unsafe { *(result.output.as_ptr() as *const [G; OUT_576]) }; __ret } } else { aiur_fn_576(__args, record, io_buffer, __cu)? } }; + let __r_arr: [G; OUT_572] = { let __args: [G; IN_572] = [__v_0, __v_1, __v_2, __v_3, __v_4, __v_5, __v_6, __v_7, __v_8, __v_9, __v_10, __v_11]; let __cu = unconstrained; if let Some(result) = record.function_queries[572].get_mut(&__args[..]) { if !__cu && *result.multiplicity == G::ZERO { aiur_fn_572(__args, record, io_buffer, false)? } else { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_572] = unsafe { *(result.output.as_ptr() as *const [G; OUT_572]) }; __ret } } else { aiur_fn_572(__args, record, io_buffer, __cu)? } }; let __v_13: G = __r_arr[0]; match __v_0.as_canonical_u64() { 0u64 => { let __v_14: G = G::from_u64(0); - let __r_arr: [G; OUT_581] = { let __args: [G; IN_581] = [__v_2, __v_14, __v_1]; let __cu = unconstrained; if let Some(result) = record.function_queries[581].get_mut(&__args[..]) { if !__cu && *result.multiplicity == G::ZERO { aiur_fn_581(__args, record, io_buffer, false)? } else { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_581] = unsafe { *(result.output.as_ptr() as *const [G; OUT_581]) }; __ret } } else { aiur_fn_581(__args, record, io_buffer, __cu)? } }; + let __r_arr: [G; OUT_577] = { let __args: [G; IN_577] = [__v_2, __v_14, __v_1]; let __cu = unconstrained; if let Some(result) = record.function_queries[577].get_mut(&__args[..]) { if !__cu && *result.multiplicity == G::ZERO { aiur_fn_577(__args, record, io_buffer, false)? } else { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_577] = unsafe { *(result.output.as_ptr() as *const [G; OUT_577]) }; __ret } } else { aiur_fn_577(__args, record, io_buffer, __cu)? } }; let __v_15: G = G::from_u64(1); let __v_16: G = G::from_u64(1); let __v_17: G = { let __values: [G; 3] = [__v_15, __v_16, __v_16]; let __mq = record.memory_queries.get_mut(&3).ok_or(ExecError::InvalidMemorySize(3))?; if let Some(result) = __mq.get_mut(&__values[..]) { if !unconstrained { *result.multiplicity += G::ONE; } result.output[0] } else { let __ptr = G::from_usize(__mq.len()); __mq.insert(&__values[..], &[__ptr], G::from_bool(!unconstrained)); __ptr } }; - let __r_arr: [G; OUT_499] = { let __args: [G; IN_499] = [__v_2, __v_17]; let __cu = unconstrained; if let Some(result) = record.function_queries[499].get_mut(&__args[..]) { if !__cu && *result.multiplicity == G::ZERO { aiur_fn_499(__args, record, io_buffer, false)? } else { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_499] = unsafe { *(result.output.as_ptr() as *const [G; OUT_499]) }; __ret } } else { aiur_fn_499(__args, record, io_buffer, __cu)? } }; + let __r_arr: [G; OUT_495] = { let __args: [G; IN_495] = [__v_2, __v_17]; let __cu = unconstrained; if let Some(result) = record.function_queries[495].get_mut(&__args[..]) { if !__cu && *result.multiplicity == G::ZERO { aiur_fn_495(__args, record, io_buffer, false)? } else { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_495] = unsafe { *(result.output.as_ptr() as *const [G; OUT_495]) }; __ret } } else { aiur_fn_495(__args, record, io_buffer, __cu)? } }; let __v_18: G = __r_arr[0]; - let __r_arr: [G; OUT_578] = { let __args: [G; IN_578] = [__v_13, __v_2]; let __cu = unconstrained; if let Some(result) = record.function_queries[578].get_mut(&__args[..]) { if !__cu && *result.multiplicity == G::ZERO { aiur_fn_578(__args, record, io_buffer, false)? } else { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_578] = unsafe { *(result.output.as_ptr() as *const [G; OUT_578]) }; __ret } } else { aiur_fn_578(__args, record, io_buffer, __cu)? } }; - let __ret: [G; OUT_697] = []; - if let Some(result) = record.function_queries[697].get_mut(&inp[..]) { debug_assert_eq!(result.output, &__ret[..]); if !unconstrained { *result.multiplicity += G::ONE; } } else { record.function_queries[697].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained)); }; + let __r_arr: [G; OUT_574] = { let __args: [G; IN_574] = [__v_13, __v_2]; let __cu = unconstrained; if let Some(result) = record.function_queries[574].get_mut(&__args[..]) { if !__cu && *result.multiplicity == G::ZERO { aiur_fn_574(__args, record, io_buffer, false)? } else { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_574] = unsafe { *(result.output.as_ptr() as *const [G; OUT_574]) }; __ret } } else { aiur_fn_574(__args, record, io_buffer, __cu)? } }; + let __ret: [G; OUT_693] = []; + if let Some(result) = record.function_queries[693].get_mut(&inp[..]) { debug_assert_eq!(result.output, &__ret[..]); if !unconstrained { *result.multiplicity += G::ONE; } } else { record.function_queries[693].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained)); }; return Ok(__ret); }, 1u64 => { let __v_14: G = G::from_u64(0); - let __r_arr: [G; OUT_581] = { let __args: [G; IN_581] = [__v_2, __v_14, __v_1]; let __cu = unconstrained; if let Some(result) = record.function_queries[581].get_mut(&__args[..]) { if !__cu && *result.multiplicity == G::ZERO { aiur_fn_581(__args, record, io_buffer, false)? } else { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_581] = unsafe { *(result.output.as_ptr() as *const [G; OUT_581]) }; __ret } } else { aiur_fn_581(__args, record, io_buffer, __cu)? } }; + let __r_arr: [G; OUT_577] = { let __args: [G; IN_577] = [__v_2, __v_14, __v_1]; let __cu = unconstrained; if let Some(result) = record.function_queries[577].get_mut(&__args[..]) { if !__cu && *result.multiplicity == G::ZERO { aiur_fn_577(__args, record, io_buffer, false)? } else { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_577] = unsafe { *(result.output.as_ptr() as *const [G; OUT_577]) }; __ret } } else { aiur_fn_577(__args, record, io_buffer, __cu)? } }; let __v_15: G = G::from_u64(0); - let __r_arr: [G; OUT_581] = { let __args: [G; IN_581] = [__v_3, __v_15, __v_1]; let __cu = unconstrained; if let Some(result) = record.function_queries[581].get_mut(&__args[..]) { if !__cu && *result.multiplicity == G::ZERO { aiur_fn_581(__args, record, io_buffer, false)? } else { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_581] = unsafe { *(result.output.as_ptr() as *const [G; OUT_581]) }; __ret } } else { aiur_fn_581(__args, record, io_buffer, __cu)? } }; + let __r_arr: [G; OUT_577] = { let __args: [G; IN_577] = [__v_3, __v_15, __v_1]; let __cu = unconstrained; if let Some(result) = record.function_queries[577].get_mut(&__args[..]) { if !__cu && *result.multiplicity == G::ZERO { aiur_fn_577(__args, record, io_buffer, false)? } else { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_577] = unsafe { *(result.output.as_ptr() as *const [G; OUT_577]) }; __ret } } else { aiur_fn_577(__args, record, io_buffer, __cu)? } }; let __v_16: G = G::from_u64(1); let __v_17: G = G::from_u64(1); let __v_18: G = { let __values: [G; 3] = [__v_16, __v_17, __v_17]; let __mq = record.memory_queries.get_mut(&3).ok_or(ExecError::InvalidMemorySize(3))?; if let Some(result) = __mq.get_mut(&__values[..]) { if !unconstrained { *result.multiplicity += G::ONE; } result.output[0] } else { let __ptr = G::from_usize(__mq.len()); __mq.insert(&__values[..], &[__ptr], G::from_bool(!unconstrained)); __ptr } }; - let __r_arr: [G; OUT_499] = { let __args: [G; IN_499] = [__v_2, __v_18]; let __cu = unconstrained; if let Some(result) = record.function_queries[499].get_mut(&__args[..]) { if !__cu && *result.multiplicity == G::ZERO { aiur_fn_499(__args, record, io_buffer, false)? } else { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_499] = unsafe { *(result.output.as_ptr() as *const [G; OUT_499]) }; __ret } } else { aiur_fn_499(__args, record, io_buffer, __cu)? } }; + let __r_arr: [G; OUT_495] = { let __args: [G; IN_495] = [__v_2, __v_18]; let __cu = unconstrained; if let Some(result) = record.function_queries[495].get_mut(&__args[..]) { if !__cu && *result.multiplicity == G::ZERO { aiur_fn_495(__args, record, io_buffer, false)? } else { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_495] = unsafe { *(result.output.as_ptr() as *const [G; OUT_495]) }; __ret } } else { aiur_fn_495(__args, record, io_buffer, __cu)? } }; let __v_19: G = __r_arr[0]; - let __r_arr: [G; OUT_578] = { let __args: [G; IN_578] = [__v_13, __v_2]; let __cu = unconstrained; if let Some(result) = record.function_queries[578].get_mut(&__args[..]) { if !__cu && *result.multiplicity == G::ZERO { aiur_fn_578(__args, record, io_buffer, false)? } else { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_578] = unsafe { *(result.output.as_ptr() as *const [G; OUT_578]) }; __ret } } else { aiur_fn_578(__args, record, io_buffer, __cu)? } }; - let __r_arr: [G; OUT_578] = { let __args: [G; IN_578] = [__v_13, __v_3]; let __cu = unconstrained; if let Some(result) = record.function_queries[578].get_mut(&__args[..]) { if !__cu && *result.multiplicity == G::ZERO { aiur_fn_578(__args, record, io_buffer, false)? } else { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_578] = unsafe { *(result.output.as_ptr() as *const [G; OUT_578]) }; __ret } } else { aiur_fn_578(__args, record, io_buffer, __cu)? } }; + let __r_arr: [G; OUT_574] = { let __args: [G; IN_574] = [__v_13, __v_2]; let __cu = unconstrained; if let Some(result) = record.function_queries[574].get_mut(&__args[..]) { if !__cu && *result.multiplicity == G::ZERO { aiur_fn_574(__args, record, io_buffer, false)? } else { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_574] = unsafe { *(result.output.as_ptr() as *const [G; OUT_574]) }; __ret } } else { aiur_fn_574(__args, record, io_buffer, __cu)? } }; + let __r_arr: [G; OUT_574] = { let __args: [G; IN_574] = [__v_13, __v_3]; let __cu = unconstrained; if let Some(result) = record.function_queries[574].get_mut(&__args[..]) { if !__cu && *result.multiplicity == G::ZERO { aiur_fn_574(__args, record, io_buffer, false)? } else { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_574] = unsafe { *(result.output.as_ptr() as *const [G; OUT_574]) }; __ret } } else { aiur_fn_574(__args, record, io_buffer, __cu)? } }; let __v_20: G = G::from_u64(1); let __v_21: G = G::from_u64(1); let __v_22: G = { let __values: [G; 3] = [__v_20, __v_21, __v_21]; let __mq = record.memory_queries.get_mut(&3).ok_or(ExecError::InvalidMemorySize(3))?; if let Some(result) = __mq.get_mut(&__values[..]) { if !unconstrained { *result.multiplicity += G::ONE; } result.output[0] } else { let __ptr = G::from_usize(__mq.len()); __mq.insert(&__values[..], &[__ptr], G::from_bool(!unconstrained)); __ptr } }; - let __r_arr: [G; OUT_500] = { let __args: [G; IN_500] = [__v_3, __v_2, __v_22]; let __cu = unconstrained; if let Some(result) = record.function_queries[500].get_mut(&__args[..]) { if !__cu && *result.multiplicity == G::ZERO { aiur_fn_500(__args, record, io_buffer, false)? } else { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_500] = unsafe { *(result.output.as_ptr() as *const [G; OUT_500]) }; __ret } } else { aiur_fn_500(__args, record, io_buffer, __cu)? } }; - let __ret: [G; OUT_697] = []; - if let Some(result) = record.function_queries[697].get_mut(&inp[..]) { debug_assert_eq!(result.output, &__ret[..]); if !unconstrained { *result.multiplicity += G::ONE; } } else { record.function_queries[697].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained)); }; + let __r_arr: [G; OUT_496] = { let __args: [G; IN_496] = [__v_3, __v_2, __v_22]; let __cu = unconstrained; if let Some(result) = record.function_queries[496].get_mut(&__args[..]) { if !__cu && *result.multiplicity == G::ZERO { aiur_fn_496(__args, record, io_buffer, false)? } else { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_496] = unsafe { *(result.output.as_ptr() as *const [G; OUT_496]) }; __ret } } else { aiur_fn_496(__args, record, io_buffer, __cu)? } }; + let __ret: [G; OUT_693] = []; + if let Some(result) = record.function_queries[693].get_mut(&inp[..]) { debug_assert_eq!(result.output, &__ret[..]); if !unconstrained { *result.multiplicity += G::ONE; } } else { record.function_queries[693].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained)); }; return Ok(__ret); }, 2u64 => { let __v_14: G = G::from_u64(0); - let __r_arr: [G; OUT_581] = { let __args: [G; IN_581] = [__v_2, __v_14, __v_1]; let __cu = unconstrained; if let Some(result) = record.function_queries[581].get_mut(&__args[..]) { if !__cu && *result.multiplicity == G::ZERO { aiur_fn_581(__args, record, io_buffer, false)? } else { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_581] = unsafe { *(result.output.as_ptr() as *const [G; OUT_581]) }; __ret } } else { aiur_fn_581(__args, record, io_buffer, __cu)? } }; + let __r_arr: [G; OUT_577] = { let __args: [G; IN_577] = [__v_2, __v_14, __v_1]; let __cu = unconstrained; if let Some(result) = record.function_queries[577].get_mut(&__args[..]) { if !__cu && *result.multiplicity == G::ZERO { aiur_fn_577(__args, record, io_buffer, false)? } else { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_577] = unsafe { *(result.output.as_ptr() as *const [G; OUT_577]) }; __ret } } else { aiur_fn_577(__args, record, io_buffer, __cu)? } }; let __v_15: G = G::from_u64(0); - let __r_arr: [G; OUT_581] = { let __args: [G; IN_581] = [__v_3, __v_15, __v_1]; let __cu = unconstrained; if let Some(result) = record.function_queries[581].get_mut(&__args[..]) { if !__cu && *result.multiplicity == G::ZERO { aiur_fn_581(__args, record, io_buffer, false)? } else { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_581] = unsafe { *(result.output.as_ptr() as *const [G; OUT_581]) }; __ret } } else { aiur_fn_581(__args, record, io_buffer, __cu)? } }; + let __r_arr: [G; OUT_577] = { let __args: [G; IN_577] = [__v_3, __v_15, __v_1]; let __cu = unconstrained; if let Some(result) = record.function_queries[577].get_mut(&__args[..]) { if !__cu && *result.multiplicity == G::ZERO { aiur_fn_577(__args, record, io_buffer, false)? } else { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_577] = unsafe { *(result.output.as_ptr() as *const [G; OUT_577]) }; __ret } } else { aiur_fn_577(__args, record, io_buffer, __cu)? } }; let __v_16: G = G::from_u64(1); let __v_17: G = G::from_u64(1); let __v_18: G = { let __values: [G; 3] = [__v_16, __v_17, __v_17]; let __mq = record.memory_queries.get_mut(&3).ok_or(ExecError::InvalidMemorySize(3))?; if let Some(result) = __mq.get_mut(&__values[..]) { if !unconstrained { *result.multiplicity += G::ONE; } result.output[0] } else { let __ptr = G::from_usize(__mq.len()); __mq.insert(&__values[..], &[__ptr], G::from_bool(!unconstrained)); __ptr } }; - let __r_arr: [G; OUT_499] = { let __args: [G; IN_499] = [__v_2, __v_18]; let __cu = unconstrained; if let Some(result) = record.function_queries[499].get_mut(&__args[..]) { if !__cu && *result.multiplicity == G::ZERO { aiur_fn_499(__args, record, io_buffer, false)? } else { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_499] = unsafe { *(result.output.as_ptr() as *const [G; OUT_499]) }; __ret } } else { aiur_fn_499(__args, record, io_buffer, __cu)? } }; + let __r_arr: [G; OUT_495] = { let __args: [G; IN_495] = [__v_2, __v_18]; let __cu = unconstrained; if let Some(result) = record.function_queries[495].get_mut(&__args[..]) { if !__cu && *result.multiplicity == G::ZERO { aiur_fn_495(__args, record, io_buffer, false)? } else { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_495] = unsafe { *(result.output.as_ptr() as *const [G; OUT_495]) }; __ret } } else { aiur_fn_495(__args, record, io_buffer, __cu)? } }; let __v_19: G = __r_arr[0]; - let __r_arr: [G; OUT_578] = { let __args: [G; IN_578] = [__v_13, __v_2]; let __cu = unconstrained; if let Some(result) = record.function_queries[578].get_mut(&__args[..]) { if !__cu && *result.multiplicity == G::ZERO { aiur_fn_578(__args, record, io_buffer, false)? } else { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_578] = unsafe { *(result.output.as_ptr() as *const [G; OUT_578]) }; __ret } } else { aiur_fn_578(__args, record, io_buffer, __cu)? } }; - let __r_arr: [G; OUT_578] = { let __args: [G; IN_578] = [__v_13, __v_3]; let __cu = unconstrained; if let Some(result) = record.function_queries[578].get_mut(&__args[..]) { if !__cu && *result.multiplicity == G::ZERO { aiur_fn_578(__args, record, io_buffer, false)? } else { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_578] = unsafe { *(result.output.as_ptr() as *const [G; OUT_578]) }; __ret } } else { aiur_fn_578(__args, record, io_buffer, __cu)? } }; + let __r_arr: [G; OUT_574] = { let __args: [G; IN_574] = [__v_13, __v_2]; let __cu = unconstrained; if let Some(result) = record.function_queries[574].get_mut(&__args[..]) { if !__cu && *result.multiplicity == G::ZERO { aiur_fn_574(__args, record, io_buffer, false)? } else { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_574] = unsafe { *(result.output.as_ptr() as *const [G; OUT_574]) }; __ret } } else { aiur_fn_574(__args, record, io_buffer, __cu)? } }; + let __r_arr: [G; OUT_574] = { let __args: [G; IN_574] = [__v_13, __v_3]; let __cu = unconstrained; if let Some(result) = record.function_queries[574].get_mut(&__args[..]) { if !__cu && *result.multiplicity == G::ZERO { aiur_fn_574(__args, record, io_buffer, false)? } else { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_574] = unsafe { *(result.output.as_ptr() as *const [G; OUT_574]) }; __ret } } else { aiur_fn_574(__args, record, io_buffer, __cu)? } }; let __v_20: G = G::from_u64(0); let __v_21: G = G::from_u64(0); let __v_22: G = { let __values: [G; 3] = [__v_20, __v_21, __v_21]; let __mq = record.memory_queries.get_mut(&3).ok_or(ExecError::InvalidMemorySize(3))?; if let Some(result) = __mq.get_mut(&__values[..]) { if !unconstrained { *result.multiplicity += G::ONE; } result.output[0] } else { let __ptr = G::from_usize(__mq.len()); __mq.insert(&__values[..], &[__ptr], G::from_bool(!unconstrained)); __ptr } }; - let __r_arr: [G; OUT_324] = { let __args: [G; IN_324] = [__v_19, __v_22]; let __cu = unconstrained; if let Some(result) = record.function_queries[324].get_mut(&__args[..]) { if !__cu && *result.multiplicity == G::ZERO { aiur_fn_324(__args, record, io_buffer, false)? } else { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_324] = unsafe { *(result.output.as_ptr() as *const [G; OUT_324]) }; __ret } } else { aiur_fn_324(__args, record, io_buffer, __cu)? } }; + let __r_arr: [G; OUT_320] = { let __args: [G; IN_320] = [__v_19, __v_22]; let __cu = unconstrained; if let Some(result) = record.function_queries[320].get_mut(&__args[..]) { if !__cu && *result.multiplicity == G::ZERO { aiur_fn_320(__args, record, io_buffer, false)? } else { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_320] = unsafe { *(result.output.as_ptr() as *const [G; OUT_320]) }; __ret } } else { aiur_fn_320(__args, record, io_buffer, __cu)? } }; let __v_23: G = __r_arr[0]; let __v_24: G = G::from_u64(1); if (__v_23 != __v_24) { @@ -58539,71 +58267,71 @@ fn aiur_fn_697( let __v_25: G = G::from_u64(1); let __v_26: G = G::from_u64(1); let __v_27: G = { let __values: [G; 3] = [__v_25, __v_26, __v_26]; let __mq = record.memory_queries.get_mut(&3).ok_or(ExecError::InvalidMemorySize(3))?; if let Some(result) = __mq.get_mut(&__values[..]) { if !unconstrained { *result.multiplicity += G::ONE; } result.output[0] } else { let __ptr = G::from_usize(__mq.len()); __mq.insert(&__values[..], &[__ptr], G::from_bool(!unconstrained)); __ptr } }; - let __r_arr: [G; OUT_500] = { let __args: [G; IN_500] = [__v_3, __v_2, __v_27]; let __cu = unconstrained; if let Some(result) = record.function_queries[500].get_mut(&__args[..]) { if !__cu && *result.multiplicity == G::ZERO { aiur_fn_500(__args, record, io_buffer, false)? } else { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_500] = unsafe { *(result.output.as_ptr() as *const [G; OUT_500]) }; __ret } } else { aiur_fn_500(__args, record, io_buffer, __cu)? } }; - let __ret: [G; OUT_697] = []; - if let Some(result) = record.function_queries[697].get_mut(&inp[..]) { debug_assert_eq!(result.output, &__ret[..]); if !unconstrained { *result.multiplicity += G::ONE; } } else { record.function_queries[697].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained)); }; + let __r_arr: [G; OUT_496] = { let __args: [G; IN_496] = [__v_3, __v_2, __v_27]; let __cu = unconstrained; if let Some(result) = record.function_queries[496].get_mut(&__args[..]) { if !__cu && *result.multiplicity == G::ZERO { aiur_fn_496(__args, record, io_buffer, false)? } else { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_496] = unsafe { *(result.output.as_ptr() as *const [G; OUT_496]) }; __ret } } else { aiur_fn_496(__args, record, io_buffer, __cu)? } }; + let __ret: [G; OUT_693] = []; + if let Some(result) = record.function_queries[693].get_mut(&inp[..]) { debug_assert_eq!(result.output, &__ret[..]); if !unconstrained { *result.multiplicity += G::ONE; } } else { record.function_queries[693].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained)); }; return Ok(__ret); }, 3u64 => { let __v_14: G = G::from_u64(0); - let __r_arr: [G; OUT_581] = { let __args: [G; IN_581] = [__v_2, __v_14, __v_1]; let __cu = unconstrained; if let Some(result) = record.function_queries[581].get_mut(&__args[..]) { if !__cu && *result.multiplicity == G::ZERO { aiur_fn_581(__args, record, io_buffer, false)? } else { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_581] = unsafe { *(result.output.as_ptr() as *const [G; OUT_581]) }; __ret } } else { aiur_fn_581(__args, record, io_buffer, __cu)? } }; + let __r_arr: [G; OUT_577] = { let __args: [G; IN_577] = [__v_2, __v_14, __v_1]; let __cu = unconstrained; if let Some(result) = record.function_queries[577].get_mut(&__args[..]) { if !__cu && *result.multiplicity == G::ZERO { aiur_fn_577(__args, record, io_buffer, false)? } else { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_577] = unsafe { *(result.output.as_ptr() as *const [G; OUT_577]) }; __ret } } else { aiur_fn_577(__args, record, io_buffer, __cu)? } }; let __v_15: G = G::from_u64(0); - let __r_arr: [G; OUT_581] = { let __args: [G; IN_581] = [__v_3, __v_15, __v_1]; let __cu = unconstrained; if let Some(result) = record.function_queries[581].get_mut(&__args[..]) { if !__cu && *result.multiplicity == G::ZERO { aiur_fn_581(__args, record, io_buffer, false)? } else { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_581] = unsafe { *(result.output.as_ptr() as *const [G; OUT_581]) }; __ret } } else { aiur_fn_581(__args, record, io_buffer, __cu)? } }; + let __r_arr: [G; OUT_577] = { let __args: [G; IN_577] = [__v_3, __v_15, __v_1]; let __cu = unconstrained; if let Some(result) = record.function_queries[577].get_mut(&__args[..]) { if !__cu && *result.multiplicity == G::ZERO { aiur_fn_577(__args, record, io_buffer, false)? } else { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_577] = unsafe { *(result.output.as_ptr() as *const [G; OUT_577]) }; __ret } } else { aiur_fn_577(__args, record, io_buffer, __cu)? } }; let __v_16: G = G::from_u64(1); let __v_17: G = G::from_u64(1); let __v_18: G = { let __values: [G; 3] = [__v_16, __v_17, __v_17]; let __mq = record.memory_queries.get_mut(&3).ok_or(ExecError::InvalidMemorySize(3))?; if let Some(result) = __mq.get_mut(&__values[..]) { if !unconstrained { *result.multiplicity += G::ONE; } result.output[0] } else { let __ptr = G::from_usize(__mq.len()); __mq.insert(&__values[..], &[__ptr], G::from_bool(!unconstrained)); __ptr } }; - let __r_arr: [G; OUT_499] = { let __args: [G; IN_499] = [__v_2, __v_18]; let __cu = unconstrained; if let Some(result) = record.function_queries[499].get_mut(&__args[..]) { if !__cu && *result.multiplicity == G::ZERO { aiur_fn_499(__args, record, io_buffer, false)? } else { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_499] = unsafe { *(result.output.as_ptr() as *const [G; OUT_499]) }; __ret } } else { aiur_fn_499(__args, record, io_buffer, __cu)? } }; + let __r_arr: [G; OUT_495] = { let __args: [G; IN_495] = [__v_2, __v_18]; let __cu = unconstrained; if let Some(result) = record.function_queries[495].get_mut(&__args[..]) { if !__cu && *result.multiplicity == G::ZERO { aiur_fn_495(__args, record, io_buffer, false)? } else { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_495] = unsafe { *(result.output.as_ptr() as *const [G; OUT_495]) }; __ret } } else { aiur_fn_495(__args, record, io_buffer, __cu)? } }; let __v_19: G = __r_arr[0]; - let __r_arr: [G; OUT_578] = { let __args: [G; IN_578] = [__v_13, __v_2]; let __cu = unconstrained; if let Some(result) = record.function_queries[578].get_mut(&__args[..]) { if !__cu && *result.multiplicity == G::ZERO { aiur_fn_578(__args, record, io_buffer, false)? } else { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_578] = unsafe { *(result.output.as_ptr() as *const [G; OUT_578]) }; __ret } } else { aiur_fn_578(__args, record, io_buffer, __cu)? } }; - let __r_arr: [G; OUT_578] = { let __args: [G; IN_578] = [__v_13, __v_3]; let __cu = unconstrained; if let Some(result) = record.function_queries[578].get_mut(&__args[..]) { if !__cu && *result.multiplicity == G::ZERO { aiur_fn_578(__args, record, io_buffer, false)? } else { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_578] = unsafe { *(result.output.as_ptr() as *const [G; OUT_578]) }; __ret } } else { aiur_fn_578(__args, record, io_buffer, __cu)? } }; + let __r_arr: [G; OUT_574] = { let __args: [G; IN_574] = [__v_13, __v_2]; let __cu = unconstrained; if let Some(result) = record.function_queries[574].get_mut(&__args[..]) { if !__cu && *result.multiplicity == G::ZERO { aiur_fn_574(__args, record, io_buffer, false)? } else { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_574] = unsafe { *(result.output.as_ptr() as *const [G; OUT_574]) }; __ret } } else { aiur_fn_574(__args, record, io_buffer, __cu)? } }; + let __r_arr: [G; OUT_574] = { let __args: [G; IN_574] = [__v_13, __v_3]; let __cu = unconstrained; if let Some(result) = record.function_queries[574].get_mut(&__args[..]) { if !__cu && *result.multiplicity == G::ZERO { aiur_fn_574(__args, record, io_buffer, false)? } else { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_574] = unsafe { *(result.output.as_ptr() as *const [G; OUT_574]) }; __ret } } else { aiur_fn_574(__args, record, io_buffer, __cu)? } }; let __v_20: G = G::from_u64(1); let __v_21: G = G::from_u64(1); let __v_22: G = { let __values: [G; 3] = [__v_20, __v_21, __v_21]; let __mq = record.memory_queries.get_mut(&3).ok_or(ExecError::InvalidMemorySize(3))?; if let Some(result) = __mq.get_mut(&__values[..]) { if !unconstrained { *result.multiplicity += G::ONE; } result.output[0] } else { let __ptr = G::from_usize(__mq.len()); __mq.insert(&__values[..], &[__ptr], G::from_bool(!unconstrained)); __ptr } }; - let __r_arr: [G; OUT_500] = { let __args: [G; IN_500] = [__v_3, __v_2, __v_22]; let __cu = unconstrained; if let Some(result) = record.function_queries[500].get_mut(&__args[..]) { if !__cu && *result.multiplicity == G::ZERO { aiur_fn_500(__args, record, io_buffer, false)? } else { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_500] = unsafe { *(result.output.as_ptr() as *const [G; OUT_500]) }; __ret } } else { aiur_fn_500(__args, record, io_buffer, __cu)? } }; - let __ret: [G; OUT_697] = []; - if let Some(result) = record.function_queries[697].get_mut(&inp[..]) { debug_assert_eq!(result.output, &__ret[..]); if !unconstrained { *result.multiplicity += G::ONE; } } else { record.function_queries[697].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained)); }; + let __r_arr: [G; OUT_496] = { let __args: [G; IN_496] = [__v_3, __v_2, __v_22]; let __cu = unconstrained; if let Some(result) = record.function_queries[496].get_mut(&__args[..]) { if !__cu && *result.multiplicity == G::ZERO { aiur_fn_496(__args, record, io_buffer, false)? } else { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_496] = unsafe { *(result.output.as_ptr() as *const [G; OUT_496]) }; __ret } } else { aiur_fn_496(__args, record, io_buffer, __cu)? } }; + let __ret: [G; OUT_693] = []; + if let Some(result) = record.function_queries[693].get_mut(&inp[..]) { debug_assert_eq!(result.output, &__ret[..]); if !unconstrained { *result.multiplicity += G::ONE; } } else { record.function_queries[693].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained)); }; return Ok(__ret); }, 4u64 => { let __v_14: G = G::from_u64(0); - let __r_arr: [G; OUT_581] = { let __args: [G; IN_581] = [__v_2, __v_14, __v_1]; let __cu = unconstrained; if let Some(result) = record.function_queries[581].get_mut(&__args[..]) { if !__cu && *result.multiplicity == G::ZERO { aiur_fn_581(__args, record, io_buffer, false)? } else { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_581] = unsafe { *(result.output.as_ptr() as *const [G; OUT_581]) }; __ret } } else { aiur_fn_581(__args, record, io_buffer, __cu)? } }; + let __r_arr: [G; OUT_577] = { let __args: [G; IN_577] = [__v_2, __v_14, __v_1]; let __cu = unconstrained; if let Some(result) = record.function_queries[577].get_mut(&__args[..]) { if !__cu && *result.multiplicity == G::ZERO { aiur_fn_577(__args, record, io_buffer, false)? } else { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_577] = unsafe { *(result.output.as_ptr() as *const [G; OUT_577]) }; __ret } } else { aiur_fn_577(__args, record, io_buffer, __cu)? } }; let __v_15: G = G::from_u64(1); let __v_16: G = G::from_u64(1); let __v_17: G = { let __values: [G; 3] = [__v_15, __v_16, __v_16]; let __mq = record.memory_queries.get_mut(&3).ok_or(ExecError::InvalidMemorySize(3))?; if let Some(result) = __mq.get_mut(&__values[..]) { if !unconstrained { *result.multiplicity += G::ONE; } result.output[0] } else { let __ptr = G::from_usize(__mq.len()); __mq.insert(&__values[..], &[__ptr], G::from_bool(!unconstrained)); __ptr } }; - let __r_arr: [G; OUT_499] = { let __args: [G; IN_499] = [__v_2, __v_17]; let __cu = unconstrained; if let Some(result) = record.function_queries[499].get_mut(&__args[..]) { if !__cu && *result.multiplicity == G::ZERO { aiur_fn_499(__args, record, io_buffer, false)? } else { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_499] = unsafe { *(result.output.as_ptr() as *const [G; OUT_499]) }; __ret } } else { aiur_fn_499(__args, record, io_buffer, __cu)? } }; + let __r_arr: [G; OUT_495] = { let __args: [G; IN_495] = [__v_2, __v_17]; let __cu = unconstrained; if let Some(result) = record.function_queries[495].get_mut(&__args[..]) { if !__cu && *result.multiplicity == G::ZERO { aiur_fn_495(__args, record, io_buffer, false)? } else { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_495] = unsafe { *(result.output.as_ptr() as *const [G; OUT_495]) }; __ret } } else { aiur_fn_495(__args, record, io_buffer, __cu)? } }; let __v_18: G = __r_arr[0]; - let __r_arr: [G; OUT_578] = { let __args: [G; IN_578] = [__v_13, __v_2]; let __cu = unconstrained; if let Some(result) = record.function_queries[578].get_mut(&__args[..]) { if !__cu && *result.multiplicity == G::ZERO { aiur_fn_578(__args, record, io_buffer, false)? } else { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_578] = unsafe { *(result.output.as_ptr() as *const [G; OUT_578]) }; __ret } } else { aiur_fn_578(__args, record, io_buffer, __cu)? } }; - let __r_arr: [G; OUT_585] = { let __args: [G; IN_585] = [__v_12, __v_3, __v_1, __v_2]; let __cu = unconstrained; if let Some(result) = record.function_queries[585].get_mut(&__args[..]) { if !__cu && *result.multiplicity == G::ZERO { aiur_fn_585(__args, record, io_buffer, false)? } else { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_585] = unsafe { *(result.output.as_ptr() as *const [G; OUT_585]) }; __ret } } else { aiur_fn_585(__args, record, io_buffer, __cu)? } }; - let __ret: [G; OUT_697] = []; - if let Some(result) = record.function_queries[697].get_mut(&inp[..]) { debug_assert_eq!(result.output, &__ret[..]); if !unconstrained { *result.multiplicity += G::ONE; } } else { record.function_queries[697].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained)); }; + let __r_arr: [G; OUT_574] = { let __args: [G; IN_574] = [__v_13, __v_2]; let __cu = unconstrained; if let Some(result) = record.function_queries[574].get_mut(&__args[..]) { if !__cu && *result.multiplicity == G::ZERO { aiur_fn_574(__args, record, io_buffer, false)? } else { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_574] = unsafe { *(result.output.as_ptr() as *const [G; OUT_574]) }; __ret } } else { aiur_fn_574(__args, record, io_buffer, __cu)? } }; + let __r_arr: [G; OUT_581] = { let __args: [G; IN_581] = [__v_12, __v_3, __v_1, __v_2]; let __cu = unconstrained; if let Some(result) = record.function_queries[581].get_mut(&__args[..]) { if !__cu && *result.multiplicity == G::ZERO { aiur_fn_581(__args, record, io_buffer, false)? } else { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_581] = unsafe { *(result.output.as_ptr() as *const [G; OUT_581]) }; __ret } } else { aiur_fn_581(__args, record, io_buffer, __cu)? } }; + let __ret: [G; OUT_693] = []; + if let Some(result) = record.function_queries[693].get_mut(&inp[..]) { debug_assert_eq!(result.output, &__ret[..]); if !unconstrained { *result.multiplicity += G::ONE; } } else { record.function_queries[693].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained)); }; return Ok(__ret); }, 5u64 => { let __v_14: G = G::from_u64(0); - let __r_arr: [G; OUT_581] = { let __args: [G; IN_581] = [__v_2, __v_14, __v_1]; let __cu = unconstrained; if let Some(result) = record.function_queries[581].get_mut(&__args[..]) { if !__cu && *result.multiplicity == G::ZERO { aiur_fn_581(__args, record, io_buffer, false)? } else { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_581] = unsafe { *(result.output.as_ptr() as *const [G; OUT_581]) }; __ret } } else { aiur_fn_581(__args, record, io_buffer, __cu)? } }; + let __r_arr: [G; OUT_577] = { let __args: [G; IN_577] = [__v_2, __v_14, __v_1]; let __cu = unconstrained; if let Some(result) = record.function_queries[577].get_mut(&__args[..]) { if !__cu && *result.multiplicity == G::ZERO { aiur_fn_577(__args, record, io_buffer, false)? } else { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_577] = unsafe { *(result.output.as_ptr() as *const [G; OUT_577]) }; __ret } } else { aiur_fn_577(__args, record, io_buffer, __cu)? } }; let __v_15: G = G::from_u64(1); let __v_16: G = G::from_u64(1); let __v_17: G = { let __values: [G; 3] = [__v_15, __v_16, __v_16]; let __mq = record.memory_queries.get_mut(&3).ok_or(ExecError::InvalidMemorySize(3))?; if let Some(result) = __mq.get_mut(&__values[..]) { if !unconstrained { *result.multiplicity += G::ONE; } result.output[0] } else { let __ptr = G::from_usize(__mq.len()); __mq.insert(&__values[..], &[__ptr], G::from_bool(!unconstrained)); __ptr } }; - let __r_arr: [G; OUT_499] = { let __args: [G; IN_499] = [__v_2, __v_17]; let __cu = unconstrained; if let Some(result) = record.function_queries[499].get_mut(&__args[..]) { if !__cu && *result.multiplicity == G::ZERO { aiur_fn_499(__args, record, io_buffer, false)? } else { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_499] = unsafe { *(result.output.as_ptr() as *const [G; OUT_499]) }; __ret } } else { aiur_fn_499(__args, record, io_buffer, __cu)? } }; + let __r_arr: [G; OUT_495] = { let __args: [G; IN_495] = [__v_2, __v_17]; let __cu = unconstrained; if let Some(result) = record.function_queries[495].get_mut(&__args[..]) { if !__cu && *result.multiplicity == G::ZERO { aiur_fn_495(__args, record, io_buffer, false)? } else { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_495] = unsafe { *(result.output.as_ptr() as *const [G; OUT_495]) }; __ret } } else { aiur_fn_495(__args, record, io_buffer, __cu)? } }; let __v_18: G = __r_arr[0]; - let __r_arr: [G; OUT_578] = { let __args: [G; IN_578] = [__v_13, __v_2]; let __cu = unconstrained; if let Some(result) = record.function_queries[578].get_mut(&__args[..]) { if !__cu && *result.multiplicity == G::ZERO { aiur_fn_578(__args, record, io_buffer, false)? } else { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_578] = unsafe { *(result.output.as_ptr() as *const [G; OUT_578]) }; __ret } } else { aiur_fn_578(__args, record, io_buffer, __cu)? } }; - let __r_arr: [G; OUT_575] = { let __args: [G; IN_575] = [__v_7]; let __cu = unconstrained; if let Some(result) = record.function_queries[575].get_mut(&__args[..]) { if !__cu && *result.multiplicity == G::ZERO { aiur_fn_575(__args, record, io_buffer, false)? } else { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_575] = unsafe { *(result.output.as_ptr() as *const [G; OUT_575]) }; __ret } } else { aiur_fn_575(__args, record, io_buffer, __cu)? } }; - let __r_arr: [G; OUT_609] = { let __args: [G; IN_609] = [__v_2, __v_3, __v_4, __v_5, __v_1, __v_7, __v_8, __v_6]; let __cu = unconstrained; if let Some(result) = record.function_queries[609].get_mut(&__args[..]) { if !__cu && *result.multiplicity == G::ZERO { aiur_fn_609(__args, record, io_buffer, false)? } else { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_609] = unsafe { *(result.output.as_ptr() as *const [G; OUT_609]) }; __ret } } else { aiur_fn_609(__args, record, io_buffer, __cu)? } }; - let __r_arr: [G; OUT_612] = { let __args: [G; IN_612] = [__v_0, __v_1, __v_2, __v_3, __v_4, __v_5, __v_6, __v_7, __v_8, __v_9, __v_10, __v_11, __v_12]; let __cu = unconstrained; if let Some(result) = record.function_queries[612].get_mut(&__args[..]) { if !__cu && *result.multiplicity == G::ZERO { aiur_fn_612(__args, record, io_buffer, false)? } else { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_612] = unsafe { *(result.output.as_ptr() as *const [G; OUT_612]) }; __ret } } else { aiur_fn_612(__args, record, io_buffer, __cu)? } }; - let __ret: [G; OUT_697] = []; - if let Some(result) = record.function_queries[697].get_mut(&inp[..]) { debug_assert_eq!(result.output, &__ret[..]); if !unconstrained { *result.multiplicity += G::ONE; } } else { record.function_queries[697].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained)); }; + let __r_arr: [G; OUT_574] = { let __args: [G; IN_574] = [__v_13, __v_2]; let __cu = unconstrained; if let Some(result) = record.function_queries[574].get_mut(&__args[..]) { if !__cu && *result.multiplicity == G::ZERO { aiur_fn_574(__args, record, io_buffer, false)? } else { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_574] = unsafe { *(result.output.as_ptr() as *const [G; OUT_574]) }; __ret } } else { aiur_fn_574(__args, record, io_buffer, __cu)? } }; + let __r_arr: [G; OUT_571] = { let __args: [G; IN_571] = [__v_7]; let __cu = unconstrained; if let Some(result) = record.function_queries[571].get_mut(&__args[..]) { if !__cu && *result.multiplicity == G::ZERO { aiur_fn_571(__args, record, io_buffer, false)? } else { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_571] = unsafe { *(result.output.as_ptr() as *const [G; OUT_571]) }; __ret } } else { aiur_fn_571(__args, record, io_buffer, __cu)? } }; + let __r_arr: [G; OUT_605] = { let __args: [G; IN_605] = [__v_2, __v_3, __v_4, __v_5, __v_1, __v_7, __v_8, __v_6]; let __cu = unconstrained; if let Some(result) = record.function_queries[605].get_mut(&__args[..]) { if !__cu && *result.multiplicity == G::ZERO { aiur_fn_605(__args, record, io_buffer, false)? } else { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_605] = unsafe { *(result.output.as_ptr() as *const [G; OUT_605]) }; __ret } } else { aiur_fn_605(__args, record, io_buffer, __cu)? } }; + let __r_arr: [G; OUT_608] = { let __args: [G; IN_608] = [__v_0, __v_1, __v_2, __v_3, __v_4, __v_5, __v_6, __v_7, __v_8, __v_9, __v_10, __v_11, __v_12]; let __cu = unconstrained; if let Some(result) = record.function_queries[608].get_mut(&__args[..]) { if !__cu && *result.multiplicity == G::ZERO { aiur_fn_608(__args, record, io_buffer, false)? } else { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_608] = unsafe { *(result.output.as_ptr() as *const [G; OUT_608]) }; __ret } } else { aiur_fn_608(__args, record, io_buffer, __cu)? } }; + let __ret: [G; OUT_693] = []; + if let Some(result) = record.function_queries[693].get_mut(&inp[..]) { debug_assert_eq!(result.output, &__ret[..]); if !unconstrained { *result.multiplicity += G::ONE; } } else { record.function_queries[693].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained)); }; return Ok(__ret); }, 6u64 => { let __v_14: G = G::from_u64(0); - let __r_arr: [G; OUT_581] = { let __args: [G; IN_581] = [__v_2, __v_14, __v_1]; let __cu = unconstrained; if let Some(result) = record.function_queries[581].get_mut(&__args[..]) { if !__cu && *result.multiplicity == G::ZERO { aiur_fn_581(__args, record, io_buffer, false)? } else { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_581] = unsafe { *(result.output.as_ptr() as *const [G; OUT_581]) }; __ret } } else { aiur_fn_581(__args, record, io_buffer, __cu)? } }; + let __r_arr: [G; OUT_577] = { let __args: [G; IN_577] = [__v_2, __v_14, __v_1]; let __cu = unconstrained; if let Some(result) = record.function_queries[577].get_mut(&__args[..]) { if !__cu && *result.multiplicity == G::ZERO { aiur_fn_577(__args, record, io_buffer, false)? } else { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_577] = unsafe { *(result.output.as_ptr() as *const [G; OUT_577]) }; __ret } } else { aiur_fn_577(__args, record, io_buffer, __cu)? } }; let __v_15: G = G::from_u64(1); let __v_16: G = G::from_u64(1); let __v_17: G = { let __values: [G; 3] = [__v_15, __v_16, __v_16]; let __mq = record.memory_queries.get_mut(&3).ok_or(ExecError::InvalidMemorySize(3))?; if let Some(result) = __mq.get_mut(&__values[..]) { if !unconstrained { *result.multiplicity += G::ONE; } result.output[0] } else { let __ptr = G::from_usize(__mq.len()); __mq.insert(&__values[..], &[__ptr], G::from_bool(!unconstrained)); __ptr } }; - let __r_arr: [G; OUT_499] = { let __args: [G; IN_499] = [__v_2, __v_17]; let __cu = unconstrained; if let Some(result) = record.function_queries[499].get_mut(&__args[..]) { if !__cu && *result.multiplicity == G::ZERO { aiur_fn_499(__args, record, io_buffer, false)? } else { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_499] = unsafe { *(result.output.as_ptr() as *const [G; OUT_499]) }; __ret } } else { aiur_fn_499(__args, record, io_buffer, __cu)? } }; + let __r_arr: [G; OUT_495] = { let __args: [G; IN_495] = [__v_2, __v_17]; let __cu = unconstrained; if let Some(result) = record.function_queries[495].get_mut(&__args[..]) { if !__cu && *result.multiplicity == G::ZERO { aiur_fn_495(__args, record, io_buffer, false)? } else { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_495] = unsafe { *(result.output.as_ptr() as *const [G; OUT_495]) }; __ret } } else { aiur_fn_495(__args, record, io_buffer, __cu)? } }; let __v_18: G = __r_arr[0]; - let __r_arr: [G; OUT_578] = { let __args: [G; IN_578] = [__v_13, __v_2]; let __cu = unconstrained; if let Some(result) = record.function_queries[578].get_mut(&__args[..]) { if !__cu && *result.multiplicity == G::ZERO { aiur_fn_578(__args, record, io_buffer, false)? } else { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_578] = unsafe { *(result.output.as_ptr() as *const [G; OUT_578]) }; __ret } } else { aiur_fn_578(__args, record, io_buffer, __cu)? } }; - let __r_arr: [G; OUT_289] = { let __args: [G; IN_289] = [__v_3, __v_4]; let __cu = unconstrained; if let Some(result) = record.function_queries[289].get_mut(&__args[..]) { if !__cu && *result.multiplicity == G::ZERO { aiur_fn_289(__args, record, io_buffer, false)? } else { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_289] = unsafe { *(result.output.as_ptr() as *const [G; OUT_289]) }; __ret } } else { aiur_fn_289(__args, record, io_buffer, __cu)? } }; + let __r_arr: [G; OUT_574] = { let __args: [G; IN_574] = [__v_13, __v_2]; let __cu = unconstrained; if let Some(result) = record.function_queries[574].get_mut(&__args[..]) { if !__cu && *result.multiplicity == G::ZERO { aiur_fn_574(__args, record, io_buffer, false)? } else { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_574] = unsafe { *(result.output.as_ptr() as *const [G; OUT_574]) }; __ret } } else { aiur_fn_574(__args, record, io_buffer, __cu)? } }; + let __r_arr: [G; OUT_285] = { let __args: [G; IN_285] = [__v_3, __v_4]; let __cu = unconstrained; if let Some(result) = record.function_queries[285].get_mut(&__args[..]) { if !__cu && *result.multiplicity == G::ZERO { aiur_fn_285(__args, record, io_buffer, false)? } else { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_285] = unsafe { *(result.output.as_ptr() as *const [G; OUT_285]) }; __ret } } else { aiur_fn_285(__args, record, io_buffer, __cu)? } }; let __v_19: G = __r_arr[0]; let __loaded: [G; 12] = { let __mq = record.memory_queries.get_mut(&12).ok_or(ExecError::InvalidMemorySize(12))?; let __ptr_u64 = __v_19.as_canonical_u64(); let __ptr_usize = usize::try_from(__ptr_u64).ok().ok_or(ExecError::PointerTooLarge(__ptr_u64))?; let (__args, __mult) = __mq.get_index_mut(__ptr_usize).ok_or(ExecError::UnboundPointer { ptr: __ptr_u64, size: 12 })?; if !unconstrained { *__mult += G::ONE; } let __arr: [G; 12] = __args[..12].try_into().unwrap(); __arr }; let __v_20: G = __loaded[0]; @@ -58620,15 +58348,15 @@ fn aiur_fn_697( let __v_31: G = __loaded[11]; match __v_20.as_canonical_u64() { 5u64 => { - let __r_arr: [G; OUT_592] = { let __args: [G; IN_592] = [__v_22, __v_2, __v_23]; let __cu = unconstrained; if let Some(result) = record.function_queries[592].get_mut(&__args[..]) { if !__cu && *result.multiplicity == G::ZERO { aiur_fn_592(__args, record, io_buffer, false)? } else { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_592] = unsafe { *(result.output.as_ptr() as *const [G; OUT_592]) }; __ret } } else { aiur_fn_592(__args, record, io_buffer, __cu)? } }; - let __r_arr: [G; OUT_590] = { let __args: [G; IN_590] = [__v_2, __v_6, __v_24, __v_7, __v_21, __v_3, __v_4]; let __cu = unconstrained; if let Some(result) = record.function_queries[590].get_mut(&__args[..]) { if !__cu && *result.multiplicity == G::ZERO { aiur_fn_590(__args, record, io_buffer, false)? } else { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_590] = unsafe { *(result.output.as_ptr() as *const [G; OUT_590]) }; __ret } } else { aiur_fn_590(__args, record, io_buffer, __cu)? } }; + let __r_arr: [G; OUT_588] = { let __args: [G; IN_588] = [__v_22, __v_2, __v_23]; let __cu = unconstrained; if let Some(result) = record.function_queries[588].get_mut(&__args[..]) { if !__cu && *result.multiplicity == G::ZERO { aiur_fn_588(__args, record, io_buffer, false)? } else { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_588] = unsafe { *(result.output.as_ptr() as *const [G; OUT_588]) }; __ret } } else { aiur_fn_588(__args, record, io_buffer, __cu)? } }; + let __r_arr: [G; OUT_586] = { let __args: [G; IN_586] = [__v_2, __v_6, __v_24, __v_7, __v_21, __v_3, __v_4]; let __cu = unconstrained; if let Some(result) = record.function_queries[586].get_mut(&__args[..]) { if !__cu && *result.multiplicity == G::ZERO { aiur_fn_586(__args, record, io_buffer, false)? } else { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_586] = unsafe { *(result.output.as_ptr() as *const [G; OUT_586]) }; __ret } } else { aiur_fn_586(__args, record, io_buffer, __cu)? } }; let __v_32: G = (__v_23 + __v_24); let __v_33: G = G::from_u64(1); let __v_34: G = G::from_u64(1); let __v_35: G = { let __values: [G; 3] = [__v_33, __v_34, __v_34]; let __mq = record.memory_queries.get_mut(&3).ok_or(ExecError::InvalidMemorySize(3))?; if let Some(result) = __mq.get_mut(&__values[..]) { if !unconstrained { *result.multiplicity += G::ONE; } result.output[0] } else { let __ptr = G::from_usize(__mq.len()); __mq.insert(&__values[..], &[__ptr], G::from_bool(!unconstrained)); __ptr } }; - let __r_arr: [G; OUT_593] = { let __args: [G; IN_593] = [__v_22, __v_32, __v_35]; let __cu = unconstrained; if let Some(result) = record.function_queries[593].get_mut(&__args[..]) { if !__cu && *result.multiplicity == G::ZERO { aiur_fn_593(__args, record, io_buffer, false)? } else { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_593] = unsafe { *(result.output.as_ptr() as *const [G; OUT_593]) }; __ret } } else { aiur_fn_593(__args, record, io_buffer, __cu)? } }; + let __r_arr: [G; OUT_589] = { let __args: [G; IN_589] = [__v_22, __v_32, __v_35]; let __cu = unconstrained; if let Some(result) = record.function_queries[589].get_mut(&__args[..]) { if !__cu && *result.multiplicity == G::ZERO { aiur_fn_589(__args, record, io_buffer, false)? } else { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_589] = unsafe { *(result.output.as_ptr() as *const [G; OUT_589]) }; __ret } } else { aiur_fn_589(__args, record, io_buffer, __cu)? } }; let __v_36: G = __r_arr[0]; - let __r_arr: [G; OUT_596] = { let __args: [G; IN_596] = [__v_2, __v_6, __v_36]; let __cu = unconstrained; if let Some(result) = record.function_queries[596].get_mut(&__args[..]) { if !__cu && *result.multiplicity == G::ZERO { aiur_fn_596(__args, record, io_buffer, false)? } else { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_596] = unsafe { *(result.output.as_ptr() as *const [G; OUT_596]) }; __ret } } else { aiur_fn_596(__args, record, io_buffer, __cu)? } }; + let __r_arr: [G; OUT_592] = { let __args: [G; IN_592] = [__v_2, __v_6, __v_36]; let __cu = unconstrained; if let Some(result) = record.function_queries[592].get_mut(&__args[..]) { if !__cu && *result.multiplicity == G::ZERO { aiur_fn_592(__args, record, io_buffer, false)? } else { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_592] = unsafe { *(result.output.as_ptr() as *const [G; OUT_592]) }; __ret } } else { aiur_fn_592(__args, record, io_buffer, __cu)? } }; if (__v_6 != __v_23) { return Err(ExecError::AssertEqMismatch { lhs: __v_6.as_canonical_u64(), rhs: __v_23.as_canonical_u64(), msg: Some("ctor parameter count differs from its inductive's".to_string()) }); } @@ -58637,14 +58365,14 @@ fn aiur_fn_697( let __v_37: G = G::from_u64(1); let __v_38: G = G::from_u64(1); let __v_39: G = { let __values: [G; 3] = [__v_37, __v_38, __v_38]; let __mq = record.memory_queries.get_mut(&3).ok_or(ExecError::InvalidMemorySize(3))?; if let Some(result) = __mq.get_mut(&__values[..]) { if !unconstrained { *result.multiplicity += G::ONE; } result.output[0] } else { let __ptr = G::from_usize(__mq.len()); __mq.insert(&__values[..], &[__ptr], G::from_bool(!unconstrained)); __ptr } }; - let __r_arr: [G; OUT_608] = { let __args: [G; IN_608] = [__v_2, __v_6, __v_3, __v_39]; let __cu = unconstrained; if let Some(result) = record.function_queries[608].get_mut(&__args[..]) { if !__cu && *result.multiplicity == G::ZERO { aiur_fn_608(__args, record, io_buffer, false)? } else { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_608] = unsafe { *(result.output.as_ptr() as *const [G; OUT_608]) }; __ret } } else { aiur_fn_608(__args, record, io_buffer, __cu)? } }; - let __ret: [G; OUT_697] = []; - if let Some(result) = record.function_queries[697].get_mut(&inp[..]) { debug_assert_eq!(result.output, &__ret[..]); if !unconstrained { *result.multiplicity += G::ONE; } } else { record.function_queries[697].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained)); }; + let __r_arr: [G; OUT_604] = { let __args: [G; IN_604] = [__v_2, __v_6, __v_3, __v_39]; let __cu = unconstrained; if let Some(result) = record.function_queries[604].get_mut(&__args[..]) { if !__cu && *result.multiplicity == G::ZERO { aiur_fn_604(__args, record, io_buffer, false)? } else { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_604] = unsafe { *(result.output.as_ptr() as *const [G; OUT_604]) }; __ret } } else { aiur_fn_604(__args, record, io_buffer, __cu)? } }; + let __ret: [G; OUT_693] = []; + if let Some(result) = record.function_queries[693].get_mut(&inp[..]) { debug_assert_eq!(result.output, &__ret[..]); if !unconstrained { *result.multiplicity += G::ONE; } } else { record.function_queries[693].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained)); }; return Ok(__ret); }, _ => { - let __ret: [G; OUT_697] = []; - if let Some(result) = record.function_queries[697].get_mut(&inp[..]) { debug_assert_eq!(result.output, &__ret[..]); if !unconstrained { *result.multiplicity += G::ONE; } } else { record.function_queries[697].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained)); }; + let __ret: [G; OUT_693] = []; + if let Some(result) = record.function_queries[693].get_mut(&inp[..]) { debug_assert_eq!(result.output, &__ret[..]); if !unconstrained { *result.multiplicity += G::ONE; } } else { record.function_queries[693].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained)); }; return Ok(__ret); }, } @@ -58656,17 +58384,17 @@ fn aiur_fn_697( }, 7u64 => { let __v_14: G = G::from_u64(0); - let __r_arr: [G; OUT_581] = { let __args: [G; IN_581] = [__v_2, __v_14, __v_1]; let __cu = unconstrained; if let Some(result) = record.function_queries[581].get_mut(&__args[..]) { if !__cu && *result.multiplicity == G::ZERO { aiur_fn_581(__args, record, io_buffer, false)? } else { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_581] = unsafe { *(result.output.as_ptr() as *const [G; OUT_581]) }; __ret } } else { aiur_fn_581(__args, record, io_buffer, __cu)? } }; + let __r_arr: [G; OUT_577] = { let __args: [G; IN_577] = [__v_2, __v_14, __v_1]; let __cu = unconstrained; if let Some(result) = record.function_queries[577].get_mut(&__args[..]) { if !__cu && *result.multiplicity == G::ZERO { aiur_fn_577(__args, record, io_buffer, false)? } else { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_577] = unsafe { *(result.output.as_ptr() as *const [G; OUT_577]) }; __ret } } else { aiur_fn_577(__args, record, io_buffer, __cu)? } }; let __v_15: G = G::from_u64(1); let __v_16: G = G::from_u64(1); let __v_17: G = { let __values: [G; 3] = [__v_15, __v_16, __v_16]; let __mq = record.memory_queries.get_mut(&3).ok_or(ExecError::InvalidMemorySize(3))?; if let Some(result) = __mq.get_mut(&__values[..]) { if !unconstrained { *result.multiplicity += G::ONE; } result.output[0] } else { let __ptr = G::from_usize(__mq.len()); __mq.insert(&__values[..], &[__ptr], G::from_bool(!unconstrained)); __ptr } }; - let __r_arr: [G; OUT_499] = { let __args: [G; IN_499] = [__v_2, __v_17]; let __cu = unconstrained; if let Some(result) = record.function_queries[499].get_mut(&__args[..]) { if !__cu && *result.multiplicity == G::ZERO { aiur_fn_499(__args, record, io_buffer, false)? } else { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_499] = unsafe { *(result.output.as_ptr() as *const [G; OUT_499]) }; __ret } } else { aiur_fn_499(__args, record, io_buffer, __cu)? } }; + let __r_arr: [G; OUT_495] = { let __args: [G; IN_495] = [__v_2, __v_17]; let __cu = unconstrained; if let Some(result) = record.function_queries[495].get_mut(&__args[..]) { if !__cu && *result.multiplicity == G::ZERO { aiur_fn_495(__args, record, io_buffer, false)? } else { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_495] = unsafe { *(result.output.as_ptr() as *const [G; OUT_495]) }; __ret } } else { aiur_fn_495(__args, record, io_buffer, __cu)? } }; let __v_18: G = __r_arr[0]; - let __r_arr: [G; OUT_578] = { let __args: [G; IN_578] = [__v_13, __v_2]; let __cu = unconstrained; if let Some(result) = record.function_queries[578].get_mut(&__args[..]) { if !__cu && *result.multiplicity == G::ZERO { aiur_fn_578(__args, record, io_buffer, false)? } else { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_578] = unsafe { *(result.output.as_ptr() as *const [G; OUT_578]) }; __ret } } else { aiur_fn_578(__args, record, io_buffer, __cu)? } }; - let __r_arr: [G; OUT_575] = { let __args: [G; IN_575] = [__v_10]; let __cu = unconstrained; if let Some(result) = record.function_queries[575].get_mut(&__args[..]) { if !__cu && *result.multiplicity == G::ZERO { aiur_fn_575(__args, record, io_buffer, false)? } else { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_575] = unsafe { *(result.output.as_ptr() as *const [G; OUT_575]) }; __ret } } else { aiur_fn_575(__args, record, io_buffer, __cu)? } }; - let __r_arr: [G; OUT_692] = { let __args: [G; IN_692] = [__v_0, __v_1, __v_2, __v_3, __v_4, __v_5, __v_6, __v_7, __v_8, __v_9, __v_10, __v_11, __v_12]; let __cu = unconstrained; if let Some(result) = record.function_queries[692].get_mut(&__args[..]) { if !__cu && *result.multiplicity == G::ZERO { aiur_fn_692(__args, record, io_buffer, false)? } else { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_692] = unsafe { *(result.output.as_ptr() as *const [G; OUT_692]) }; __ret } } else { aiur_fn_692(__args, record, io_buffer, __cu)? } }; - let __ret: [G; OUT_697] = []; - if let Some(result) = record.function_queries[697].get_mut(&inp[..]) { debug_assert_eq!(result.output, &__ret[..]); if !unconstrained { *result.multiplicity += G::ONE; } } else { record.function_queries[697].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained)); }; + let __r_arr: [G; OUT_574] = { let __args: [G; IN_574] = [__v_13, __v_2]; let __cu = unconstrained; if let Some(result) = record.function_queries[574].get_mut(&__args[..]) { if !__cu && *result.multiplicity == G::ZERO { aiur_fn_574(__args, record, io_buffer, false)? } else { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_574] = unsafe { *(result.output.as_ptr() as *const [G; OUT_574]) }; __ret } } else { aiur_fn_574(__args, record, io_buffer, __cu)? } }; + let __r_arr: [G; OUT_571] = { let __args: [G; IN_571] = [__v_10]; let __cu = unconstrained; if let Some(result) = record.function_queries[571].get_mut(&__args[..]) { if !__cu && *result.multiplicity == G::ZERO { aiur_fn_571(__args, record, io_buffer, false)? } else { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_571] = unsafe { *(result.output.as_ptr() as *const [G; OUT_571]) }; __ret } } else { aiur_fn_571(__args, record, io_buffer, __cu)? } }; + let __r_arr: [G; OUT_688] = { let __args: [G; IN_688] = [__v_0, __v_1, __v_2, __v_3, __v_4, __v_5, __v_6, __v_7, __v_8, __v_9, __v_10, __v_11, __v_12]; let __cu = unconstrained; if let Some(result) = record.function_queries[688].get_mut(&__args[..]) { if !__cu && *result.multiplicity == G::ZERO { aiur_fn_688(__args, record, io_buffer, false)? } else { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_688] = unsafe { *(result.output.as_ptr() as *const [G; OUT_688]) }; __ret } } else { aiur_fn_688(__args, record, io_buffer, __cu)? } }; + let __ret: [G; OUT_693] = []; + if let Some(result) = record.function_queries[693].get_mut(&inp[..]) { debug_assert_eq!(result.output, &__ret[..]); if !unconstrained { *result.multiplicity += G::ONE; } } else { record.function_queries[693].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained)); }; return Ok(__ret); }, _ => { @@ -58676,18 +58404,18 @@ fn aiur_fn_697( }) } -const INPUT_SIZE_698: usize = 1; -const IN_698: usize = 1; -const OUT_698: usize = 0; -fn aiur_fn_698( - inp: [G; IN_698], +const INPUT_SIZE_694: usize = 1; +const IN_694: usize = 1; +const OUT_694: usize = 0; +fn aiur_fn_694( + inp: [G; IN_694], record: &mut QueryRecord, io_buffer: &mut IOBuffer, unconstrained: bool, -) -> Result<[G; OUT_698], ExecError> { +) -> Result<[G; OUT_694], ExecError> { stacker::maybe_grow(64 * 1024, 4 * 1024 * 1024, || { let __v_0: G = inp[0]; - let __r_arr: [G; OUT_287] = { let __args: [G; IN_287] = [__v_0]; let __cu = unconstrained; if let Some(result) = record.function_queries[287].get_mut(&__args[..]) { if !__cu && *result.multiplicity == G::ZERO { aiur_fn_287(__args, record, io_buffer, false)? } else { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_287] = unsafe { *(result.output.as_ptr() as *const [G; OUT_287]) }; __ret } } else { aiur_fn_287(__args, record, io_buffer, __cu)? } }; + let __r_arr: [G; OUT_283] = { let __args: [G; IN_283] = [__v_0]; let __cu = unconstrained; if let Some(result) = record.function_queries[283].get_mut(&__args[..]) { if !__cu && *result.multiplicity == G::ZERO { aiur_fn_283(__args, record, io_buffer, false)? } else { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_283] = unsafe { *(result.output.as_ptr() as *const [G; OUT_283]) }; __ret } } else { aiur_fn_283(__args, record, io_buffer, __cu)? } }; let __v_1: G = __r_arr[0]; let __loaded: [G; 12] = { let __mq = record.memory_queries.get_mut(&12).ok_or(ExecError::InvalidMemorySize(12))?; let __ptr_u64 = __v_1.as_canonical_u64(); let __ptr_usize = usize::try_from(__ptr_u64).ok().ok_or(ExecError::PointerTooLarge(__ptr_u64))?; let (__args, __mult) = __mq.get_index_mut(__ptr_usize).ok_or(ExecError::UnboundPointer { ptr: __ptr_u64, size: 12 })?; if !unconstrained { *__mult += G::ONE; } let __arr: [G; 12] = __args[..12].try_into().unwrap(); __arr }; let __v_2: G = __loaded[0]; @@ -58702,22 +58430,22 @@ fn aiur_fn_698( let __v_11: G = __loaded[9]; let __v_12: G = __loaded[10]; let __v_13: G = __loaded[11]; - let __r_arr: [G; OUT_697] = { let __args: [G; IN_697] = [__v_2, __v_3, __v_4, __v_5, __v_6, __v_7, __v_8, __v_9, __v_10, __v_11, __v_12, __v_13, __v_0]; let __cu = unconstrained; if let Some(result) = record.function_queries[697].get_mut(&__args[..]) { if !__cu && *result.multiplicity == G::ZERO { aiur_fn_697(__args, record, io_buffer, false)? } else { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_697] = unsafe { *(result.output.as_ptr() as *const [G; OUT_697]) }; __ret } } else { aiur_fn_697(__args, record, io_buffer, __cu)? } }; - let __ret: [G; OUT_698] = []; - if let Some(result) = record.function_queries[698].get_mut(&inp[..]) { debug_assert_eq!(result.output, &__ret[..]); if !unconstrained { *result.multiplicity += G::ONE; } } else { record.function_queries[698].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained)); }; + let __r_arr: [G; OUT_693] = { let __args: [G; IN_693] = [__v_2, __v_3, __v_4, __v_5, __v_6, __v_7, __v_8, __v_9, __v_10, __v_11, __v_12, __v_13, __v_0]; let __cu = unconstrained; if let Some(result) = record.function_queries[693].get_mut(&__args[..]) { if !__cu && *result.multiplicity == G::ZERO { aiur_fn_693(__args, record, io_buffer, false)? } else { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_693] = unsafe { *(result.output.as_ptr() as *const [G; OUT_693]) }; __ret } } else { aiur_fn_693(__args, record, io_buffer, __cu)? } }; + let __ret: [G; OUT_694] = []; + if let Some(result) = record.function_queries[694].get_mut(&inp[..]) { debug_assert_eq!(result.output, &__ret[..]); if !unconstrained { *result.multiplicity += G::ONE; } } else { record.function_queries[694].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained)); }; return Ok(__ret); }) } -const INPUT_SIZE_699: usize = 1; -const IN_699: usize = 1; -const OUT_699: usize = 1; -fn aiur_fn_699( - inp: [G; IN_699], +const INPUT_SIZE_695: usize = 1; +const IN_695: usize = 1; +const OUT_695: usize = 1; +fn aiur_fn_695( + inp: [G; IN_695], record: &mut QueryRecord, io_buffer: &mut IOBuffer, unconstrained: bool, -) -> Result<[G; OUT_699], ExecError> { +) -> Result<[G; OUT_695], ExecError> { stacker::maybe_grow(64 * 1024, 4 * 1024 * 1024, || { let __v_0: G = inp[0]; let __loaded: [G; 18] = { let __mq = record.memory_queries.get_mut(&18).ok_or(ExecError::InvalidMemorySize(18))?; let __ptr_u64 = __v_0.as_canonical_u64(); let __ptr_usize = usize::try_from(__ptr_u64).ok().ok_or(ExecError::PointerTooLarge(__ptr_u64))?; let (__args, __mult) = __mq.get_index_mut(__ptr_usize).ok_or(ExecError::UnboundPointer { ptr: __ptr_u64, size: 18 })?; if !unconstrained { *__mult += G::ONE; } let __arr: [G; 18] = __args[..18].try_into().unwrap(); __arr }; @@ -58748,90 +58476,90 @@ fn aiur_fn_699( let __v_22: G = G::from_u64(1); let __v_23: G = { let __values: [G; 3] = [__v_21, __v_22, __v_22]; let __mq = record.memory_queries.get_mut(&3).ok_or(ExecError::InvalidMemorySize(3))?; if let Some(result) = __mq.get_mut(&__values[..]) { if !unconstrained { *result.multiplicity += G::ONE; } result.output[0] } else { let __ptr = G::from_usize(__mq.len()); __mq.insert(&__values[..], &[__ptr], G::from_bool(!unconstrained)); __ptr } }; let __v_24: G = { let __values: [G; 3] = [__v_19, __v_20, __v_23]; let __mq = record.memory_queries.get_mut(&3).ok_or(ExecError::InvalidMemorySize(3))?; if let Some(result) = __mq.get_mut(&__values[..]) { if !unconstrained { *result.multiplicity += G::ONE; } result.output[0] } else { let __ptr = G::from_usize(__mq.len()); __mq.insert(&__values[..], &[__ptr], G::from_bool(!unconstrained)); __ptr } }; - let __ret: [G; OUT_699] = [__v_24]; - if let Some(result) = record.function_queries[699].get_mut(&inp[..]) { debug_assert_eq!(result.output, &__ret[..]); if !unconstrained { *result.multiplicity += G::ONE; } } else { record.function_queries[699].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained)); }; + let __ret: [G; OUT_695] = [__v_24]; + if let Some(result) = record.function_queries[695].get_mut(&inp[..]) { debug_assert_eq!(result.output, &__ret[..]); if !unconstrained { *result.multiplicity += G::ONE; } } else { record.function_queries[695].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained)); }; return Ok(__ret); }, 4u64 => { let __v_19: G = G::from_u64(0); let __r_arr: [G; OUT_16] = { let __args: [G; IN_16] = [__v_2, __v_3, __v_4, __v_5, __v_6, __v_7, __v_8, __v_9]; let __cu = unconstrained; if let Some(result) = record.function_queries[16].get_mut(&__args[..]) { if !__cu && *result.multiplicity == G::ZERO { aiur_fn_16(__args, record, io_buffer, false)? } else { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_16] = unsafe { *(result.output.as_ptr() as *const [G; OUT_16]) }; __ret } } else { aiur_fn_16(__args, record, io_buffer, __cu)? } }; let __v_20: G = __r_arr[0]; - let __r_arr: [G; OUT_699] = { let __args: [G; IN_699] = [__v_18]; let __cu = unconstrained; if let Some(result) = record.function_queries[699].get_mut(&__args[..]) { if !__cu && *result.multiplicity == G::ZERO { aiur_fn_699(__args, record, io_buffer, false)? } else { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_699] = unsafe { *(result.output.as_ptr() as *const [G; OUT_699]) }; __ret } } else { aiur_fn_699(__args, record, io_buffer, __cu)? } }; + let __r_arr: [G; OUT_695] = { let __args: [G; IN_695] = [__v_18]; let __cu = unconstrained; if let Some(result) = record.function_queries[695].get_mut(&__args[..]) { if !__cu && *result.multiplicity == G::ZERO { aiur_fn_695(__args, record, io_buffer, false)? } else { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_695] = unsafe { *(result.output.as_ptr() as *const [G; OUT_695]) }; __ret } } else { aiur_fn_695(__args, record, io_buffer, __cu)? } }; let __v_21: G = __r_arr[0]; let __v_22: G = { let __values: [G; 3] = [__v_19, __v_20, __v_21]; let __mq = record.memory_queries.get_mut(&3).ok_or(ExecError::InvalidMemorySize(3))?; if let Some(result) = __mq.get_mut(&__values[..]) { if !unconstrained { *result.multiplicity += G::ONE; } result.output[0] } else { let __ptr = G::from_usize(__mq.len()); __mq.insert(&__values[..], &[__ptr], G::from_bool(!unconstrained)); __ptr } }; - let __ret: [G; OUT_699] = [__v_22]; - if let Some(result) = record.function_queries[699].get_mut(&inp[..]) { debug_assert_eq!(result.output, &__ret[..]); if !unconstrained { *result.multiplicity += G::ONE; } } else { record.function_queries[699].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained)); }; + let __ret: [G; OUT_695] = [__v_22]; + if let Some(result) = record.function_queries[695].get_mut(&inp[..]) { debug_assert_eq!(result.output, &__ret[..]); if !unconstrained { *result.multiplicity += G::ONE; } } else { record.function_queries[695].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained)); }; return Ok(__ret); }, 7u64 => { - let __r_arr: [G; OUT_699] = { let __args: [G; IN_699] = [__v_2]; let __cu = unconstrained; if let Some(result) = record.function_queries[699].get_mut(&__args[..]) { if !__cu && *result.multiplicity == G::ZERO { aiur_fn_699(__args, record, io_buffer, false)? } else { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_699] = unsafe { *(result.output.as_ptr() as *const [G; OUT_699]) }; __ret } } else { aiur_fn_699(__args, record, io_buffer, __cu)? } }; + let __r_arr: [G; OUT_695] = { let __args: [G; IN_695] = [__v_2]; let __cu = unconstrained; if let Some(result) = record.function_queries[695].get_mut(&__args[..]) { if !__cu && *result.multiplicity == G::ZERO { aiur_fn_695(__args, record, io_buffer, false)? } else { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_695] = unsafe { *(result.output.as_ptr() as *const [G; OUT_695]) }; __ret } } else { aiur_fn_695(__args, record, io_buffer, __cu)? } }; let __v_19: G = __r_arr[0]; - let __r_arr: [G; OUT_699] = { let __args: [G; IN_699] = [__v_3]; let __cu = unconstrained; if let Some(result) = record.function_queries[699].get_mut(&__args[..]) { if !__cu && *result.multiplicity == G::ZERO { aiur_fn_699(__args, record, io_buffer, false)? } else { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_699] = unsafe { *(result.output.as_ptr() as *const [G; OUT_699]) }; __ret } } else { aiur_fn_699(__args, record, io_buffer, __cu)? } }; + let __r_arr: [G; OUT_695] = { let __args: [G; IN_695] = [__v_3]; let __cu = unconstrained; if let Some(result) = record.function_queries[695].get_mut(&__args[..]) { if !__cu && *result.multiplicity == G::ZERO { aiur_fn_695(__args, record, io_buffer, false)? } else { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_695] = unsafe { *(result.output.as_ptr() as *const [G; OUT_695]) }; __ret } } else { aiur_fn_695(__args, record, io_buffer, __cu)? } }; let __v_20: G = __r_arr[0]; - let __r_arr: [G; OUT_763] = { let __args: [G; IN_763] = [__v_19, __v_20]; let __cu = unconstrained; if let Some(result) = record.function_queries[763].get_mut(&__args[..]) { if !__cu && *result.multiplicity == G::ZERO { aiur_fn_763(__args, record, io_buffer, false)? } else { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_763] = unsafe { *(result.output.as_ptr() as *const [G; OUT_763]) }; __ret } } else { aiur_fn_763(__args, record, io_buffer, __cu)? } }; + let __r_arr: [G; OUT_759] = { let __args: [G; IN_759] = [__v_19, __v_20]; let __cu = unconstrained; if let Some(result) = record.function_queries[759].get_mut(&__args[..]) { if !__cu && *result.multiplicity == G::ZERO { aiur_fn_759(__args, record, io_buffer, false)? } else { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_759] = unsafe { *(result.output.as_ptr() as *const [G; OUT_759]) }; __ret } } else { aiur_fn_759(__args, record, io_buffer, __cu)? } }; let __v_21: G = __r_arr[0]; - let __ret: [G; OUT_699] = [__v_21]; - if let Some(result) = record.function_queries[699].get_mut(&inp[..]) { debug_assert_eq!(result.output, &__ret[..]); if !unconstrained { *result.multiplicity += G::ONE; } } else { record.function_queries[699].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained)); }; + let __ret: [G; OUT_695] = [__v_21]; + if let Some(result) = record.function_queries[695].get_mut(&inp[..]) { debug_assert_eq!(result.output, &__ret[..]); if !unconstrained { *result.multiplicity += G::ONE; } } else { record.function_queries[695].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained)); }; return Ok(__ret); }, 8u64 => { - let __r_arr: [G; OUT_699] = { let __args: [G; IN_699] = [__v_2]; let __cu = unconstrained; if let Some(result) = record.function_queries[699].get_mut(&__args[..]) { if !__cu && *result.multiplicity == G::ZERO { aiur_fn_699(__args, record, io_buffer, false)? } else { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_699] = unsafe { *(result.output.as_ptr() as *const [G; OUT_699]) }; __ret } } else { aiur_fn_699(__args, record, io_buffer, __cu)? } }; + let __r_arr: [G; OUT_695] = { let __args: [G; IN_695] = [__v_2]; let __cu = unconstrained; if let Some(result) = record.function_queries[695].get_mut(&__args[..]) { if !__cu && *result.multiplicity == G::ZERO { aiur_fn_695(__args, record, io_buffer, false)? } else { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_695] = unsafe { *(result.output.as_ptr() as *const [G; OUT_695]) }; __ret } } else { aiur_fn_695(__args, record, io_buffer, __cu)? } }; let __v_19: G = __r_arr[0]; - let __r_arr: [G; OUT_699] = { let __args: [G; IN_699] = [__v_3]; let __cu = unconstrained; if let Some(result) = record.function_queries[699].get_mut(&__args[..]) { if !__cu && *result.multiplicity == G::ZERO { aiur_fn_699(__args, record, io_buffer, false)? } else { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_699] = unsafe { *(result.output.as_ptr() as *const [G; OUT_699]) }; __ret } } else { aiur_fn_699(__args, record, io_buffer, __cu)? } }; + let __r_arr: [G; OUT_695] = { let __args: [G; IN_695] = [__v_3]; let __cu = unconstrained; if let Some(result) = record.function_queries[695].get_mut(&__args[..]) { if !__cu && *result.multiplicity == G::ZERO { aiur_fn_695(__args, record, io_buffer, false)? } else { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_695] = unsafe { *(result.output.as_ptr() as *const [G; OUT_695]) }; __ret } } else { aiur_fn_695(__args, record, io_buffer, __cu)? } }; let __v_20: G = __r_arr[0]; - let __r_arr: [G; OUT_763] = { let __args: [G; IN_763] = [__v_19, __v_20]; let __cu = unconstrained; if let Some(result) = record.function_queries[763].get_mut(&__args[..]) { if !__cu && *result.multiplicity == G::ZERO { aiur_fn_763(__args, record, io_buffer, false)? } else { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_763] = unsafe { *(result.output.as_ptr() as *const [G; OUT_763]) }; __ret } } else { aiur_fn_763(__args, record, io_buffer, __cu)? } }; + let __r_arr: [G; OUT_759] = { let __args: [G; IN_759] = [__v_19, __v_20]; let __cu = unconstrained; if let Some(result) = record.function_queries[759].get_mut(&__args[..]) { if !__cu && *result.multiplicity == G::ZERO { aiur_fn_759(__args, record, io_buffer, false)? } else { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_759] = unsafe { *(result.output.as_ptr() as *const [G; OUT_759]) }; __ret } } else { aiur_fn_759(__args, record, io_buffer, __cu)? } }; let __v_21: G = __r_arr[0]; - let __ret: [G; OUT_699] = [__v_21]; - if let Some(result) = record.function_queries[699].get_mut(&inp[..]) { debug_assert_eq!(result.output, &__ret[..]); if !unconstrained { *result.multiplicity += G::ONE; } } else { record.function_queries[699].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained)); }; + let __ret: [G; OUT_695] = [__v_21]; + if let Some(result) = record.function_queries[695].get_mut(&inp[..]) { debug_assert_eq!(result.output, &__ret[..]); if !unconstrained { *result.multiplicity += G::ONE; } } else { record.function_queries[695].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained)); }; return Ok(__ret); }, 9u64 => { - let __r_arr: [G; OUT_699] = { let __args: [G; IN_699] = [__v_2]; let __cu = unconstrained; if let Some(result) = record.function_queries[699].get_mut(&__args[..]) { if !__cu && *result.multiplicity == G::ZERO { aiur_fn_699(__args, record, io_buffer, false)? } else { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_699] = unsafe { *(result.output.as_ptr() as *const [G; OUT_699]) }; __ret } } else { aiur_fn_699(__args, record, io_buffer, __cu)? } }; + let __r_arr: [G; OUT_695] = { let __args: [G; IN_695] = [__v_2]; let __cu = unconstrained; if let Some(result) = record.function_queries[695].get_mut(&__args[..]) { if !__cu && *result.multiplicity == G::ZERO { aiur_fn_695(__args, record, io_buffer, false)? } else { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_695] = unsafe { *(result.output.as_ptr() as *const [G; OUT_695]) }; __ret } } else { aiur_fn_695(__args, record, io_buffer, __cu)? } }; let __v_19: G = __r_arr[0]; - let __r_arr: [G; OUT_699] = { let __args: [G; IN_699] = [__v_3]; let __cu = unconstrained; if let Some(result) = record.function_queries[699].get_mut(&__args[..]) { if !__cu && *result.multiplicity == G::ZERO { aiur_fn_699(__args, record, io_buffer, false)? } else { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_699] = unsafe { *(result.output.as_ptr() as *const [G; OUT_699]) }; __ret } } else { aiur_fn_699(__args, record, io_buffer, __cu)? } }; + let __r_arr: [G; OUT_695] = { let __args: [G; IN_695] = [__v_3]; let __cu = unconstrained; if let Some(result) = record.function_queries[695].get_mut(&__args[..]) { if !__cu && *result.multiplicity == G::ZERO { aiur_fn_695(__args, record, io_buffer, false)? } else { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_695] = unsafe { *(result.output.as_ptr() as *const [G; OUT_695]) }; __ret } } else { aiur_fn_695(__args, record, io_buffer, __cu)? } }; let __v_20: G = __r_arr[0]; - let __r_arr: [G; OUT_763] = { let __args: [G; IN_763] = [__v_19, __v_20]; let __cu = unconstrained; if let Some(result) = record.function_queries[763].get_mut(&__args[..]) { if !__cu && *result.multiplicity == G::ZERO { aiur_fn_763(__args, record, io_buffer, false)? } else { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_763] = unsafe { *(result.output.as_ptr() as *const [G; OUT_763]) }; __ret } } else { aiur_fn_763(__args, record, io_buffer, __cu)? } }; + let __r_arr: [G; OUT_759] = { let __args: [G; IN_759] = [__v_19, __v_20]; let __cu = unconstrained; if let Some(result) = record.function_queries[759].get_mut(&__args[..]) { if !__cu && *result.multiplicity == G::ZERO { aiur_fn_759(__args, record, io_buffer, false)? } else { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_759] = unsafe { *(result.output.as_ptr() as *const [G; OUT_759]) }; __ret } } else { aiur_fn_759(__args, record, io_buffer, __cu)? } }; let __v_21: G = __r_arr[0]; - let __ret: [G; OUT_699] = [__v_21]; - if let Some(result) = record.function_queries[699].get_mut(&inp[..]) { debug_assert_eq!(result.output, &__ret[..]); if !unconstrained { *result.multiplicity += G::ONE; } } else { record.function_queries[699].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained)); }; + let __ret: [G; OUT_695] = [__v_21]; + if let Some(result) = record.function_queries[695].get_mut(&inp[..]) { debug_assert_eq!(result.output, &__ret[..]); if !unconstrained { *result.multiplicity += G::ONE; } } else { record.function_queries[695].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained)); }; return Ok(__ret); }, 10u64 => { - let __r_arr: [G; OUT_699] = { let __args: [G; IN_699] = [__v_10]; let __cu = unconstrained; if let Some(result) = record.function_queries[699].get_mut(&__args[..]) { if !__cu && *result.multiplicity == G::ZERO { aiur_fn_699(__args, record, io_buffer, false)? } else { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_699] = unsafe { *(result.output.as_ptr() as *const [G; OUT_699]) }; __ret } } else { aiur_fn_699(__args, record, io_buffer, __cu)? } }; + let __r_arr: [G; OUT_695] = { let __args: [G; IN_695] = [__v_10]; let __cu = unconstrained; if let Some(result) = record.function_queries[695].get_mut(&__args[..]) { if !__cu && *result.multiplicity == G::ZERO { aiur_fn_695(__args, record, io_buffer, false)? } else { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_695] = unsafe { *(result.output.as_ptr() as *const [G; OUT_695]) }; __ret } } else { aiur_fn_695(__args, record, io_buffer, __cu)? } }; let __v_19: G = __r_arr[0]; - let __r_arr: [G; OUT_699] = { let __args: [G; IN_699] = [__v_11]; let __cu = unconstrained; if let Some(result) = record.function_queries[699].get_mut(&__args[..]) { if !__cu && *result.multiplicity == G::ZERO { aiur_fn_699(__args, record, io_buffer, false)? } else { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_699] = unsafe { *(result.output.as_ptr() as *const [G; OUT_699]) }; __ret } } else { aiur_fn_699(__args, record, io_buffer, __cu)? } }; + let __r_arr: [G; OUT_695] = { let __args: [G; IN_695] = [__v_11]; let __cu = unconstrained; if let Some(result) = record.function_queries[695].get_mut(&__args[..]) { if !__cu && *result.multiplicity == G::ZERO { aiur_fn_695(__args, record, io_buffer, false)? } else { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_695] = unsafe { *(result.output.as_ptr() as *const [G; OUT_695]) }; __ret } } else { aiur_fn_695(__args, record, io_buffer, __cu)? } }; let __v_20: G = __r_arr[0]; - let __r_arr: [G; OUT_699] = { let __args: [G; IN_699] = [__v_12]; let __cu = unconstrained; if let Some(result) = record.function_queries[699].get_mut(&__args[..]) { if !__cu && *result.multiplicity == G::ZERO { aiur_fn_699(__args, record, io_buffer, false)? } else { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_699] = unsafe { *(result.output.as_ptr() as *const [G; OUT_699]) }; __ret } } else { aiur_fn_699(__args, record, io_buffer, __cu)? } }; + let __r_arr: [G; OUT_695] = { let __args: [G; IN_695] = [__v_12]; let __cu = unconstrained; if let Some(result) = record.function_queries[695].get_mut(&__args[..]) { if !__cu && *result.multiplicity == G::ZERO { aiur_fn_695(__args, record, io_buffer, false)? } else { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_695] = unsafe { *(result.output.as_ptr() as *const [G; OUT_695]) }; __ret } } else { aiur_fn_695(__args, record, io_buffer, __cu)? } }; let __v_21: G = __r_arr[0]; - let __r_arr: [G; OUT_763] = { let __args: [G; IN_763] = [__v_20, __v_21]; let __cu = unconstrained; if let Some(result) = record.function_queries[763].get_mut(&__args[..]) { if !__cu && *result.multiplicity == G::ZERO { aiur_fn_763(__args, record, io_buffer, false)? } else { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_763] = unsafe { *(result.output.as_ptr() as *const [G; OUT_763]) }; __ret } } else { aiur_fn_763(__args, record, io_buffer, __cu)? } }; + let __r_arr: [G; OUT_759] = { let __args: [G; IN_759] = [__v_20, __v_21]; let __cu = unconstrained; if let Some(result) = record.function_queries[759].get_mut(&__args[..]) { if !__cu && *result.multiplicity == G::ZERO { aiur_fn_759(__args, record, io_buffer, false)? } else { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_759] = unsafe { *(result.output.as_ptr() as *const [G; OUT_759]) }; __ret } } else { aiur_fn_759(__args, record, io_buffer, __cu)? } }; let __v_22: G = __r_arr[0]; - let __r_arr: [G; OUT_763] = { let __args: [G; IN_763] = [__v_19, __v_22]; let __cu = unconstrained; if let Some(result) = record.function_queries[763].get_mut(&__args[..]) { if !__cu && *result.multiplicity == G::ZERO { aiur_fn_763(__args, record, io_buffer, false)? } else { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_763] = unsafe { *(result.output.as_ptr() as *const [G; OUT_763]) }; __ret } } else { aiur_fn_763(__args, record, io_buffer, __cu)? } }; + let __r_arr: [G; OUT_759] = { let __args: [G; IN_759] = [__v_19, __v_22]; let __cu = unconstrained; if let Some(result) = record.function_queries[759].get_mut(&__args[..]) { if !__cu && *result.multiplicity == G::ZERO { aiur_fn_759(__args, record, io_buffer, false)? } else { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_759] = unsafe { *(result.output.as_ptr() as *const [G; OUT_759]) }; __ret } } else { aiur_fn_759(__args, record, io_buffer, __cu)? } }; let __v_23: G = __r_arr[0]; - let __ret: [G; OUT_699] = [__v_23]; - if let Some(result) = record.function_queries[699].get_mut(&inp[..]) { debug_assert_eq!(result.output, &__ret[..]); if !unconstrained { *result.multiplicity += G::ONE; } } else { record.function_queries[699].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained)); }; + let __ret: [G; OUT_695] = [__v_23]; + if let Some(result) = record.function_queries[695].get_mut(&inp[..]) { debug_assert_eq!(result.output, &__ret[..]); if !unconstrained { *result.multiplicity += G::ONE; } } else { record.function_queries[695].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained)); }; return Ok(__ret); }, _ => { let __v_19: G = G::from_u64(1); let __v_20: G = G::from_u64(1); let __v_21: G = { let __values: [G; 3] = [__v_19, __v_20, __v_20]; let __mq = record.memory_queries.get_mut(&3).ok_or(ExecError::InvalidMemorySize(3))?; if let Some(result) = __mq.get_mut(&__values[..]) { if !unconstrained { *result.multiplicity += G::ONE; } result.output[0] } else { let __ptr = G::from_usize(__mq.len()); __mq.insert(&__values[..], &[__ptr], G::from_bool(!unconstrained)); __ptr } }; - let __ret: [G; OUT_699] = [__v_21]; - if let Some(result) = record.function_queries[699].get_mut(&inp[..]) { debug_assert_eq!(result.output, &__ret[..]); if !unconstrained { *result.multiplicity += G::ONE; } } else { record.function_queries[699].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained)); }; + let __ret: [G; OUT_695] = [__v_21]; + if let Some(result) = record.function_queries[695].get_mut(&inp[..]) { debug_assert_eq!(result.output, &__ret[..]); if !unconstrained { *result.multiplicity += G::ONE; } } else { record.function_queries[695].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained)); }; return Ok(__ret); }, } }) } -const INPUT_SIZE_700: usize = 1; -const IN_700: usize = 1; -const OUT_700: usize = 1; -fn aiur_fn_700( - inp: [G; IN_700], +const INPUT_SIZE_696: usize = 1; +const IN_696: usize = 1; +const OUT_696: usize = 1; +fn aiur_fn_696( + inp: [G; IN_696], record: &mut QueryRecord, io_buffer: &mut IOBuffer, unconstrained: bool, -) -> Result<[G; OUT_700], ExecError> { +) -> Result<[G; OUT_696], ExecError> { stacker::maybe_grow(64 * 1024, 4 * 1024 * 1024, || { let __v_0: G = inp[0]; let __loaded: [G; 3] = { let __mq = record.memory_queries.get_mut(&3).ok_or(ExecError::InvalidMemorySize(3))?; let __ptr_u64 = __v_0.as_canonical_u64(); let __ptr_usize = usize::try_from(__ptr_u64).ok().ok_or(ExecError::PointerTooLarge(__ptr_u64))?; let (__args, __mult) = __mq.get_index_mut(__ptr_usize).ok_or(ExecError::UnboundPointer { ptr: __ptr_u64, size: 3 })?; if !unconstrained { *__mult += G::ONE; } let __arr: [G; 3] = __args[..3].try_into().unwrap(); __arr }; @@ -58843,19 +58571,19 @@ fn aiur_fn_700( let __v_4: G = G::from_u64(1); let __v_5: G = G::from_u64(1); let __v_6: G = { let __values: [G; 3] = [__v_4, __v_5, __v_5]; let __mq = record.memory_queries.get_mut(&3).ok_or(ExecError::InvalidMemorySize(3))?; if let Some(result) = __mq.get_mut(&__values[..]) { if !unconstrained { *result.multiplicity += G::ONE; } result.output[0] } else { let __ptr = G::from_usize(__mq.len()); __mq.insert(&__values[..], &[__ptr], G::from_bool(!unconstrained)); __ptr } }; - let __ret: [G; OUT_700] = [__v_6]; - if let Some(result) = record.function_queries[700].get_mut(&inp[..]) { debug_assert_eq!(result.output, &__ret[..]); if !unconstrained { *result.multiplicity += G::ONE; } } else { record.function_queries[700].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained)); }; + let __ret: [G; OUT_696] = [__v_6]; + if let Some(result) = record.function_queries[696].get_mut(&inp[..]) { debug_assert_eq!(result.output, &__ret[..]); if !unconstrained { *result.multiplicity += G::ONE; } } else { record.function_queries[696].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained)); }; return Ok(__ret); }, 0u64 => { - let __r_arr: [G; OUT_699] = { let __args: [G; IN_699] = [__v_2]; let __cu = unconstrained; if let Some(result) = record.function_queries[699].get_mut(&__args[..]) { if !__cu && *result.multiplicity == G::ZERO { aiur_fn_699(__args, record, io_buffer, false)? } else { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_699] = unsafe { *(result.output.as_ptr() as *const [G; OUT_699]) }; __ret } } else { aiur_fn_699(__args, record, io_buffer, __cu)? } }; + let __r_arr: [G; OUT_695] = { let __args: [G; IN_695] = [__v_2]; let __cu = unconstrained; if let Some(result) = record.function_queries[695].get_mut(&__args[..]) { if !__cu && *result.multiplicity == G::ZERO { aiur_fn_695(__args, record, io_buffer, false)? } else { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_695] = unsafe { *(result.output.as_ptr() as *const [G; OUT_695]) }; __ret } } else { aiur_fn_695(__args, record, io_buffer, __cu)? } }; let __v_4: G = __r_arr[0]; - let __r_arr: [G; OUT_700] = { let __args: [G; IN_700] = [__v_3]; let __cu = unconstrained; if let Some(result) = record.function_queries[700].get_mut(&__args[..]) { if !__cu && *result.multiplicity == G::ZERO { aiur_fn_700(__args, record, io_buffer, false)? } else { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_700] = unsafe { *(result.output.as_ptr() as *const [G; OUT_700]) }; __ret } } else { aiur_fn_700(__args, record, io_buffer, __cu)? } }; + let __r_arr: [G; OUT_696] = { let __args: [G; IN_696] = [__v_3]; let __cu = unconstrained; if let Some(result) = record.function_queries[696].get_mut(&__args[..]) { if !__cu && *result.multiplicity == G::ZERO { aiur_fn_696(__args, record, io_buffer, false)? } else { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_696] = unsafe { *(result.output.as_ptr() as *const [G; OUT_696]) }; __ret } } else { aiur_fn_696(__args, record, io_buffer, __cu)? } }; let __v_5: G = __r_arr[0]; - let __r_arr: [G; OUT_763] = { let __args: [G; IN_763] = [__v_4, __v_5]; let __cu = unconstrained; if let Some(result) = record.function_queries[763].get_mut(&__args[..]) { if !__cu && *result.multiplicity == G::ZERO { aiur_fn_763(__args, record, io_buffer, false)? } else { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_763] = unsafe { *(result.output.as_ptr() as *const [G; OUT_763]) }; __ret } } else { aiur_fn_763(__args, record, io_buffer, __cu)? } }; + let __r_arr: [G; OUT_759] = { let __args: [G; IN_759] = [__v_4, __v_5]; let __cu = unconstrained; if let Some(result) = record.function_queries[759].get_mut(&__args[..]) { if !__cu && *result.multiplicity == G::ZERO { aiur_fn_759(__args, record, io_buffer, false)? } else { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_759] = unsafe { *(result.output.as_ptr() as *const [G; OUT_759]) }; __ret } } else { aiur_fn_759(__args, record, io_buffer, __cu)? } }; let __v_6: G = __r_arr[0]; - let __ret: [G; OUT_700] = [__v_6]; - if let Some(result) = record.function_queries[700].get_mut(&inp[..]) { debug_assert_eq!(result.output, &__ret[..]); if !unconstrained { *result.multiplicity += G::ONE; } } else { record.function_queries[700].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained)); }; + let __ret: [G; OUT_696] = [__v_6]; + if let Some(result) = record.function_queries[696].get_mut(&inp[..]) { debug_assert_eq!(result.output, &__ret[..]); if !unconstrained { *result.multiplicity += G::ONE; } } else { record.function_queries[696].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained)); }; return Ok(__ret); }, _ => { @@ -58865,15 +58593,15 @@ fn aiur_fn_700( }) } -const INPUT_SIZE_701: usize = 1; -const IN_701: usize = 1; -const OUT_701: usize = 1; -fn aiur_fn_701( - inp: [G; IN_701], +const INPUT_SIZE_697: usize = 1; +const IN_697: usize = 1; +const OUT_697: usize = 1; +fn aiur_fn_697( + inp: [G; IN_697], record: &mut QueryRecord, io_buffer: &mut IOBuffer, unconstrained: bool, -) -> Result<[G; OUT_701], ExecError> { +) -> Result<[G; OUT_697], ExecError> { stacker::maybe_grow(64 * 1024, 4 * 1024 * 1024, || { let __v_0: G = inp[0]; let __loaded: [G; 11] = { let __mq = record.memory_queries.get_mut(&11).ok_or(ExecError::InvalidMemorySize(11))?; let __ptr_u64 = __v_0.as_canonical_u64(); let __ptr_usize = usize::try_from(__ptr_u64).ok().ok_or(ExecError::PointerTooLarge(__ptr_u64))?; let (__args, __mult) = __mq.get_index_mut(__ptr_usize).ok_or(ExecError::UnboundPointer { ptr: __ptr_u64, size: 11 })?; if !unconstrained { *__mult += G::ONE; } let __arr: [G; 11] = __args[..11].try_into().unwrap(); __arr }; @@ -58893,21 +58621,21 @@ fn aiur_fn_701( let __v_12: G = G::from_u64(1); let __v_13: G = G::from_u64(1); let __v_14: G = { let __values: [G; 3] = [__v_12, __v_13, __v_13]; let __mq = record.memory_queries.get_mut(&3).ok_or(ExecError::InvalidMemorySize(3))?; if let Some(result) = __mq.get_mut(&__values[..]) { if !unconstrained { *result.multiplicity += G::ONE; } result.output[0] } else { let __ptr = G::from_usize(__mq.len()); __mq.insert(&__values[..], &[__ptr], G::from_bool(!unconstrained)); __ptr } }; - let __ret: [G; OUT_701] = [__v_14]; - if let Some(result) = record.function_queries[701].get_mut(&inp[..]) { debug_assert_eq!(result.output, &__ret[..]); if !unconstrained { *result.multiplicity += G::ONE; } } else { record.function_queries[701].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained)); }; + let __ret: [G; OUT_697] = [__v_14]; + if let Some(result) = record.function_queries[697].get_mut(&inp[..]) { debug_assert_eq!(result.output, &__ret[..]); if !unconstrained { *result.multiplicity += G::ONE; } } else { record.function_queries[697].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained)); }; return Ok(__ret); }, 0u64 => { match __v_2.as_canonical_u64() { _ => { - let __r_arr: [G; OUT_699] = { let __args: [G; IN_699] = [__v_10]; let __cu = unconstrained; if let Some(result) = record.function_queries[699].get_mut(&__args[..]) { if !__cu && *result.multiplicity == G::ZERO { aiur_fn_699(__args, record, io_buffer, false)? } else { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_699] = unsafe { *(result.output.as_ptr() as *const [G; OUT_699]) }; __ret } } else { aiur_fn_699(__args, record, io_buffer, __cu)? } }; + let __r_arr: [G; OUT_695] = { let __args: [G; IN_695] = [__v_10]; let __cu = unconstrained; if let Some(result) = record.function_queries[695].get_mut(&__args[..]) { if !__cu && *result.multiplicity == G::ZERO { aiur_fn_695(__args, record, io_buffer, false)? } else { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_695] = unsafe { *(result.output.as_ptr() as *const [G; OUT_695]) }; __ret } } else { aiur_fn_695(__args, record, io_buffer, __cu)? } }; let __v_12: G = __r_arr[0]; - let __r_arr: [G; OUT_701] = { let __args: [G; IN_701] = [__v_11]; let __cu = unconstrained; if let Some(result) = record.function_queries[701].get_mut(&__args[..]) { if !__cu && *result.multiplicity == G::ZERO { aiur_fn_701(__args, record, io_buffer, false)? } else { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_701] = unsafe { *(result.output.as_ptr() as *const [G; OUT_701]) }; __ret } } else { aiur_fn_701(__args, record, io_buffer, __cu)? } }; + let __r_arr: [G; OUT_697] = { let __args: [G; IN_697] = [__v_11]; let __cu = unconstrained; if let Some(result) = record.function_queries[697].get_mut(&__args[..]) { if !__cu && *result.multiplicity == G::ZERO { aiur_fn_697(__args, record, io_buffer, false)? } else { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_697] = unsafe { *(result.output.as_ptr() as *const [G; OUT_697]) }; __ret } } else { aiur_fn_697(__args, record, io_buffer, __cu)? } }; let __v_13: G = __r_arr[0]; - let __r_arr: [G; OUT_763] = { let __args: [G; IN_763] = [__v_12, __v_13]; let __cu = unconstrained; if let Some(result) = record.function_queries[763].get_mut(&__args[..]) { if !__cu && *result.multiplicity == G::ZERO { aiur_fn_763(__args, record, io_buffer, false)? } else { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_763] = unsafe { *(result.output.as_ptr() as *const [G; OUT_763]) }; __ret } } else { aiur_fn_763(__args, record, io_buffer, __cu)? } }; + let __r_arr: [G; OUT_759] = { let __args: [G; IN_759] = [__v_12, __v_13]; let __cu = unconstrained; if let Some(result) = record.function_queries[759].get_mut(&__args[..]) { if !__cu && *result.multiplicity == G::ZERO { aiur_fn_759(__args, record, io_buffer, false)? } else { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_759] = unsafe { *(result.output.as_ptr() as *const [G; OUT_759]) }; __ret } } else { aiur_fn_759(__args, record, io_buffer, __cu)? } }; let __v_14: G = __r_arr[0]; - let __ret: [G; OUT_701] = [__v_14]; - if let Some(result) = record.function_queries[701].get_mut(&inp[..]) { debug_assert_eq!(result.output, &__ret[..]); if !unconstrained { *result.multiplicity += G::ONE; } } else { record.function_queries[701].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained)); }; + let __ret: [G; OUT_697] = [__v_14]; + if let Some(result) = record.function_queries[697].get_mut(&inp[..]) { debug_assert_eq!(result.output, &__ret[..]); if !unconstrained { *result.multiplicity += G::ONE; } } else { record.function_queries[697].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained)); }; return Ok(__ret); }, } @@ -58919,15 +58647,15 @@ fn aiur_fn_701( }) } -const INPUT_SIZE_702: usize = 1; -const IN_702: usize = 1; -const OUT_702: usize = 1; -fn aiur_fn_702( - inp: [G; IN_702], +const INPUT_SIZE_698: usize = 1; +const IN_698: usize = 1; +const OUT_698: usize = 1; +fn aiur_fn_698( + inp: [G; IN_698], record: &mut QueryRecord, io_buffer: &mut IOBuffer, unconstrained: bool, -) -> Result<[G; OUT_702], ExecError> { +) -> Result<[G; OUT_698], ExecError> { stacker::maybe_grow(64 * 1024, 4 * 1024 * 1024, || { let __v_0: G = inp[0]; let __loaded: [G; 36] = { let __mq = record.memory_queries.get_mut(&36).ok_or(ExecError::InvalidMemorySize(36))?; let __ptr_u64 = __v_0.as_canonical_u64(); let __ptr_usize = usize::try_from(__ptr_u64).ok().ok_or(ExecError::PointerTooLarge(__ptr_u64))?; let (__args, __mult) = __mq.get_index_mut(__ptr_usize).ok_or(ExecError::UnboundPointer { ptr: __ptr_u64, size: 36 })?; if !unconstrained { *__mult += G::ONE; } let __arr: [G; 36] = __args[..36].try_into().unwrap(); __arr }; @@ -58972,21 +58700,21 @@ fn aiur_fn_702( let __v_37: G = G::from_u64(1); let __v_38: G = G::from_u64(1); let __v_39: G = { let __values: [G; 3] = [__v_37, __v_38, __v_38]; let __mq = record.memory_queries.get_mut(&3).ok_or(ExecError::InvalidMemorySize(3))?; if let Some(result) = __mq.get_mut(&__values[..]) { if !unconstrained { *result.multiplicity += G::ONE; } result.output[0] } else { let __ptr = G::from_usize(__mq.len()); __mq.insert(&__values[..], &[__ptr], G::from_bool(!unconstrained)); __ptr } }; - let __ret: [G; OUT_702] = [__v_39]; - if let Some(result) = record.function_queries[702].get_mut(&inp[..]) { debug_assert_eq!(result.output, &__ret[..]); if !unconstrained { *result.multiplicity += G::ONE; } } else { record.function_queries[702].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained)); }; + let __ret: [G; OUT_698] = [__v_39]; + if let Some(result) = record.function_queries[698].get_mut(&inp[..]) { debug_assert_eq!(result.output, &__ret[..]); if !unconstrained { *result.multiplicity += G::ONE; } } else { record.function_queries[698].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained)); }; return Ok(__ret); }, 0u64 => { match __v_2.as_canonical_u64() { _ => { - let __r_arr: [G; OUT_699] = { let __args: [G; IN_699] = [__v_35]; let __cu = unconstrained; if let Some(result) = record.function_queries[699].get_mut(&__args[..]) { if !__cu && *result.multiplicity == G::ZERO { aiur_fn_699(__args, record, io_buffer, false)? } else { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_699] = unsafe { *(result.output.as_ptr() as *const [G; OUT_699]) }; __ret } } else { aiur_fn_699(__args, record, io_buffer, __cu)? } }; + let __r_arr: [G; OUT_695] = { let __args: [G; IN_695] = [__v_35]; let __cu = unconstrained; if let Some(result) = record.function_queries[695].get_mut(&__args[..]) { if !__cu && *result.multiplicity == G::ZERO { aiur_fn_695(__args, record, io_buffer, false)? } else { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_695] = unsafe { *(result.output.as_ptr() as *const [G; OUT_695]) }; __ret } } else { aiur_fn_695(__args, record, io_buffer, __cu)? } }; let __v_37: G = __r_arr[0]; - let __r_arr: [G; OUT_702] = { let __args: [G; IN_702] = [__v_36]; let __cu = unconstrained; if let Some(result) = record.function_queries[702].get_mut(&__args[..]) { if !__cu && *result.multiplicity == G::ZERO { aiur_fn_702(__args, record, io_buffer, false)? } else { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_702] = unsafe { *(result.output.as_ptr() as *const [G; OUT_702]) }; __ret } } else { aiur_fn_702(__args, record, io_buffer, __cu)? } }; + let __r_arr: [G; OUT_698] = { let __args: [G; IN_698] = [__v_36]; let __cu = unconstrained; if let Some(result) = record.function_queries[698].get_mut(&__args[..]) { if !__cu && *result.multiplicity == G::ZERO { aiur_fn_698(__args, record, io_buffer, false)? } else { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_698] = unsafe { *(result.output.as_ptr() as *const [G; OUT_698]) }; __ret } } else { aiur_fn_698(__args, record, io_buffer, __cu)? } }; let __v_38: G = __r_arr[0]; - let __r_arr: [G; OUT_763] = { let __args: [G; IN_763] = [__v_37, __v_38]; let __cu = unconstrained; if let Some(result) = record.function_queries[763].get_mut(&__args[..]) { if !__cu && *result.multiplicity == G::ZERO { aiur_fn_763(__args, record, io_buffer, false)? } else { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_763] = unsafe { *(result.output.as_ptr() as *const [G; OUT_763]) }; __ret } } else { aiur_fn_763(__args, record, io_buffer, __cu)? } }; + let __r_arr: [G; OUT_759] = { let __args: [G; IN_759] = [__v_37, __v_38]; let __cu = unconstrained; if let Some(result) = record.function_queries[759].get_mut(&__args[..]) { if !__cu && *result.multiplicity == G::ZERO { aiur_fn_759(__args, record, io_buffer, false)? } else { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_759] = unsafe { *(result.output.as_ptr() as *const [G; OUT_759]) }; __ret } } else { aiur_fn_759(__args, record, io_buffer, __cu)? } }; let __v_39: G = __r_arr[0]; - let __ret: [G; OUT_702] = [__v_39]; - if let Some(result) = record.function_queries[702].get_mut(&inp[..]) { debug_assert_eq!(result.output, &__ret[..]); if !unconstrained { *result.multiplicity += G::ONE; } } else { record.function_queries[702].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained)); }; + let __ret: [G; OUT_698] = [__v_39]; + if let Some(result) = record.function_queries[698].get_mut(&inp[..]) { debug_assert_eq!(result.output, &__ret[..]); if !unconstrained { *result.multiplicity += G::ONE; } } else { record.function_queries[698].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained)); }; return Ok(__ret); }, } @@ -58998,15 +58726,15 @@ fn aiur_fn_702( }) } -const INPUT_SIZE_703: usize = 1; -const IN_703: usize = 1; -const OUT_703: usize = 1; -fn aiur_fn_703( - inp: [G; IN_703], +const INPUT_SIZE_699: usize = 1; +const IN_699: usize = 1; +const OUT_699: usize = 1; +fn aiur_fn_699( + inp: [G; IN_699], record: &mut QueryRecord, io_buffer: &mut IOBuffer, unconstrained: bool, -) -> Result<[G; OUT_703], ExecError> { +) -> Result<[G; OUT_699], ExecError> { stacker::maybe_grow(64 * 1024, 4 * 1024 * 1024, || { let __v_0: G = inp[0]; let __loaded: [G; 47] = { let __mq = record.memory_queries.get_mut(&47).ok_or(ExecError::InvalidMemorySize(47))?; let __ptr_u64 = __v_0.as_canonical_u64(); let __ptr_usize = usize::try_from(__ptr_u64).ok().ok_or(ExecError::PointerTooLarge(__ptr_u64))?; let (__args, __mult) = __mq.get_index_mut(__ptr_usize).ok_or(ExecError::UnboundPointer { ptr: __ptr_u64, size: 47 })?; if !unconstrained { *__mult += G::ONE; } let __arr: [G; 47] = __args[..47].try_into().unwrap(); __arr }; @@ -59062,8 +58790,8 @@ fn aiur_fn_703( let __v_48: G = G::from_u64(1); let __v_49: G = G::from_u64(1); let __v_50: G = { let __values: [G; 3] = [__v_48, __v_49, __v_49]; let __mq = record.memory_queries.get_mut(&3).ok_or(ExecError::InvalidMemorySize(3))?; if let Some(result) = __mq.get_mut(&__values[..]) { if !unconstrained { *result.multiplicity += G::ONE; } result.output[0] } else { let __ptr = G::from_usize(__mq.len()); __mq.insert(&__values[..], &[__ptr], G::from_bool(!unconstrained)); __ptr } }; - let __ret: [G; OUT_703] = [__v_50]; - if let Some(result) = record.function_queries[703].get_mut(&inp[..]) { debug_assert_eq!(result.output, &__ret[..]); if !unconstrained { *result.multiplicity += G::ONE; } } else { record.function_queries[703].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained)); }; + let __ret: [G; OUT_699] = [__v_50]; + if let Some(result) = record.function_queries[699].get_mut(&inp[..]) { debug_assert_eq!(result.output, &__ret[..]); if !unconstrained { *result.multiplicity += G::ONE; } } else { record.function_queries[699].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained)); }; return Ok(__ret); }, 0u64 => { @@ -59071,18 +58799,18 @@ fn aiur_fn_703( 0u64 => { match __v_3.as_canonical_u64() { _ => { - let __r_arr: [G; OUT_699] = { let __args: [G; IN_699] = [__v_13]; let __cu = unconstrained; if let Some(result) = record.function_queries[699].get_mut(&__args[..]) { if !__cu && *result.multiplicity == G::ZERO { aiur_fn_699(__args, record, io_buffer, false)? } else { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_699] = unsafe { *(result.output.as_ptr() as *const [G; OUT_699]) }; __ret } } else { aiur_fn_699(__args, record, io_buffer, __cu)? } }; + let __r_arr: [G; OUT_695] = { let __args: [G; IN_695] = [__v_13]; let __cu = unconstrained; if let Some(result) = record.function_queries[695].get_mut(&__args[..]) { if !__cu && *result.multiplicity == G::ZERO { aiur_fn_695(__args, record, io_buffer, false)? } else { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_695] = unsafe { *(result.output.as_ptr() as *const [G; OUT_695]) }; __ret } } else { aiur_fn_695(__args, record, io_buffer, __cu)? } }; let __v_48: G = __r_arr[0]; - let __r_arr: [G; OUT_699] = { let __args: [G; IN_699] = [__v_14]; let __cu = unconstrained; if let Some(result) = record.function_queries[699].get_mut(&__args[..]) { if !__cu && *result.multiplicity == G::ZERO { aiur_fn_699(__args, record, io_buffer, false)? } else { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_699] = unsafe { *(result.output.as_ptr() as *const [G; OUT_699]) }; __ret } } else { aiur_fn_699(__args, record, io_buffer, __cu)? } }; + let __r_arr: [G; OUT_695] = { let __args: [G; IN_695] = [__v_14]; let __cu = unconstrained; if let Some(result) = record.function_queries[695].get_mut(&__args[..]) { if !__cu && *result.multiplicity == G::ZERO { aiur_fn_695(__args, record, io_buffer, false)? } else { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_695] = unsafe { *(result.output.as_ptr() as *const [G; OUT_695]) }; __ret } } else { aiur_fn_695(__args, record, io_buffer, __cu)? } }; let __v_49: G = __r_arr[0]; - let __r_arr: [G; OUT_763] = { let __args: [G; IN_763] = [__v_48, __v_49]; let __cu = unconstrained; if let Some(result) = record.function_queries[763].get_mut(&__args[..]) { if !__cu && *result.multiplicity == G::ZERO { aiur_fn_763(__args, record, io_buffer, false)? } else { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_763] = unsafe { *(result.output.as_ptr() as *const [G; OUT_763]) }; __ret } } else { aiur_fn_763(__args, record, io_buffer, __cu)? } }; + let __r_arr: [G; OUT_759] = { let __args: [G; IN_759] = [__v_48, __v_49]; let __cu = unconstrained; if let Some(result) = record.function_queries[759].get_mut(&__args[..]) { if !__cu && *result.multiplicity == G::ZERO { aiur_fn_759(__args, record, io_buffer, false)? } else { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_759] = unsafe { *(result.output.as_ptr() as *const [G; OUT_759]) }; __ret } } else { aiur_fn_759(__args, record, io_buffer, __cu)? } }; let __v_50: G = __r_arr[0]; - let __r_arr: [G; OUT_703] = { let __args: [G; IN_703] = [__v_47]; let __cu = unconstrained; if let Some(result) = record.function_queries[703].get_mut(&__args[..]) { if !__cu && *result.multiplicity == G::ZERO { aiur_fn_703(__args, record, io_buffer, false)? } else { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_703] = unsafe { *(result.output.as_ptr() as *const [G; OUT_703]) }; __ret } } else { aiur_fn_703(__args, record, io_buffer, __cu)? } }; + let __r_arr: [G; OUT_699] = { let __args: [G; IN_699] = [__v_47]; let __cu = unconstrained; if let Some(result) = record.function_queries[699].get_mut(&__args[..]) { if !__cu && *result.multiplicity == G::ZERO { aiur_fn_699(__args, record, io_buffer, false)? } else { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_699] = unsafe { *(result.output.as_ptr() as *const [G; OUT_699]) }; __ret } } else { aiur_fn_699(__args, record, io_buffer, __cu)? } }; let __v_51: G = __r_arr[0]; - let __r_arr: [G; OUT_763] = { let __args: [G; IN_763] = [__v_50, __v_51]; let __cu = unconstrained; if let Some(result) = record.function_queries[763].get_mut(&__args[..]) { if !__cu && *result.multiplicity == G::ZERO { aiur_fn_763(__args, record, io_buffer, false)? } else { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_763] = unsafe { *(result.output.as_ptr() as *const [G; OUT_763]) }; __ret } } else { aiur_fn_763(__args, record, io_buffer, __cu)? } }; + let __r_arr: [G; OUT_759] = { let __args: [G; IN_759] = [__v_50, __v_51]; let __cu = unconstrained; if let Some(result) = record.function_queries[759].get_mut(&__args[..]) { if !__cu && *result.multiplicity == G::ZERO { aiur_fn_759(__args, record, io_buffer, false)? } else { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_759] = unsafe { *(result.output.as_ptr() as *const [G; OUT_759]) }; __ret } } else { aiur_fn_759(__args, record, io_buffer, __cu)? } }; let __v_52: G = __r_arr[0]; - let __ret: [G; OUT_703] = [__v_52]; - if let Some(result) = record.function_queries[703].get_mut(&inp[..]) { debug_assert_eq!(result.output, &__ret[..]); if !unconstrained { *result.multiplicity += G::ONE; } } else { record.function_queries[703].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained)); }; + let __ret: [G; OUT_699] = [__v_52]; + if let Some(result) = record.function_queries[699].get_mut(&inp[..]) { debug_assert_eq!(result.output, &__ret[..]); if !unconstrained { *result.multiplicity += G::ONE; } } else { record.function_queries[699].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained)); }; return Ok(__ret); }, } @@ -59090,18 +58818,18 @@ fn aiur_fn_703( 1u64 => { match __v_3.as_canonical_u64() { _ => { - let __r_arr: [G; OUT_699] = { let __args: [G; IN_699] = [__v_28]; let __cu = unconstrained; if let Some(result) = record.function_queries[699].get_mut(&__args[..]) { if !__cu && *result.multiplicity == G::ZERO { aiur_fn_699(__args, record, io_buffer, false)? } else { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_699] = unsafe { *(result.output.as_ptr() as *const [G; OUT_699]) }; __ret } } else { aiur_fn_699(__args, record, io_buffer, __cu)? } }; + let __r_arr: [G; OUT_695] = { let __args: [G; IN_695] = [__v_28]; let __cu = unconstrained; if let Some(result) = record.function_queries[695].get_mut(&__args[..]) { if !__cu && *result.multiplicity == G::ZERO { aiur_fn_695(__args, record, io_buffer, false)? } else { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_695] = unsafe { *(result.output.as_ptr() as *const [G; OUT_695]) }; __ret } } else { aiur_fn_695(__args, record, io_buffer, __cu)? } }; let __v_48: G = __r_arr[0]; - let __r_arr: [G; OUT_702] = { let __args: [G; IN_702] = [__v_29]; let __cu = unconstrained; if let Some(result) = record.function_queries[702].get_mut(&__args[..]) { if !__cu && *result.multiplicity == G::ZERO { aiur_fn_702(__args, record, io_buffer, false)? } else { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_702] = unsafe { *(result.output.as_ptr() as *const [G; OUT_702]) }; __ret } } else { aiur_fn_702(__args, record, io_buffer, __cu)? } }; + let __r_arr: [G; OUT_698] = { let __args: [G; IN_698] = [__v_29]; let __cu = unconstrained; if let Some(result) = record.function_queries[698].get_mut(&__args[..]) { if !__cu && *result.multiplicity == G::ZERO { aiur_fn_698(__args, record, io_buffer, false)? } else { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_698] = unsafe { *(result.output.as_ptr() as *const [G; OUT_698]) }; __ret } } else { aiur_fn_698(__args, record, io_buffer, __cu)? } }; let __v_49: G = __r_arr[0]; - let __r_arr: [G; OUT_763] = { let __args: [G; IN_763] = [__v_48, __v_49]; let __cu = unconstrained; if let Some(result) = record.function_queries[763].get_mut(&__args[..]) { if !__cu && *result.multiplicity == G::ZERO { aiur_fn_763(__args, record, io_buffer, false)? } else { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_763] = unsafe { *(result.output.as_ptr() as *const [G; OUT_763]) }; __ret } } else { aiur_fn_763(__args, record, io_buffer, __cu)? } }; + let __r_arr: [G; OUT_759] = { let __args: [G; IN_759] = [__v_48, __v_49]; let __cu = unconstrained; if let Some(result) = record.function_queries[759].get_mut(&__args[..]) { if !__cu && *result.multiplicity == G::ZERO { aiur_fn_759(__args, record, io_buffer, false)? } else { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_759] = unsafe { *(result.output.as_ptr() as *const [G; OUT_759]) }; __ret } } else { aiur_fn_759(__args, record, io_buffer, __cu)? } }; let __v_50: G = __r_arr[0]; - let __r_arr: [G; OUT_703] = { let __args: [G; IN_703] = [__v_47]; let __cu = unconstrained; if let Some(result) = record.function_queries[703].get_mut(&__args[..]) { if !__cu && *result.multiplicity == G::ZERO { aiur_fn_703(__args, record, io_buffer, false)? } else { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_703] = unsafe { *(result.output.as_ptr() as *const [G; OUT_703]) }; __ret } } else { aiur_fn_703(__args, record, io_buffer, __cu)? } }; + let __r_arr: [G; OUT_699] = { let __args: [G; IN_699] = [__v_47]; let __cu = unconstrained; if let Some(result) = record.function_queries[699].get_mut(&__args[..]) { if !__cu && *result.multiplicity == G::ZERO { aiur_fn_699(__args, record, io_buffer, false)? } else { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_699] = unsafe { *(result.output.as_ptr() as *const [G; OUT_699]) }; __ret } } else { aiur_fn_699(__args, record, io_buffer, __cu)? } }; let __v_51: G = __r_arr[0]; - let __r_arr: [G; OUT_763] = { let __args: [G; IN_763] = [__v_50, __v_51]; let __cu = unconstrained; if let Some(result) = record.function_queries[763].get_mut(&__args[..]) { if !__cu && *result.multiplicity == G::ZERO { aiur_fn_763(__args, record, io_buffer, false)? } else { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_763] = unsafe { *(result.output.as_ptr() as *const [G; OUT_763]) }; __ret } } else { aiur_fn_763(__args, record, io_buffer, __cu)? } }; + let __r_arr: [G; OUT_759] = { let __args: [G; IN_759] = [__v_50, __v_51]; let __cu = unconstrained; if let Some(result) = record.function_queries[759].get_mut(&__args[..]) { if !__cu && *result.multiplicity == G::ZERO { aiur_fn_759(__args, record, io_buffer, false)? } else { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_759] = unsafe { *(result.output.as_ptr() as *const [G; OUT_759]) }; __ret } } else { aiur_fn_759(__args, record, io_buffer, __cu)? } }; let __v_52: G = __r_arr[0]; - let __ret: [G; OUT_703] = [__v_52]; - if let Some(result) = record.function_queries[703].get_mut(&inp[..]) { debug_assert_eq!(result.output, &__ret[..]); if !unconstrained { *result.multiplicity += G::ONE; } } else { record.function_queries[703].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained)); }; + let __ret: [G; OUT_699] = [__v_52]; + if let Some(result) = record.function_queries[699].get_mut(&inp[..]) { debug_assert_eq!(result.output, &__ret[..]); if !unconstrained { *result.multiplicity += G::ONE; } } else { record.function_queries[699].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained)); }; return Ok(__ret); }, } @@ -59109,18 +58837,18 @@ fn aiur_fn_703( 2u64 => { match __v_3.as_canonical_u64() { _ => { - let __r_arr: [G; OUT_699] = { let __args: [G; IN_699] = [__v_45]; let __cu = unconstrained; if let Some(result) = record.function_queries[699].get_mut(&__args[..]) { if !__cu && *result.multiplicity == G::ZERO { aiur_fn_699(__args, record, io_buffer, false)? } else { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_699] = unsafe { *(result.output.as_ptr() as *const [G; OUT_699]) }; __ret } } else { aiur_fn_699(__args, record, io_buffer, __cu)? } }; + let __r_arr: [G; OUT_695] = { let __args: [G; IN_695] = [__v_45]; let __cu = unconstrained; if let Some(result) = record.function_queries[695].get_mut(&__args[..]) { if !__cu && *result.multiplicity == G::ZERO { aiur_fn_695(__args, record, io_buffer, false)? } else { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_695] = unsafe { *(result.output.as_ptr() as *const [G; OUT_695]) }; __ret } } else { aiur_fn_695(__args, record, io_buffer, __cu)? } }; let __v_48: G = __r_arr[0]; - let __r_arr: [G; OUT_701] = { let __args: [G; IN_701] = [__v_46]; let __cu = unconstrained; if let Some(result) = record.function_queries[701].get_mut(&__args[..]) { if !__cu && *result.multiplicity == G::ZERO { aiur_fn_701(__args, record, io_buffer, false)? } else { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_701] = unsafe { *(result.output.as_ptr() as *const [G; OUT_701]) }; __ret } } else { aiur_fn_701(__args, record, io_buffer, __cu)? } }; + let __r_arr: [G; OUT_697] = { let __args: [G; IN_697] = [__v_46]; let __cu = unconstrained; if let Some(result) = record.function_queries[697].get_mut(&__args[..]) { if !__cu && *result.multiplicity == G::ZERO { aiur_fn_697(__args, record, io_buffer, false)? } else { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_697] = unsafe { *(result.output.as_ptr() as *const [G; OUT_697]) }; __ret } } else { aiur_fn_697(__args, record, io_buffer, __cu)? } }; let __v_49: G = __r_arr[0]; - let __r_arr: [G; OUT_763] = { let __args: [G; IN_763] = [__v_48, __v_49]; let __cu = unconstrained; if let Some(result) = record.function_queries[763].get_mut(&__args[..]) { if !__cu && *result.multiplicity == G::ZERO { aiur_fn_763(__args, record, io_buffer, false)? } else { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_763] = unsafe { *(result.output.as_ptr() as *const [G; OUT_763]) }; __ret } } else { aiur_fn_763(__args, record, io_buffer, __cu)? } }; + let __r_arr: [G; OUT_759] = { let __args: [G; IN_759] = [__v_48, __v_49]; let __cu = unconstrained; if let Some(result) = record.function_queries[759].get_mut(&__args[..]) { if !__cu && *result.multiplicity == G::ZERO { aiur_fn_759(__args, record, io_buffer, false)? } else { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_759] = unsafe { *(result.output.as_ptr() as *const [G; OUT_759]) }; __ret } } else { aiur_fn_759(__args, record, io_buffer, __cu)? } }; let __v_50: G = __r_arr[0]; - let __r_arr: [G; OUT_703] = { let __args: [G; IN_703] = [__v_47]; let __cu = unconstrained; if let Some(result) = record.function_queries[703].get_mut(&__args[..]) { if !__cu && *result.multiplicity == G::ZERO { aiur_fn_703(__args, record, io_buffer, false)? } else { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_703] = unsafe { *(result.output.as_ptr() as *const [G; OUT_703]) }; __ret } } else { aiur_fn_703(__args, record, io_buffer, __cu)? } }; + let __r_arr: [G; OUT_699] = { let __args: [G; IN_699] = [__v_47]; let __cu = unconstrained; if let Some(result) = record.function_queries[699].get_mut(&__args[..]) { if !__cu && *result.multiplicity == G::ZERO { aiur_fn_699(__args, record, io_buffer, false)? } else { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_699] = unsafe { *(result.output.as_ptr() as *const [G; OUT_699]) }; __ret } } else { aiur_fn_699(__args, record, io_buffer, __cu)? } }; let __v_51: G = __r_arr[0]; - let __r_arr: [G; OUT_763] = { let __args: [G; IN_763] = [__v_50, __v_51]; let __cu = unconstrained; if let Some(result) = record.function_queries[763].get_mut(&__args[..]) { if !__cu && *result.multiplicity == G::ZERO { aiur_fn_763(__args, record, io_buffer, false)? } else { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_763] = unsafe { *(result.output.as_ptr() as *const [G; OUT_763]) }; __ret } } else { aiur_fn_763(__args, record, io_buffer, __cu)? } }; + let __r_arr: [G; OUT_759] = { let __args: [G; IN_759] = [__v_50, __v_51]; let __cu = unconstrained; if let Some(result) = record.function_queries[759].get_mut(&__args[..]) { if !__cu && *result.multiplicity == G::ZERO { aiur_fn_759(__args, record, io_buffer, false)? } else { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_759] = unsafe { *(result.output.as_ptr() as *const [G; OUT_759]) }; __ret } } else { aiur_fn_759(__args, record, io_buffer, __cu)? } }; let __v_52: G = __r_arr[0]; - let __ret: [G; OUT_703] = [__v_52]; - if let Some(result) = record.function_queries[703].get_mut(&inp[..]) { debug_assert_eq!(result.output, &__ret[..]); if !unconstrained { *result.multiplicity += G::ONE; } } else { record.function_queries[703].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained)); }; + let __ret: [G; OUT_699] = [__v_52]; + if let Some(result) = record.function_queries[699].get_mut(&inp[..]) { debug_assert_eq!(result.output, &__ret[..]); if !unconstrained { *result.multiplicity += G::ONE; } } else { record.function_queries[699].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained)); }; return Ok(__ret); }, } @@ -59137,15 +58865,15 @@ fn aiur_fn_703( }) } -const INPUT_SIZE_704: usize = 48; -const IN_704: usize = 48; -const OUT_704: usize = 1; -fn aiur_fn_704( - inp: [G; IN_704], +const INPUT_SIZE_700: usize = 48; +const IN_700: usize = 48; +const OUT_700: usize = 1; +fn aiur_fn_700( + inp: [G; IN_700], record: &mut QueryRecord, io_buffer: &mut IOBuffer, unconstrained: bool, -) -> Result<[G; OUT_704], ExecError> { +) -> Result<[G; OUT_700], ExecError> { stacker::maybe_grow(64 * 1024, 4 * 1024 * 1024, || { let __v_0: G = inp[0]; let __v_1: G = inp[1]; @@ -59197,22 +58925,22 @@ fn aiur_fn_704( let __v_47: G = inp[47]; match __v_0.as_canonical_u64() { _ => { - let __r_arr: [G; OUT_700] = { let __args: [G; IN_700] = [__v_45]; let __cu = unconstrained; if let Some(result) = record.function_queries[700].get_mut(&__args[..]) { if !__cu && *result.multiplicity == G::ZERO { aiur_fn_700(__args, record, io_buffer, false)? } else { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_700] = unsafe { *(result.output.as_ptr() as *const [G; OUT_700]) }; __ret } } else { aiur_fn_700(__args, record, io_buffer, __cu)? } }; + let __r_arr: [G; OUT_696] = { let __args: [G; IN_696] = [__v_45]; let __cu = unconstrained; if let Some(result) = record.function_queries[696].get_mut(&__args[..]) { if !__cu && *result.multiplicity == G::ZERO { aiur_fn_696(__args, record, io_buffer, false)? } else { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_696] = unsafe { *(result.output.as_ptr() as *const [G; OUT_696]) }; __ret } } else { aiur_fn_696(__args, record, io_buffer, __cu)? } }; let __v_48: G = __r_arr[0]; match __v_0.as_canonical_u64() { 0u64 => { match __v_1.as_canonical_u64() { _ => { - let __r_arr: [G; OUT_699] = { let __args: [G; IN_699] = [__v_11]; let __cu = unconstrained; if let Some(result) = record.function_queries[699].get_mut(&__args[..]) { if !__cu && *result.multiplicity == G::ZERO { aiur_fn_699(__args, record, io_buffer, false)? } else { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_699] = unsafe { *(result.output.as_ptr() as *const [G; OUT_699]) }; __ret } } else { aiur_fn_699(__args, record, io_buffer, __cu)? } }; + let __r_arr: [G; OUT_695] = { let __args: [G; IN_695] = [__v_11]; let __cu = unconstrained; if let Some(result) = record.function_queries[695].get_mut(&__args[..]) { if !__cu && *result.multiplicity == G::ZERO { aiur_fn_695(__args, record, io_buffer, false)? } else { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_695] = unsafe { *(result.output.as_ptr() as *const [G; OUT_695]) }; __ret } } else { aiur_fn_695(__args, record, io_buffer, __cu)? } }; let __v_49: G = __r_arr[0]; - let __r_arr: [G; OUT_699] = { let __args: [G; IN_699] = [__v_12]; let __cu = unconstrained; if let Some(result) = record.function_queries[699].get_mut(&__args[..]) { if !__cu && *result.multiplicity == G::ZERO { aiur_fn_699(__args, record, io_buffer, false)? } else { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_699] = unsafe { *(result.output.as_ptr() as *const [G; OUT_699]) }; __ret } } else { aiur_fn_699(__args, record, io_buffer, __cu)? } }; + let __r_arr: [G; OUT_695] = { let __args: [G; IN_695] = [__v_12]; let __cu = unconstrained; if let Some(result) = record.function_queries[695].get_mut(&__args[..]) { if !__cu && *result.multiplicity == G::ZERO { aiur_fn_695(__args, record, io_buffer, false)? } else { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_695] = unsafe { *(result.output.as_ptr() as *const [G; OUT_695]) }; __ret } } else { aiur_fn_695(__args, record, io_buffer, __cu)? } }; let __v_50: G = __r_arr[0]; - let __r_arr: [G; OUT_763] = { let __args: [G; IN_763] = [__v_49, __v_50]; let __cu = unconstrained; if let Some(result) = record.function_queries[763].get_mut(&__args[..]) { if !__cu && *result.multiplicity == G::ZERO { aiur_fn_763(__args, record, io_buffer, false)? } else { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_763] = unsafe { *(result.output.as_ptr() as *const [G; OUT_763]) }; __ret } } else { aiur_fn_763(__args, record, io_buffer, __cu)? } }; + let __r_arr: [G; OUT_759] = { let __args: [G; IN_759] = [__v_49, __v_50]; let __cu = unconstrained; if let Some(result) = record.function_queries[759].get_mut(&__args[..]) { if !__cu && *result.multiplicity == G::ZERO { aiur_fn_759(__args, record, io_buffer, false)? } else { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_759] = unsafe { *(result.output.as_ptr() as *const [G; OUT_759]) }; __ret } } else { aiur_fn_759(__args, record, io_buffer, __cu)? } }; let __v_51: G = __r_arr[0]; - let __r_arr: [G; OUT_763] = { let __args: [G; IN_763] = [__v_48, __v_51]; let __cu = unconstrained; if let Some(result) = record.function_queries[763].get_mut(&__args[..]) { if !__cu && *result.multiplicity == G::ZERO { aiur_fn_763(__args, record, io_buffer, false)? } else { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_763] = unsafe { *(result.output.as_ptr() as *const [G; OUT_763]) }; __ret } } else { aiur_fn_763(__args, record, io_buffer, __cu)? } }; + let __r_arr: [G; OUT_759] = { let __args: [G; IN_759] = [__v_48, __v_51]; let __cu = unconstrained; if let Some(result) = record.function_queries[759].get_mut(&__args[..]) { if !__cu && *result.multiplicity == G::ZERO { aiur_fn_759(__args, record, io_buffer, false)? } else { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_759] = unsafe { *(result.output.as_ptr() as *const [G; OUT_759]) }; __ret } } else { aiur_fn_759(__args, record, io_buffer, __cu)? } }; let __v_52: G = __r_arr[0]; - let __ret: [G; OUT_704] = [__v_52]; - if let Some(result) = record.function_queries[704].get_mut(&inp[..]) { debug_assert_eq!(result.output, &__ret[..]); if !unconstrained { *result.multiplicity += G::ONE; } } else { record.function_queries[704].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained)); }; + let __ret: [G; OUT_700] = [__v_52]; + if let Some(result) = record.function_queries[700].get_mut(&inp[..]) { debug_assert_eq!(result.output, &__ret[..]); if !unconstrained { *result.multiplicity += G::ONE; } } else { record.function_queries[700].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained)); }; return Ok(__ret); }, } @@ -59220,16 +58948,16 @@ fn aiur_fn_704( 1u64 => { match __v_1.as_canonical_u64() { _ => { - let __r_arr: [G; OUT_699] = { let __args: [G; IN_699] = [__v_43]; let __cu = unconstrained; if let Some(result) = record.function_queries[699].get_mut(&__args[..]) { if !__cu && *result.multiplicity == G::ZERO { aiur_fn_699(__args, record, io_buffer, false)? } else { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_699] = unsafe { *(result.output.as_ptr() as *const [G; OUT_699]) }; __ret } } else { aiur_fn_699(__args, record, io_buffer, __cu)? } }; + let __r_arr: [G; OUT_695] = { let __args: [G; IN_695] = [__v_43]; let __cu = unconstrained; if let Some(result) = record.function_queries[695].get_mut(&__args[..]) { if !__cu && *result.multiplicity == G::ZERO { aiur_fn_695(__args, record, io_buffer, false)? } else { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_695] = unsafe { *(result.output.as_ptr() as *const [G; OUT_695]) }; __ret } } else { aiur_fn_695(__args, record, io_buffer, __cu)? } }; let __v_49: G = __r_arr[0]; - let __r_arr: [G; OUT_701] = { let __args: [G; IN_701] = [__v_44]; let __cu = unconstrained; if let Some(result) = record.function_queries[701].get_mut(&__args[..]) { if !__cu && *result.multiplicity == G::ZERO { aiur_fn_701(__args, record, io_buffer, false)? } else { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_701] = unsafe { *(result.output.as_ptr() as *const [G; OUT_701]) }; __ret } } else { aiur_fn_701(__args, record, io_buffer, __cu)? } }; + let __r_arr: [G; OUT_697] = { let __args: [G; IN_697] = [__v_44]; let __cu = unconstrained; if let Some(result) = record.function_queries[697].get_mut(&__args[..]) { if !__cu && *result.multiplicity == G::ZERO { aiur_fn_697(__args, record, io_buffer, false)? } else { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_697] = unsafe { *(result.output.as_ptr() as *const [G; OUT_697]) }; __ret } } else { aiur_fn_697(__args, record, io_buffer, __cu)? } }; let __v_50: G = __r_arr[0]; - let __r_arr: [G; OUT_763] = { let __args: [G; IN_763] = [__v_49, __v_50]; let __cu = unconstrained; if let Some(result) = record.function_queries[763].get_mut(&__args[..]) { if !__cu && *result.multiplicity == G::ZERO { aiur_fn_763(__args, record, io_buffer, false)? } else { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_763] = unsafe { *(result.output.as_ptr() as *const [G; OUT_763]) }; __ret } } else { aiur_fn_763(__args, record, io_buffer, __cu)? } }; + let __r_arr: [G; OUT_759] = { let __args: [G; IN_759] = [__v_49, __v_50]; let __cu = unconstrained; if let Some(result) = record.function_queries[759].get_mut(&__args[..]) { if !__cu && *result.multiplicity == G::ZERO { aiur_fn_759(__args, record, io_buffer, false)? } else { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_759] = unsafe { *(result.output.as_ptr() as *const [G; OUT_759]) }; __ret } } else { aiur_fn_759(__args, record, io_buffer, __cu)? } }; let __v_51: G = __r_arr[0]; - let __r_arr: [G; OUT_763] = { let __args: [G; IN_763] = [__v_48, __v_51]; let __cu = unconstrained; if let Some(result) = record.function_queries[763].get_mut(&__args[..]) { if !__cu && *result.multiplicity == G::ZERO { aiur_fn_763(__args, record, io_buffer, false)? } else { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_763] = unsafe { *(result.output.as_ptr() as *const [G; OUT_763]) }; __ret } } else { aiur_fn_763(__args, record, io_buffer, __cu)? } }; + let __r_arr: [G; OUT_759] = { let __args: [G; IN_759] = [__v_48, __v_51]; let __cu = unconstrained; if let Some(result) = record.function_queries[759].get_mut(&__args[..]) { if !__cu && *result.multiplicity == G::ZERO { aiur_fn_759(__args, record, io_buffer, false)? } else { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_759] = unsafe { *(result.output.as_ptr() as *const [G; OUT_759]) }; __ret } } else { aiur_fn_759(__args, record, io_buffer, __cu)? } }; let __v_52: G = __r_arr[0]; - let __ret: [G; OUT_704] = [__v_52]; - if let Some(result) = record.function_queries[704].get_mut(&inp[..]) { debug_assert_eq!(result.output, &__ret[..]); if !unconstrained { *result.multiplicity += G::ONE; } } else { record.function_queries[704].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained)); }; + let __ret: [G; OUT_700] = [__v_52]; + if let Some(result) = record.function_queries[700].get_mut(&inp[..]) { debug_assert_eq!(result.output, &__ret[..]); if !unconstrained { *result.multiplicity += G::ONE; } } else { record.function_queries[700].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained)); }; return Ok(__ret); }, } @@ -59237,12 +58965,12 @@ fn aiur_fn_704( 2u64 => { match __v_1.as_canonical_u64() { _ => { - let __r_arr: [G; OUT_699] = { let __args: [G; IN_699] = [__v_10]; let __cu = unconstrained; if let Some(result) = record.function_queries[699].get_mut(&__args[..]) { if !__cu && *result.multiplicity == G::ZERO { aiur_fn_699(__args, record, io_buffer, false)? } else { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_699] = unsafe { *(result.output.as_ptr() as *const [G; OUT_699]) }; __ret } } else { aiur_fn_699(__args, record, io_buffer, __cu)? } }; + let __r_arr: [G; OUT_695] = { let __args: [G; IN_695] = [__v_10]; let __cu = unconstrained; if let Some(result) = record.function_queries[695].get_mut(&__args[..]) { if !__cu && *result.multiplicity == G::ZERO { aiur_fn_695(__args, record, io_buffer, false)? } else { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_695] = unsafe { *(result.output.as_ptr() as *const [G; OUT_695]) }; __ret } } else { aiur_fn_695(__args, record, io_buffer, __cu)? } }; let __v_49: G = __r_arr[0]; - let __r_arr: [G; OUT_763] = { let __args: [G; IN_763] = [__v_48, __v_49]; let __cu = unconstrained; if let Some(result) = record.function_queries[763].get_mut(&__args[..]) { if !__cu && *result.multiplicity == G::ZERO { aiur_fn_763(__args, record, io_buffer, false)? } else { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_763] = unsafe { *(result.output.as_ptr() as *const [G; OUT_763]) }; __ret } } else { aiur_fn_763(__args, record, io_buffer, __cu)? } }; + let __r_arr: [G; OUT_759] = { let __args: [G; IN_759] = [__v_48, __v_49]; let __cu = unconstrained; if let Some(result) = record.function_queries[759].get_mut(&__args[..]) { if !__cu && *result.multiplicity == G::ZERO { aiur_fn_759(__args, record, io_buffer, false)? } else { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_759] = unsafe { *(result.output.as_ptr() as *const [G; OUT_759]) }; __ret } } else { aiur_fn_759(__args, record, io_buffer, __cu)? } }; let __v_50: G = __r_arr[0]; - let __ret: [G; OUT_704] = [__v_50]; - if let Some(result) = record.function_queries[704].get_mut(&inp[..]) { debug_assert_eq!(result.output, &__ret[..]); if !unconstrained { *result.multiplicity += G::ONE; } } else { record.function_queries[704].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained)); }; + let __ret: [G; OUT_700] = [__v_50]; + if let Some(result) = record.function_queries[700].get_mut(&inp[..]) { debug_assert_eq!(result.output, &__ret[..]); if !unconstrained { *result.multiplicity += G::ONE; } } else { record.function_queries[700].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained)); }; return Ok(__ret); }, } @@ -59250,28 +58978,28 @@ fn aiur_fn_704( 3u64 => { match __v_1.as_canonical_u64() { _ => { - let __r_arr: [G; OUT_699] = { let __args: [G; IN_699] = [__v_10]; let __cu = unconstrained; if let Some(result) = record.function_queries[699].get_mut(&__args[..]) { if !__cu && *result.multiplicity == G::ZERO { aiur_fn_699(__args, record, io_buffer, false)? } else { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_699] = unsafe { *(result.output.as_ptr() as *const [G; OUT_699]) }; __ret } } else { aiur_fn_699(__args, record, io_buffer, __cu)? } }; + let __r_arr: [G; OUT_695] = { let __args: [G; IN_695] = [__v_10]; let __cu = unconstrained; if let Some(result) = record.function_queries[695].get_mut(&__args[..]) { if !__cu && *result.multiplicity == G::ZERO { aiur_fn_695(__args, record, io_buffer, false)? } else { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_695] = unsafe { *(result.output.as_ptr() as *const [G; OUT_695]) }; __ret } } else { aiur_fn_695(__args, record, io_buffer, __cu)? } }; let __v_49: G = __r_arr[0]; - let __r_arr: [G; OUT_763] = { let __args: [G; IN_763] = [__v_48, __v_49]; let __cu = unconstrained; if let Some(result) = record.function_queries[763].get_mut(&__args[..]) { if !__cu && *result.multiplicity == G::ZERO { aiur_fn_763(__args, record, io_buffer, false)? } else { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_763] = unsafe { *(result.output.as_ptr() as *const [G; OUT_763]) }; __ret } } else { aiur_fn_763(__args, record, io_buffer, __cu)? } }; + let __r_arr: [G; OUT_759] = { let __args: [G; IN_759] = [__v_48, __v_49]; let __cu = unconstrained; if let Some(result) = record.function_queries[759].get_mut(&__args[..]) { if !__cu && *result.multiplicity == G::ZERO { aiur_fn_759(__args, record, io_buffer, false)? } else { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_759] = unsafe { *(result.output.as_ptr() as *const [G; OUT_759]) }; __ret } } else { aiur_fn_759(__args, record, io_buffer, __cu)? } }; let __v_50: G = __r_arr[0]; - let __ret: [G; OUT_704] = [__v_50]; - if let Some(result) = record.function_queries[704].get_mut(&inp[..]) { debug_assert_eq!(result.output, &__ret[..]); if !unconstrained { *result.multiplicity += G::ONE; } } else { record.function_queries[704].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained)); }; + let __ret: [G; OUT_700] = [__v_50]; + if let Some(result) = record.function_queries[700].get_mut(&inp[..]) { debug_assert_eq!(result.output, &__ret[..]); if !unconstrained { *result.multiplicity += G::ONE; } } else { record.function_queries[700].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained)); }; return Ok(__ret); }, } }, 8u64 => { - let __r_arr: [G; OUT_703] = { let __args: [G; IN_703] = [__v_1]; let __cu = unconstrained; if let Some(result) = record.function_queries[703].get_mut(&__args[..]) { if !__cu && *result.multiplicity == G::ZERO { aiur_fn_703(__args, record, io_buffer, false)? } else { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_703] = unsafe { *(result.output.as_ptr() as *const [G; OUT_703]) }; __ret } } else { aiur_fn_703(__args, record, io_buffer, __cu)? } }; + let __r_arr: [G; OUT_699] = { let __args: [G; IN_699] = [__v_1]; let __cu = unconstrained; if let Some(result) = record.function_queries[699].get_mut(&__args[..]) { if !__cu && *result.multiplicity == G::ZERO { aiur_fn_699(__args, record, io_buffer, false)? } else { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_699] = unsafe { *(result.output.as_ptr() as *const [G; OUT_699]) }; __ret } } else { aiur_fn_699(__args, record, io_buffer, __cu)? } }; let __v_49: G = __r_arr[0]; - let __r_arr: [G; OUT_763] = { let __args: [G; IN_763] = [__v_48, __v_49]; let __cu = unconstrained; if let Some(result) = record.function_queries[763].get_mut(&__args[..]) { if !__cu && *result.multiplicity == G::ZERO { aiur_fn_763(__args, record, io_buffer, false)? } else { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_763] = unsafe { *(result.output.as_ptr() as *const [G; OUT_763]) }; __ret } } else { aiur_fn_763(__args, record, io_buffer, __cu)? } }; + let __r_arr: [G; OUT_759] = { let __args: [G; IN_759] = [__v_48, __v_49]; let __cu = unconstrained; if let Some(result) = record.function_queries[759].get_mut(&__args[..]) { if !__cu && *result.multiplicity == G::ZERO { aiur_fn_759(__args, record, io_buffer, false)? } else { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_759] = unsafe { *(result.output.as_ptr() as *const [G; OUT_759]) }; __ret } } else { aiur_fn_759(__args, record, io_buffer, __cu)? } }; let __v_50: G = __r_arr[0]; - let __ret: [G; OUT_704] = [__v_50]; - if let Some(result) = record.function_queries[704].get_mut(&inp[..]) { debug_assert_eq!(result.output, &__ret[..]); if !unconstrained { *result.multiplicity += G::ONE; } } else { record.function_queries[704].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained)); }; + let __ret: [G; OUT_700] = [__v_50]; + if let Some(result) = record.function_queries[700].get_mut(&inp[..]) { debug_assert_eq!(result.output, &__ret[..]); if !unconstrained { *result.multiplicity += G::ONE; } } else { record.function_queries[700].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained)); }; return Ok(__ret); }, _ => { - let __ret: [G; OUT_704] = [__v_48]; - if let Some(result) = record.function_queries[704].get_mut(&inp[..]) { debug_assert_eq!(result.output, &__ret[..]); if !unconstrained { *result.multiplicity += G::ONE; } } else { record.function_queries[704].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained)); }; + let __ret: [G; OUT_700] = [__v_48]; + if let Some(result) = record.function_queries[700].get_mut(&inp[..]) { debug_assert_eq!(result.output, &__ret[..]); if !unconstrained { *result.multiplicity += G::ONE; } } else { record.function_queries[700].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained)); }; return Ok(__ret); }, } @@ -59280,15 +59008,15 @@ fn aiur_fn_704( }) } -const INPUT_SIZE_705: usize = 2; -const IN_705: usize = 2; -const OUT_705: usize = 1; -fn aiur_fn_705( - inp: [G; IN_705], +const INPUT_SIZE_701: usize = 2; +const IN_701: usize = 2; +const OUT_701: usize = 1; +fn aiur_fn_701( + inp: [G; IN_701], record: &mut QueryRecord, io_buffer: &mut IOBuffer, unconstrained: bool, -) -> Result<[G; OUT_705], ExecError> { +) -> Result<[G; OUT_701], ExecError> { stacker::maybe_grow(64 * 1024, 4 * 1024 * 1024, || { let __v_0: G = inp[0]; let __v_1: G = inp[1]; @@ -59299,8 +59027,8 @@ fn aiur_fn_705( match __v_2.as_canonical_u64() { 1u64 => { let __v_5: G = G::from_u64(0); - let __ret: [G; OUT_705] = [__v_5]; - if let Some(result) = record.function_queries[705].get_mut(&inp[..]) { debug_assert_eq!(result.output, &__ret[..]); if !unconstrained { *result.multiplicity += G::ONE; } } else { record.function_queries[705].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained)); }; + let __ret: [G; OUT_701] = [__v_5]; + if let Some(result) = record.function_queries[701].get_mut(&inp[..]) { debug_assert_eq!(result.output, &__ret[..]); if !unconstrained { *result.multiplicity += G::ONE; } } else { record.function_queries[701].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained)); }; return Ok(__ret); }, 0u64 => { @@ -59308,15 +59036,15 @@ fn aiur_fn_705( match __v_5.as_canonical_u64() { 0u64 => { let __v_6: G = G::from_u64(1); - let __ret: [G; OUT_705] = [__v_6]; - if let Some(result) = record.function_queries[705].get_mut(&inp[..]) { debug_assert_eq!(result.output, &__ret[..]); if !unconstrained { *result.multiplicity += G::ONE; } } else { record.function_queries[705].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained)); }; + let __ret: [G; OUT_701] = [__v_6]; + if let Some(result) = record.function_queries[701].get_mut(&inp[..]) { debug_assert_eq!(result.output, &__ret[..]); if !unconstrained { *result.multiplicity += G::ONE; } } else { record.function_queries[701].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained)); }; return Ok(__ret); }, _ => { - let __r_arr: [G; OUT_705] = { let __args: [G; IN_705] = [__v_4, __v_1]; let __cu = unconstrained; if let Some(result) = record.function_queries[705].get_mut(&__args[..]) { if !__cu && *result.multiplicity == G::ZERO { aiur_fn_705(__args, record, io_buffer, false)? } else { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_705] = unsafe { *(result.output.as_ptr() as *const [G; OUT_705]) }; __ret } } else { aiur_fn_705(__args, record, io_buffer, __cu)? } }; + let __r_arr: [G; OUT_701] = { let __args: [G; IN_701] = [__v_4, __v_1]; let __cu = unconstrained; if let Some(result) = record.function_queries[701].get_mut(&__args[..]) { if !__cu && *result.multiplicity == G::ZERO { aiur_fn_701(__args, record, io_buffer, false)? } else { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_701] = unsafe { *(result.output.as_ptr() as *const [G; OUT_701]) }; __ret } } else { aiur_fn_701(__args, record, io_buffer, __cu)? } }; let __v_6: G = __r_arr[0]; - let __ret: [G; OUT_705] = [__v_6]; - if let Some(result) = record.function_queries[705].get_mut(&inp[..]) { debug_assert_eq!(result.output, &__ret[..]); if !unconstrained { *result.multiplicity += G::ONE; } } else { record.function_queries[705].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained)); }; + let __ret: [G; OUT_701] = [__v_6]; + if let Some(result) = record.function_queries[701].get_mut(&inp[..]) { debug_assert_eq!(result.output, &__ret[..]); if !unconstrained { *result.multiplicity += G::ONE; } } else { record.function_queries[701].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained)); }; return Ok(__ret); }, } @@ -59328,18 +59056,18 @@ fn aiur_fn_705( }) } -const INPUT_SIZE_706: usize = 1; -const IN_706: usize = 1; -const OUT_706: usize = 0; -fn aiur_fn_706( - inp: [G; IN_706], +const INPUT_SIZE_702: usize = 1; +const IN_702: usize = 1; +const OUT_702: usize = 0; +fn aiur_fn_702( + inp: [G; IN_702], record: &mut QueryRecord, io_buffer: &mut IOBuffer, unconstrained: bool, -) -> Result<[G; OUT_706], ExecError> { +) -> Result<[G; OUT_702], ExecError> { stacker::maybe_grow(64 * 1024, 4 * 1024 * 1024, || { let __v_0: G = inp[0]; - let __r_arr: [G; OUT_282] = { let __args: [G; IN_282] = [__v_0]; let __cu = unconstrained; if let Some(result) = record.function_queries[282].get_mut(&__args[..]) { if !__cu && *result.multiplicity == G::ZERO { aiur_fn_282(__args, record, io_buffer, false)? } else { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_282] = unsafe { *(result.output.as_ptr() as *const [G; OUT_282]) }; __ret } } else { aiur_fn_282(__args, record, io_buffer, __cu)? } }; + let __r_arr: [G; OUT_278] = { let __args: [G; IN_278] = [__v_0]; let __cu = unconstrained; if let Some(result) = record.function_queries[278].get_mut(&__args[..]) { if !__cu && *result.multiplicity == G::ZERO { aiur_fn_278(__args, record, io_buffer, false)? } else { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_278] = unsafe { *(result.output.as_ptr() as *const [G; OUT_278]) }; __ret } } else { aiur_fn_278(__args, record, io_buffer, __cu)? } }; let __v_1: G = __r_arr[0]; let __v_2: G = __r_arr[1]; let __v_3: G = __r_arr[2]; @@ -59393,14 +59121,14 @@ fn aiur_fn_706( let __mc_out___mc_0: [G; 0] = '__mc_0: { match __v_1.as_canonical_u64() { 8u64 => { let __v_49: G = G::from_u64(0); - let __r_arr: [G; OUT_708] = { let __args: [G; IN_708] = [__v_0, __v_2, __v_2, __v_49]; let __cu = unconstrained; if let Some(result) = record.function_queries[708].get_mut(&__args[..]) { if !__cu && *result.multiplicity == G::ZERO { aiur_fn_708(__args, record, io_buffer, false)? } else { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_708] = unsafe { *(result.output.as_ptr() as *const [G; OUT_708]) }; __ret } } else { aiur_fn_708(__args, record, io_buffer, __cu)? } }; + let __r_arr: [G; OUT_704] = { let __args: [G; IN_704] = [__v_0, __v_2, __v_2, __v_49]; let __cu = unconstrained; if let Some(result) = record.function_queries[704].get_mut(&__args[..]) { if !__cu && *result.multiplicity == G::ZERO { aiur_fn_704(__args, record, io_buffer, false)? } else { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_704] = unsafe { *(result.output.as_ptr() as *const [G; OUT_704]) }; __ret } } else { aiur_fn_704(__args, record, io_buffer, __cu)? } }; break '__mc_0 []; }, 7u64 => { match __v_2.as_canonical_u64() { _ => { - let __r_arr: [G; OUT_698] = { let __args: [G; IN_698] = [__v_0]; let __cu = unconstrained; if let Some(result) = record.function_queries[698].get_mut(&__args[..]) { if !__cu && *result.multiplicity == G::ZERO { aiur_fn_698(__args, record, io_buffer, false)? } else { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_698] = unsafe { *(result.output.as_ptr() as *const [G; OUT_698]) }; __ret } } else { aiur_fn_698(__args, record, io_buffer, __cu)? } }; - let __r_arr: [G; OUT_706] = { let __args: [G; IN_706] = [__v_10]; let __cu = unconstrained; if let Some(result) = record.function_queries[706].get_mut(&__args[..]) { if !__cu && *result.multiplicity == G::ZERO { aiur_fn_706(__args, record, io_buffer, false)? } else { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_706] = unsafe { *(result.output.as_ptr() as *const [G; OUT_706]) }; __ret } } else { aiur_fn_706(__args, record, io_buffer, __cu)? } }; + let __r_arr: [G; OUT_694] = { let __args: [G; IN_694] = [__v_0]; let __cu = unconstrained; if let Some(result) = record.function_queries[694].get_mut(&__args[..]) { if !__cu && *result.multiplicity == G::ZERO { aiur_fn_694(__args, record, io_buffer, false)? } else { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_694] = unsafe { *(result.output.as_ptr() as *const [G; OUT_694]) }; __ret } } else { aiur_fn_694(__args, record, io_buffer, __cu)? } }; + let __r_arr: [G; OUT_702] = { let __args: [G; IN_702] = [__v_10]; let __cu = unconstrained; if let Some(result) = record.function_queries[702].get_mut(&__args[..]) { if !__cu && *result.multiplicity == G::ZERO { aiur_fn_702(__args, record, io_buffer, false)? } else { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_702] = unsafe { *(result.output.as_ptr() as *const [G; OUT_702]) }; __ret } } else { aiur_fn_702(__args, record, io_buffer, __cu)? } }; break '__mc_0 []; }, } @@ -59408,8 +59136,8 @@ fn aiur_fn_706( 6u64 => { match __v_2.as_canonical_u64() { _ => { - let __r_arr: [G; OUT_698] = { let __args: [G; IN_698] = [__v_0]; let __cu = unconstrained; if let Some(result) = record.function_queries[698].get_mut(&__args[..]) { if !__cu && *result.multiplicity == G::ZERO { aiur_fn_698(__args, record, io_buffer, false)? } else { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_698] = unsafe { *(result.output.as_ptr() as *const [G; OUT_698]) }; __ret } } else { aiur_fn_698(__args, record, io_buffer, __cu)? } }; - let __r_arr: [G; OUT_706] = { let __args: [G; IN_706] = [__v_10]; let __cu = unconstrained; if let Some(result) = record.function_queries[706].get_mut(&__args[..]) { if !__cu && *result.multiplicity == G::ZERO { aiur_fn_706(__args, record, io_buffer, false)? } else { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_706] = unsafe { *(result.output.as_ptr() as *const [G; OUT_706]) }; __ret } } else { aiur_fn_706(__args, record, io_buffer, __cu)? } }; + let __r_arr: [G; OUT_694] = { let __args: [G; IN_694] = [__v_0]; let __cu = unconstrained; if let Some(result) = record.function_queries[694].get_mut(&__args[..]) { if !__cu && *result.multiplicity == G::ZERO { aiur_fn_694(__args, record, io_buffer, false)? } else { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_694] = unsafe { *(result.output.as_ptr() as *const [G; OUT_694]) }; __ret } } else { aiur_fn_694(__args, record, io_buffer, __cu)? } }; + let __r_arr: [G; OUT_702] = { let __args: [G; IN_702] = [__v_10]; let __cu = unconstrained; if let Some(result) = record.function_queries[702].get_mut(&__args[..]) { if !__cu && *result.multiplicity == G::ZERO { aiur_fn_702(__args, record, io_buffer, false)? } else { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_702] = unsafe { *(result.output.as_ptr() as *const [G; OUT_702]) }; __ret } } else { aiur_fn_702(__args, record, io_buffer, __cu)? } }; break '__mc_0 []; }, } @@ -59417,8 +59145,8 @@ fn aiur_fn_706( 4u64 => { match __v_2.as_canonical_u64() { _ => { - let __r_arr: [G; OUT_698] = { let __args: [G; IN_698] = [__v_0]; let __cu = unconstrained; if let Some(result) = record.function_queries[698].get_mut(&__args[..]) { if !__cu && *result.multiplicity == G::ZERO { aiur_fn_698(__args, record, io_buffer, false)? } else { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_698] = unsafe { *(result.output.as_ptr() as *const [G; OUT_698]) }; __ret } } else { aiur_fn_698(__args, record, io_buffer, __cu)? } }; - let __r_arr: [G; OUT_706] = { let __args: [G; IN_706] = [__v_18]; let __cu = unconstrained; if let Some(result) = record.function_queries[706].get_mut(&__args[..]) { if !__cu && *result.multiplicity == G::ZERO { aiur_fn_706(__args, record, io_buffer, false)? } else { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_706] = unsafe { *(result.output.as_ptr() as *const [G; OUT_706]) }; __ret } } else { aiur_fn_706(__args, record, io_buffer, __cu)? } }; + let __r_arr: [G; OUT_694] = { let __args: [G; IN_694] = [__v_0]; let __cu = unconstrained; if let Some(result) = record.function_queries[694].get_mut(&__args[..]) { if !__cu && *result.multiplicity == G::ZERO { aiur_fn_694(__args, record, io_buffer, false)? } else { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_694] = unsafe { *(result.output.as_ptr() as *const [G; OUT_694]) }; __ret } } else { aiur_fn_694(__args, record, io_buffer, __cu)? } }; + let __r_arr: [G; OUT_702] = { let __args: [G; IN_702] = [__v_18]; let __cu = unconstrained; if let Some(result) = record.function_queries[702].get_mut(&__args[..]) { if !__cu && *result.multiplicity == G::ZERO { aiur_fn_702(__args, record, io_buffer, false)? } else { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_702] = unsafe { *(result.output.as_ptr() as *const [G; OUT_702]) }; __ret } } else { aiur_fn_702(__args, record, io_buffer, __cu)? } }; break '__mc_0 []; }, } @@ -59426,39 +59154,39 @@ fn aiur_fn_706( 5u64 => { match __v_2.as_canonical_u64() { _ => { - let __r_arr: [G; OUT_698] = { let __args: [G; IN_698] = [__v_0]; let __cu = unconstrained; if let Some(result) = record.function_queries[698].get_mut(&__args[..]) { if !__cu && *result.multiplicity == G::ZERO { aiur_fn_698(__args, record, io_buffer, false)? } else { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_698] = unsafe { *(result.output.as_ptr() as *const [G; OUT_698]) }; __ret } } else { aiur_fn_698(__args, record, io_buffer, __cu)? } }; - let __r_arr: [G; OUT_706] = { let __args: [G; IN_706] = [__v_10]; let __cu = unconstrained; if let Some(result) = record.function_queries[706].get_mut(&__args[..]) { if !__cu && *result.multiplicity == G::ZERO { aiur_fn_706(__args, record, io_buffer, false)? } else { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_706] = unsafe { *(result.output.as_ptr() as *const [G; OUT_706]) }; __ret } } else { aiur_fn_706(__args, record, io_buffer, __cu)? } }; + let __r_arr: [G; OUT_694] = { let __args: [G; IN_694] = [__v_0]; let __cu = unconstrained; if let Some(result) = record.function_queries[694].get_mut(&__args[..]) { if !__cu && *result.multiplicity == G::ZERO { aiur_fn_694(__args, record, io_buffer, false)? } else { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_694] = unsafe { *(result.output.as_ptr() as *const [G; OUT_694]) }; __ret } } else { aiur_fn_694(__args, record, io_buffer, __cu)? } }; + let __r_arr: [G; OUT_702] = { let __args: [G; IN_702] = [__v_10]; let __cu = unconstrained; if let Some(result) = record.function_queries[702].get_mut(&__args[..]) { if !__cu && *result.multiplicity == G::ZERO { aiur_fn_702(__args, record, io_buffer, false)? } else { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_702] = unsafe { *(result.output.as_ptr() as *const [G; OUT_702]) }; __ret } } else { aiur_fn_702(__args, record, io_buffer, __cu)? } }; break '__mc_0 []; }, } }, _ => { - let __r_arr: [G; OUT_698] = { let __args: [G; IN_698] = [__v_0]; let __cu = unconstrained; if let Some(result) = record.function_queries[698].get_mut(&__args[..]) { if !__cu && *result.multiplicity == G::ZERO { aiur_fn_698(__args, record, io_buffer, false)? } else { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_698] = unsafe { *(result.output.as_ptr() as *const [G; OUT_698]) }; __ret } } else { aiur_fn_698(__args, record, io_buffer, __cu)? } }; + let __r_arr: [G; OUT_694] = { let __args: [G; IN_694] = [__v_0]; let __cu = unconstrained; if let Some(result) = record.function_queries[694].get_mut(&__args[..]) { if !__cu && *result.multiplicity == G::ZERO { aiur_fn_694(__args, record, io_buffer, false)? } else { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_694] = unsafe { *(result.output.as_ptr() as *const [G; OUT_694]) }; __ret } } else { aiur_fn_694(__args, record, io_buffer, __cu)? } }; break '__mc_0 []; }, } }; - let __r_arr: [G; OUT_704] = { let __args: [G; IN_704] = [__v_1, __v_2, __v_3, __v_4, __v_5, __v_6, __v_7, __v_8, __v_9, __v_10, __v_11, __v_12, __v_13, __v_14, __v_15, __v_16, __v_17, __v_18, __v_19, __v_20, __v_21, __v_22, __v_23, __v_24, __v_25, __v_26, __v_27, __v_28, __v_29, __v_30, __v_31, __v_32, __v_33, __v_34, __v_35, __v_36, __v_37, __v_38, __v_39, __v_40, __v_41, __v_42, __v_43, __v_44, __v_45, __v_46, __v_47, __v_48]; let __cu = unconstrained; if let Some(result) = record.function_queries[704].get_mut(&__args[..]) { if !__cu && *result.multiplicity == G::ZERO { aiur_fn_704(__args, record, io_buffer, false)? } else { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_704] = unsafe { *(result.output.as_ptr() as *const [G; OUT_704]) }; __ret } } else { aiur_fn_704(__args, record, io_buffer, __cu)? } }; + let __r_arr: [G; OUT_700] = { let __args: [G; IN_700] = [__v_1, __v_2, __v_3, __v_4, __v_5, __v_6, __v_7, __v_8, __v_9, __v_10, __v_11, __v_12, __v_13, __v_14, __v_15, __v_16, __v_17, __v_18, __v_19, __v_20, __v_21, __v_22, __v_23, __v_24, __v_25, __v_26, __v_27, __v_28, __v_29, __v_30, __v_31, __v_32, __v_33, __v_34, __v_35, __v_36, __v_37, __v_38, __v_39, __v_40, __v_41, __v_42, __v_43, __v_44, __v_45, __v_46, __v_47, __v_48]; let __cu = unconstrained; if let Some(result) = record.function_queries[700].get_mut(&__args[..]) { if !__cu && *result.multiplicity == G::ZERO { aiur_fn_700(__args, record, io_buffer, false)? } else { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_700] = unsafe { *(result.output.as_ptr() as *const [G; OUT_700]) }; __ret } } else { aiur_fn_700(__args, record, io_buffer, __cu)? } }; let __v_49: G = __r_arr[0]; let __v_50: G = G::from_u64(0); - let __r_arr: [G; OUT_707] = { let __args: [G; IN_707] = [__v_47, __v_49, __v_50]; let __cu = unconstrained; if let Some(result) = record.function_queries[707].get_mut(&__args[..]) { if !__cu && *result.multiplicity == G::ZERO { aiur_fn_707(__args, record, io_buffer, false)? } else { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_707] = unsafe { *(result.output.as_ptr() as *const [G; OUT_707]) }; __ret } } else { aiur_fn_707(__args, record, io_buffer, __cu)? } }; - let __ret: [G; OUT_706] = []; - if let Some(result) = record.function_queries[706].get_mut(&inp[..]) { debug_assert_eq!(result.output, &__ret[..]); if !unconstrained { *result.multiplicity += G::ONE; } } else { record.function_queries[706].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained)); }; + let __r_arr: [G; OUT_703] = { let __args: [G; IN_703] = [__v_47, __v_49, __v_50]; let __cu = unconstrained; if let Some(result) = record.function_queries[703].get_mut(&__args[..]) { if !__cu && *result.multiplicity == G::ZERO { aiur_fn_703(__args, record, io_buffer, false)? } else { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_703] = unsafe { *(result.output.as_ptr() as *const [G; OUT_703]) }; __ret } } else { aiur_fn_703(__args, record, io_buffer, __cu)? } }; + let __ret: [G; OUT_702] = []; + if let Some(result) = record.function_queries[702].get_mut(&inp[..]) { debug_assert_eq!(result.output, &__ret[..]); if !unconstrained { *result.multiplicity += G::ONE; } } else { record.function_queries[702].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained)); }; return Ok(__ret); }, } }) } -const INPUT_SIZE_707: usize = 3; -const IN_707: usize = 3; -const OUT_707: usize = 0; -fn aiur_fn_707( - inp: [G; IN_707], +const INPUT_SIZE_703: usize = 3; +const IN_703: usize = 3; +const OUT_703: usize = 0; +fn aiur_fn_703( + inp: [G; IN_703], record: &mut QueryRecord, io_buffer: &mut IOBuffer, unconstrained: bool, -) -> Result<[G; OUT_707], ExecError> { +) -> Result<[G; OUT_703], ExecError> { stacker::maybe_grow(64 * 1024, 4 * 1024 * 1024, || { let __v_0: G = inp[0]; let __v_1: G = inp[1]; @@ -59469,16 +59197,16 @@ fn aiur_fn_707( let __v_5: G = __loaded[2]; match __v_3.as_canonical_u64() { 1u64 => { - let __ret: [G; OUT_707] = []; - if let Some(result) = record.function_queries[707].get_mut(&inp[..]) { debug_assert_eq!(result.output, &__ret[..]); if !unconstrained { *result.multiplicity += G::ONE; } } else { record.function_queries[707].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained)); }; + let __ret: [G; OUT_703] = []; + if let Some(result) = record.function_queries[703].get_mut(&inp[..]) { debug_assert_eq!(result.output, &__ret[..]); if !unconstrained { *result.multiplicity += G::ONE; } } else { record.function_queries[703].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained)); }; return Ok(__ret); }, 0u64 => { - let __r_arr: [G; OUT_705] = { let __args: [G; IN_705] = [__v_1, __v_2]; let __cu = unconstrained; if let Some(result) = record.function_queries[705].get_mut(&__args[..]) { if !__cu && *result.multiplicity == G::ZERO { aiur_fn_705(__args, record, io_buffer, false)? } else { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_705] = unsafe { *(result.output.as_ptr() as *const [G; OUT_705]) }; __ret } } else { aiur_fn_705(__args, record, io_buffer, __cu)? } }; + let __r_arr: [G; OUT_701] = { let __args: [G; IN_701] = [__v_1, __v_2]; let __cu = unconstrained; if let Some(result) = record.function_queries[701].get_mut(&__args[..]) { if !__cu && *result.multiplicity == G::ZERO { aiur_fn_701(__args, record, io_buffer, false)? } else { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_701] = unsafe { *(result.output.as_ptr() as *const [G; OUT_701]) }; __ret } } else { aiur_fn_701(__args, record, io_buffer, __cu)? } }; let __v_6: G = __r_arr[0]; let __mc_out___mc_0: [G; 0] = '__mc_0: { match __v_6.as_canonical_u64() { 1u64 => { - let __r_arr: [G; OUT_706] = { let __args: [G; IN_706] = [__v_4]; let __cu = unconstrained; if let Some(result) = record.function_queries[706].get_mut(&__args[..]) { if !__cu && *result.multiplicity == G::ZERO { aiur_fn_706(__args, record, io_buffer, false)? } else { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_706] = unsafe { *(result.output.as_ptr() as *const [G; OUT_706]) }; __ret } } else { aiur_fn_706(__args, record, io_buffer, __cu)? } }; + let __r_arr: [G; OUT_702] = { let __args: [G; IN_702] = [__v_4]; let __cu = unconstrained; if let Some(result) = record.function_queries[702].get_mut(&__args[..]) { if !__cu && *result.multiplicity == G::ZERO { aiur_fn_702(__args, record, io_buffer, false)? } else { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_702] = unsafe { *(result.output.as_ptr() as *const [G; OUT_702]) }; __ret } } else { aiur_fn_702(__args, record, io_buffer, __cu)? } }; break '__mc_0 []; }, _ => { @@ -59488,9 +59216,9 @@ fn aiur_fn_707( }; let __v_7: G = G::from_u64(1); let __v_8: G = (__v_2 + __v_7); - let __r_arr: [G; OUT_707] = { let __args: [G; IN_707] = [__v_5, __v_1, __v_8]; let __cu = unconstrained; if let Some(result) = record.function_queries[707].get_mut(&__args[..]) { if !__cu && *result.multiplicity == G::ZERO { aiur_fn_707(__args, record, io_buffer, false)? } else { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_707] = unsafe { *(result.output.as_ptr() as *const [G; OUT_707]) }; __ret } } else { aiur_fn_707(__args, record, io_buffer, __cu)? } }; - let __ret: [G; OUT_707] = []; - if let Some(result) = record.function_queries[707].get_mut(&inp[..]) { debug_assert_eq!(result.output, &__ret[..]); if !unconstrained { *result.multiplicity += G::ONE; } } else { record.function_queries[707].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained)); }; + let __r_arr: [G; OUT_703] = { let __args: [G; IN_703] = [__v_5, __v_1, __v_8]; let __cu = unconstrained; if let Some(result) = record.function_queries[703].get_mut(&__args[..]) { if !__cu && *result.multiplicity == G::ZERO { aiur_fn_703(__args, record, io_buffer, false)? } else { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_703] = unsafe { *(result.output.as_ptr() as *const [G; OUT_703]) }; __ret } } else { aiur_fn_703(__args, record, io_buffer, __cu)? } }; + let __ret: [G; OUT_703] = []; + if let Some(result) = record.function_queries[703].get_mut(&inp[..]) { debug_assert_eq!(result.output, &__ret[..]); if !unconstrained { *result.multiplicity += G::ONE; } } else { record.function_queries[703].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained)); }; return Ok(__ret); }, _ => { @@ -59500,15 +59228,15 @@ fn aiur_fn_707( }) } -const INPUT_SIZE_708: usize = 4; -const IN_708: usize = 4; -const OUT_708: usize = 0; -fn aiur_fn_708( - inp: [G; IN_708], +const INPUT_SIZE_704: usize = 4; +const IN_704: usize = 4; +const OUT_704: usize = 0; +fn aiur_fn_704( + inp: [G; IN_704], record: &mut QueryRecord, io_buffer: &mut IOBuffer, unconstrained: bool, -) -> Result<[G; OUT_708], ExecError> { +) -> Result<[G; OUT_704], ExecError> { stacker::maybe_grow(64 * 1024, 4 * 1024 * 1024, || { let __v_0: G = inp[0]; let __v_1: G = inp[1]; @@ -59564,17 +59292,17 @@ fn aiur_fn_708( let __v_50: G = __loaded[46]; match __v_4.as_canonical_u64() { 1u64 => { - let __ret: [G; OUT_708] = []; - if let Some(result) = record.function_queries[708].get_mut(&inp[..]) { debug_assert_eq!(result.output, &__ret[..]); if !unconstrained { *result.multiplicity += G::ONE; } } else { record.function_queries[708].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained)); }; + let __ret: [G; OUT_704] = []; + if let Some(result) = record.function_queries[704].get_mut(&inp[..]) { debug_assert_eq!(result.output, &__ret[..]); if !unconstrained { *result.multiplicity += G::ONE; } } else { record.function_queries[704].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained)); }; return Ok(__ret); }, 0u64 => { - let __r_arr: [G; OUT_709] = { let __args: [G; IN_709] = [__v_0, __v_1, __v_5, __v_6, __v_7, __v_8, __v_9, __v_10, __v_11, __v_12, __v_13, __v_14, __v_15, __v_16, __v_17, __v_18, __v_19, __v_20, __v_21, __v_22, __v_23, __v_24, __v_25, __v_26, __v_27, __v_28, __v_29, __v_30, __v_31, __v_32, __v_33, __v_34, __v_35, __v_36, __v_37, __v_38, __v_39, __v_40, __v_41, __v_42, __v_43, __v_44, __v_45, __v_46, __v_47, __v_48, __v_49, __v_3]; let __cu = unconstrained; if let Some(result) = record.function_queries[709].get_mut(&__args[..]) { if !__cu && *result.multiplicity == G::ZERO { aiur_fn_709(__args, record, io_buffer, false)? } else { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_709] = unsafe { *(result.output.as_ptr() as *const [G; OUT_709]) }; __ret } } else { aiur_fn_709(__args, record, io_buffer, __cu)? } }; + let __r_arr: [G; OUT_705] = { let __args: [G; IN_705] = [__v_0, __v_1, __v_5, __v_6, __v_7, __v_8, __v_9, __v_10, __v_11, __v_12, __v_13, __v_14, __v_15, __v_16, __v_17, __v_18, __v_19, __v_20, __v_21, __v_22, __v_23, __v_24, __v_25, __v_26, __v_27, __v_28, __v_29, __v_30, __v_31, __v_32, __v_33, __v_34, __v_35, __v_36, __v_37, __v_38, __v_39, __v_40, __v_41, __v_42, __v_43, __v_44, __v_45, __v_46, __v_47, __v_48, __v_49, __v_3]; let __cu = unconstrained; if let Some(result) = record.function_queries[705].get_mut(&__args[..]) { if !__cu && *result.multiplicity == G::ZERO { aiur_fn_705(__args, record, io_buffer, false)? } else { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_705] = unsafe { *(result.output.as_ptr() as *const [G; OUT_705]) }; __ret } } else { aiur_fn_705(__args, record, io_buffer, __cu)? } }; let __v_51: G = G::from_u64(1); let __v_52: G = (__v_3 + __v_51); - let __r_arr: [G; OUT_708] = { let __args: [G; IN_708] = [__v_0, __v_1, __v_50, __v_52]; let __cu = unconstrained; if let Some(result) = record.function_queries[708].get_mut(&__args[..]) { if !__cu && *result.multiplicity == G::ZERO { aiur_fn_708(__args, record, io_buffer, false)? } else { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_708] = unsafe { *(result.output.as_ptr() as *const [G; OUT_708]) }; __ret } } else { aiur_fn_708(__args, record, io_buffer, __cu)? } }; - let __ret: [G; OUT_708] = []; - if let Some(result) = record.function_queries[708].get_mut(&inp[..]) { debug_assert_eq!(result.output, &__ret[..]); if !unconstrained { *result.multiplicity += G::ONE; } } else { record.function_queries[708].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained)); }; + let __r_arr: [G; OUT_704] = { let __args: [G; IN_704] = [__v_0, __v_1, __v_50, __v_52]; let __cu = unconstrained; if let Some(result) = record.function_queries[704].get_mut(&__args[..]) { if !__cu && *result.multiplicity == G::ZERO { aiur_fn_704(__args, record, io_buffer, false)? } else { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_704] = unsafe { *(result.output.as_ptr() as *const [G; OUT_704]) }; __ret } } else { aiur_fn_704(__args, record, io_buffer, __cu)? } }; + let __ret: [G; OUT_704] = []; + if let Some(result) = record.function_queries[704].get_mut(&inp[..]) { debug_assert_eq!(result.output, &__ret[..]); if !unconstrained { *result.multiplicity += G::ONE; } } else { record.function_queries[704].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained)); }; return Ok(__ret); }, _ => { @@ -59584,15 +59312,15 @@ fn aiur_fn_708( }) } -const INPUT_SIZE_709: usize = 48; -const IN_709: usize = 48; -const OUT_709: usize = 0; -fn aiur_fn_709( - inp: [G; IN_709], +const INPUT_SIZE_705: usize = 48; +const IN_705: usize = 48; +const OUT_705: usize = 0; +fn aiur_fn_705( + inp: [G; IN_705], record: &mut QueryRecord, io_buffer: &mut IOBuffer, unconstrained: bool, -) -> Result<[G; OUT_709], ExecError> { +) -> Result<[G; OUT_705], ExecError> { stacker::maybe_grow(64 * 1024, 4 * 1024 * 1024, || { let __v_0: G = inp[0]; let __v_1: G = inp[1]; @@ -59642,9 +59370,9 @@ fn aiur_fn_709( let __v_45: G = inp[45]; let __v_46: G = inp[46]; let __v_47: G = inp[47]; - let __r_arr: [G; OUT_294] = { let __args: [G; IN_294] = [__v_1, __v_0, __v_47]; let __cu = unconstrained; if let Some(result) = record.function_queries[294].get_mut(&__args[..]) { if !__cu && *result.multiplicity == G::ZERO { aiur_fn_294(__args, record, io_buffer, false)? } else { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_294] = unsafe { *(result.output.as_ptr() as *const [G; OUT_294]) }; __ret } } else { aiur_fn_294(__args, record, io_buffer, __cu)? } }; + let __r_arr: [G; OUT_290] = { let __args: [G; IN_290] = [__v_1, __v_0, __v_47]; let __cu = unconstrained; if let Some(result) = record.function_queries[290].get_mut(&__args[..]) { if !__cu && *result.multiplicity == G::ZERO { aiur_fn_290(__args, record, io_buffer, false)? } else { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_290] = unsafe { *(result.output.as_ptr() as *const [G; OUT_290]) }; __ret } } else { aiur_fn_290(__args, record, io_buffer, __cu)? } }; let __v_48: G = __r_arr[0]; - let __r_arr: [G; OUT_287] = { let __args: [G; IN_287] = [__v_48]; let __cu = unconstrained; if let Some(result) = record.function_queries[287].get_mut(&__args[..]) { if !__cu && *result.multiplicity == G::ZERO { aiur_fn_287(__args, record, io_buffer, false)? } else { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_287] = unsafe { *(result.output.as_ptr() as *const [G; OUT_287]) }; __ret } } else { aiur_fn_287(__args, record, io_buffer, __cu)? } }; + let __r_arr: [G; OUT_283] = { let __args: [G; IN_283] = [__v_48]; let __cu = unconstrained; if let Some(result) = record.function_queries[283].get_mut(&__args[..]) { if !__cu && *result.multiplicity == G::ZERO { aiur_fn_283(__args, record, io_buffer, false)? } else { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_283] = unsafe { *(result.output.as_ptr() as *const [G; OUT_283]) }; __ret } } else { aiur_fn_283(__args, record, io_buffer, __cu)? } }; let __v_49: G = __r_arr[0]; let __loaded: [G; 12] = { let __mq = record.memory_queries.get_mut(&12).ok_or(ExecError::InvalidMemorySize(12))?; let __ptr_u64 = __v_49.as_canonical_u64(); let __ptr_usize = usize::try_from(__ptr_u64).ok().ok_or(ExecError::PointerTooLarge(__ptr_u64))?; let (__args, __mult) = __mq.get_index_mut(__ptr_usize).ok_or(ExecError::UnboundPointer { ptr: __ptr_u64, size: 12 })?; if !unconstrained { *__mult += G::ONE; } let __arr: [G; 12] = __args[..12].try_into().unwrap(); __arr }; let __v_50: G = __loaded[0]; @@ -59659,22 +59387,22 @@ fn aiur_fn_709( let __v_59: G = __loaded[9]; let __v_60: G = __loaded[10]; let __v_61: G = __loaded[11]; - let __r_arr: [G; OUT_697] = { let __args: [G; IN_697] = [__v_50, __v_51, __v_52, __v_53, __v_54, __v_55, __v_56, __v_57, __v_58, __v_59, __v_60, __v_61, __v_48]; let __cu = unconstrained; if let Some(result) = record.function_queries[697].get_mut(&__args[..]) { if !__cu && *result.multiplicity == G::ZERO { aiur_fn_697(__args, record, io_buffer, false)? } else { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_697] = unsafe { *(result.output.as_ptr() as *const [G; OUT_697]) }; __ret } } else { aiur_fn_697(__args, record, io_buffer, __cu)? } }; - let __ret: [G; OUT_709] = []; - if let Some(result) = record.function_queries[709].get_mut(&inp[..]) { debug_assert_eq!(result.output, &__ret[..]); if !unconstrained { *result.multiplicity += G::ONE; } } else { record.function_queries[709].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained)); }; + let __r_arr: [G; OUT_693] = { let __args: [G; IN_693] = [__v_50, __v_51, __v_52, __v_53, __v_54, __v_55, __v_56, __v_57, __v_58, __v_59, __v_60, __v_61, __v_48]; let __cu = unconstrained; if let Some(result) = record.function_queries[693].get_mut(&__args[..]) { if !__cu && *result.multiplicity == G::ZERO { aiur_fn_693(__args, record, io_buffer, false)? } else { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_693] = unsafe { *(result.output.as_ptr() as *const [G; OUT_693]) }; __ret } } else { aiur_fn_693(__args, record, io_buffer, __cu)? } }; + let __ret: [G; OUT_705] = []; + if let Some(result) = record.function_queries[705].get_mut(&inp[..]) { debug_assert_eq!(result.output, &__ret[..]); if !unconstrained { *result.multiplicity += G::ONE; } } else { record.function_queries[705].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained)); }; return Ok(__ret); }) } -const INPUT_SIZE_710: usize = 1; -const IN_710: usize = 1; -const OUT_710: usize = 1; -fn aiur_fn_710( - inp: [G; IN_710], +const INPUT_SIZE_706: usize = 1; +const IN_706: usize = 1; +const OUT_706: usize = 1; +fn aiur_fn_706( + inp: [G; IN_706], record: &mut QueryRecord, io_buffer: &mut IOBuffer, unconstrained: bool, -) -> Result<[G; OUT_710], ExecError> { +) -> Result<[G; OUT_706], ExecError> { stacker::maybe_grow(64 * 1024, 4 * 1024 * 1024, || { let __v_0: G = inp[0]; let __v_1: G = G::from_u64(1); @@ -59687,21 +59415,21 @@ fn aiur_fn_710( let __v_7: G = { let __values: [G; 3] = [__v_5, __v_6, __v_4]; let __mq = record.memory_queries.get_mut(&3).ok_or(ExecError::InvalidMemorySize(3))?; if let Some(result) = __mq.get_mut(&__values[..]) { if !unconstrained { *result.multiplicity += G::ONE; } result.output[0] } else { let __ptr = G::from_usize(__mq.len()); __mq.insert(&__values[..], &[__ptr], G::from_bool(!unconstrained)); __ptr } }; let __r_arr: [G; OUT_21] = { let __args: [G; IN_21] = [__v_7]; let __cu = unconstrained; if let Some(result) = record.function_queries[21].get_mut(&__args[..]) { if !__cu && *result.multiplicity == G::ZERO { aiur_fn_21(__args, record, io_buffer, false)? } else { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_21] = unsafe { *(result.output.as_ptr() as *const [G; OUT_21]) }; __ret } } else { aiur_fn_21(__args, record, io_buffer, __cu)? } }; let __v_8: G = __r_arr[0]; - let __ret: [G; OUT_710] = [__v_8]; - if let Some(result) = record.function_queries[710].get_mut(&inp[..]) { debug_assert_eq!(result.output, &__ret[..]); if !unconstrained { *result.multiplicity += G::ONE; } } else { record.function_queries[710].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained)); }; + let __ret: [G; OUT_706] = [__v_8]; + if let Some(result) = record.function_queries[706].get_mut(&inp[..]) { debug_assert_eq!(result.output, &__ret[..]); if !unconstrained { *result.multiplicity += G::ONE; } } else { record.function_queries[706].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained)); }; return Ok(__ret); }) } -const INPUT_SIZE_711: usize = 2; -const IN_711: usize = 2; -const OUT_711: usize = 1; -fn aiur_fn_711( - inp: [G; IN_711], +const INPUT_SIZE_707: usize = 2; +const IN_707: usize = 2; +const OUT_707: usize = 1; +fn aiur_fn_707( + inp: [G; IN_707], record: &mut QueryRecord, io_buffer: &mut IOBuffer, unconstrained: bool, -) -> Result<[G; OUT_711], ExecError> { +) -> Result<[G; OUT_707], ExecError> { stacker::maybe_grow(64 * 1024, 4 * 1024 * 1024, || { let __v_0: G = inp[0]; let __v_1: G = inp[1]; @@ -59717,21 +59445,21 @@ fn aiur_fn_711( let __v_9: G = { let __values: [G; 3] = [__v_7, __v_8, __v_6]; let __mq = record.memory_queries.get_mut(&3).ok_or(ExecError::InvalidMemorySize(3))?; if let Some(result) = __mq.get_mut(&__values[..]) { if !unconstrained { *result.multiplicity += G::ONE; } result.output[0] } else { let __ptr = G::from_usize(__mq.len()); __mq.insert(&__values[..], &[__ptr], G::from_bool(!unconstrained)); __ptr } }; let __r_arr: [G; OUT_21] = { let __args: [G; IN_21] = [__v_9]; let __cu = unconstrained; if let Some(result) = record.function_queries[21].get_mut(&__args[..]) { if !__cu && *result.multiplicity == G::ZERO { aiur_fn_21(__args, record, io_buffer, false)? } else { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_21] = unsafe { *(result.output.as_ptr() as *const [G; OUT_21]) }; __ret } } else { aiur_fn_21(__args, record, io_buffer, __cu)? } }; let __v_10: G = __r_arr[0]; - let __ret: [G; OUT_711] = [__v_10]; - if let Some(result) = record.function_queries[711].get_mut(&inp[..]) { debug_assert_eq!(result.output, &__ret[..]); if !unconstrained { *result.multiplicity += G::ONE; } } else { record.function_queries[711].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained)); }; + let __ret: [G; OUT_707] = [__v_10]; + if let Some(result) = record.function_queries[707].get_mut(&inp[..]) { debug_assert_eq!(result.output, &__ret[..]); if !unconstrained { *result.multiplicity += G::ONE; } } else { record.function_queries[707].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained)); }; return Ok(__ret); }) } -const INPUT_SIZE_712: usize = 1; -const IN_712: usize = 1; -const OUT_712: usize = 3; -fn aiur_fn_712( - inp: [G; IN_712], +const INPUT_SIZE_708: usize = 1; +const IN_708: usize = 1; +const OUT_708: usize = 3; +fn aiur_fn_708( + inp: [G; IN_708], record: &mut QueryRecord, io_buffer: &mut IOBuffer, unconstrained: bool, -) -> Result<[G; OUT_712], ExecError> { +) -> Result<[G; OUT_708], ExecError> { stacker::maybe_grow(64 * 1024, 4 * 1024 * 1024, || { let __v_0: G = inp[0]; let __r_arr: [G; OUT_72] = { let __args: [G; IN_72] = [__v_0]; let __cu = unconstrained; if let Some(result) = record.function_queries[72].get_mut(&__args[..]) { if !__cu && *result.multiplicity == G::ZERO { aiur_fn_72(__args, record, io_buffer, false)? } else { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_72] = unsafe { *(result.output.as_ptr() as *const [G; OUT_72]) }; __ret } } else { aiur_fn_72(__args, record, io_buffer, __cu)? } }; @@ -59742,15 +59470,15 @@ fn aiur_fn_712( let __r_arr: [G; OUT_85] = { let __args: [G; IN_85] = [__v_2]; let __cu = unconstrained; if let Some(result) = record.function_queries[85].get_mut(&__args[..]) { if !__cu && *result.multiplicity == G::ZERO { aiur_fn_85(__args, record, io_buffer, false)? } else { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_85] = unsafe { *(result.output.as_ptr() as *const [G; OUT_85]) }; __ret } } else { aiur_fn_85(__args, record, io_buffer, __cu)? } }; let __v_3: G = __r_arr[0]; let __v_4: G = __r_arr[1]; - let __r_arr: [G; OUT_710] = { let __args: [G; IN_710] = [__v_3]; let __cu = unconstrained; if let Some(result) = record.function_queries[710].get_mut(&__args[..]) { if !__cu && *result.multiplicity == G::ZERO { aiur_fn_710(__args, record, io_buffer, false)? } else { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_710] = unsafe { *(result.output.as_ptr() as *const [G; OUT_710]) }; __ret } } else { aiur_fn_710(__args, record, io_buffer, __cu)? } }; + let __r_arr: [G; OUT_706] = { let __args: [G; IN_706] = [__v_3]; let __cu = unconstrained; if let Some(result) = record.function_queries[706].get_mut(&__args[..]) { if !__cu && *result.multiplicity == G::ZERO { aiur_fn_706(__args, record, io_buffer, false)? } else { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_706] = unsafe { *(result.output.as_ptr() as *const [G; OUT_706]) }; __ret } } else { aiur_fn_706(__args, record, io_buffer, __cu)? } }; let __v_5: G = __r_arr[0]; let __v_6: G = G::from_u64(0); let __v_7: G = G::from_u64(1); let __v_8: G = G::from_u64(1); let __v_9: G = { let __values: [G; 3] = [__v_7, __v_8, __v_8]; let __mq = record.memory_queries.get_mut(&3).ok_or(ExecError::InvalidMemorySize(3))?; if let Some(result) = __mq.get_mut(&__values[..]) { if !unconstrained { *result.multiplicity += G::ONE; } result.output[0] } else { let __ptr = G::from_usize(__mq.len()); __mq.insert(&__values[..], &[__ptr], G::from_bool(!unconstrained)); __ptr } }; let __v_10: G = { let __values: [G; 3] = [__v_6, __v_3, __v_9]; let __mq = record.memory_queries.get_mut(&3).ok_or(ExecError::InvalidMemorySize(3))?; if let Some(result) = __mq.get_mut(&__values[..]) { if !unconstrained { *result.multiplicity += G::ONE; } result.output[0] } else { let __ptr = G::from_usize(__mq.len()); __mq.insert(&__values[..], &[__ptr], G::from_bool(!unconstrained)); __ptr } }; - let __ret: [G; OUT_712] = [__v_5, __v_10, __v_4]; - if let Some(result) = record.function_queries[712].get_mut(&inp[..]) { debug_assert_eq!(result.output, &__ret[..]); if !unconstrained { *result.multiplicity += G::ONE; } } else { record.function_queries[712].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained)); }; + let __ret: [G; OUT_708] = [__v_5, __v_10, __v_4]; + if let Some(result) = record.function_queries[708].get_mut(&inp[..]) { debug_assert_eq!(result.output, &__ret[..]); if !unconstrained { *result.multiplicity += G::ONE; } } else { record.function_queries[708].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained)); }; return Ok(__ret); }, 1u64 => { @@ -59790,25 +59518,25 @@ fn aiur_fn_712( let __v_36: G = G::from_u64(1); let __v_37: G = G::from_u64(1); let __v_38: G = { let __values: [G; 3] = [__v_36, __v_37, __v_37]; let __mq = record.memory_queries.get_mut(&3).ok_or(ExecError::InvalidMemorySize(3))?; if let Some(result) = __mq.get_mut(&__values[..]) { if !unconstrained { *result.multiplicity += G::ONE; } result.output[0] } else { let __ptr = G::from_usize(__mq.len()); __mq.insert(&__values[..], &[__ptr], G::from_bool(!unconstrained)); __ptr } }; - let __ret: [G; OUT_712] = [__v_35, __v_38, __v_2]; - if let Some(result) = record.function_queries[712].get_mut(&inp[..]) { debug_assert_eq!(result.output, &__ret[..]); if !unconstrained { *result.multiplicity += G::ONE; } } else { record.function_queries[712].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained)); }; + let __ret: [G; OUT_708] = [__v_35, __v_38, __v_2]; + if let Some(result) = record.function_queries[708].get_mut(&inp[..]) { debug_assert_eq!(result.output, &__ret[..]); if !unconstrained { *result.multiplicity += G::ONE; } } else { record.function_queries[708].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained)); }; return Ok(__ret); }, 2u64 => { - let __r_arr: [G; OUT_712] = { let __args: [G; IN_712] = [__v_2]; let __cu = unconstrained; if let Some(result) = record.function_queries[712].get_mut(&__args[..]) { if !__cu && *result.multiplicity == G::ZERO { aiur_fn_712(__args, record, io_buffer, false)? } else { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_712] = unsafe { *(result.output.as_ptr() as *const [G; OUT_712]) }; __ret } } else { aiur_fn_712(__args, record, io_buffer, __cu)? } }; + let __r_arr: [G; OUT_708] = { let __args: [G; IN_708] = [__v_2]; let __cu = unconstrained; if let Some(result) = record.function_queries[708].get_mut(&__args[..]) { if !__cu && *result.multiplicity == G::ZERO { aiur_fn_708(__args, record, io_buffer, false)? } else { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_708] = unsafe { *(result.output.as_ptr() as *const [G; OUT_708]) }; __ret } } else { aiur_fn_708(__args, record, io_buffer, __cu)? } }; let __v_3: G = __r_arr[0]; let __v_4: G = __r_arr[1]; let __v_5: G = __r_arr[2]; - let __r_arr: [G; OUT_712] = { let __args: [G; IN_712] = [__v_5]; let __cu = unconstrained; if let Some(result) = record.function_queries[712].get_mut(&__args[..]) { if !__cu && *result.multiplicity == G::ZERO { aiur_fn_712(__args, record, io_buffer, false)? } else { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_712] = unsafe { *(result.output.as_ptr() as *const [G; OUT_712]) }; __ret } } else { aiur_fn_712(__args, record, io_buffer, __cu)? } }; + let __r_arr: [G; OUT_708] = { let __args: [G; IN_708] = [__v_5]; let __cu = unconstrained; if let Some(result) = record.function_queries[708].get_mut(&__args[..]) { if !__cu && *result.multiplicity == G::ZERO { aiur_fn_708(__args, record, io_buffer, false)? } else { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_708] = unsafe { *(result.output.as_ptr() as *const [G; OUT_708]) }; __ret } } else { aiur_fn_708(__args, record, io_buffer, __cu)? } }; let __v_6: G = __r_arr[0]; let __v_7: G = __r_arr[1]; let __v_8: G = __r_arr[2]; - let __r_arr: [G; OUT_711] = { let __args: [G; IN_711] = [__v_3, __v_6]; let __cu = unconstrained; if let Some(result) = record.function_queries[711].get_mut(&__args[..]) { if !__cu && *result.multiplicity == G::ZERO { aiur_fn_711(__args, record, io_buffer, false)? } else { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_711] = unsafe { *(result.output.as_ptr() as *const [G; OUT_711]) }; __ret } } else { aiur_fn_711(__args, record, io_buffer, __cu)? } }; + let __r_arr: [G; OUT_707] = { let __args: [G; IN_707] = [__v_3, __v_6]; let __cu = unconstrained; if let Some(result) = record.function_queries[707].get_mut(&__args[..]) { if !__cu && *result.multiplicity == G::ZERO { aiur_fn_707(__args, record, io_buffer, false)? } else { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_707] = unsafe { *(result.output.as_ptr() as *const [G; OUT_707]) }; __ret } } else { aiur_fn_707(__args, record, io_buffer, __cu)? } }; let __v_9: G = __r_arr[0]; - let __r_arr: [G; OUT_763] = { let __args: [G; IN_763] = [__v_4, __v_7]; let __cu = unconstrained; if let Some(result) = record.function_queries[763].get_mut(&__args[..]) { if !__cu && *result.multiplicity == G::ZERO { aiur_fn_763(__args, record, io_buffer, false)? } else { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_763] = unsafe { *(result.output.as_ptr() as *const [G; OUT_763]) }; __ret } } else { aiur_fn_763(__args, record, io_buffer, __cu)? } }; + let __r_arr: [G; OUT_759] = { let __args: [G; IN_759] = [__v_4, __v_7]; let __cu = unconstrained; if let Some(result) = record.function_queries[759].get_mut(&__args[..]) { if !__cu && *result.multiplicity == G::ZERO { aiur_fn_759(__args, record, io_buffer, false)? } else { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_759] = unsafe { *(result.output.as_ptr() as *const [G; OUT_759]) }; __ret } } else { aiur_fn_759(__args, record, io_buffer, __cu)? } }; let __v_10: G = __r_arr[0]; - let __ret: [G; OUT_712] = [__v_9, __v_10, __v_8]; - if let Some(result) = record.function_queries[712].get_mut(&inp[..]) { debug_assert_eq!(result.output, &__ret[..]); if !unconstrained { *result.multiplicity += G::ONE; } } else { record.function_queries[712].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained)); }; + let __ret: [G; OUT_708] = [__v_9, __v_10, __v_8]; + if let Some(result) = record.function_queries[708].get_mut(&inp[..]) { debug_assert_eq!(result.output, &__ret[..]); if !unconstrained { *result.multiplicity += G::ONE; } } else { record.function_queries[708].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained)); }; return Ok(__ret); }, _ => { @@ -59818,15 +59546,15 @@ fn aiur_fn_712( }) } -const INPUT_SIZE_713: usize = 1; -const IN_713: usize = 1; -const OUT_713: usize = 1; -fn aiur_fn_713( - inp: [G; IN_713], +const INPUT_SIZE_709: usize = 1; +const IN_709: usize = 1; +const OUT_709: usize = 1; +fn aiur_fn_709( + inp: [G; IN_709], record: &mut QueryRecord, io_buffer: &mut IOBuffer, unconstrained: bool, -) -> Result<[G; OUT_713], ExecError> { +) -> Result<[G; OUT_709], ExecError> { stacker::maybe_grow(64 * 1024, 4 * 1024 * 1024, || { let __v_0: G = inp[0]; let __loaded: [G; 32] = { let __mq = record.memory_queries.get_mut(&32).ok_or(ExecError::InvalidMemorySize(32))?; let __ptr_u64 = __v_0.as_canonical_u64(); let __ptr_usize = usize::try_from(__ptr_u64).ok().ok_or(ExecError::PointerTooLarge(__ptr_u64))?; let (__args, __mult) = __mq.get_index_mut(__ptr_usize).ok_or(ExecError::UnboundPointer { ptr: __ptr_u64, size: 32 })?; if !unconstrained { *__mult += G::ONE; } let __arr: [G; 32] = __args[..32].try_into().unwrap(); __arr }; @@ -59880,7 +59608,7 @@ fn aiur_fn_713( let __v_45: G = __r_arr[7]; let __v_46: G = __r_arr[8]; let __v_47: G = __r_arr[9]; - let __r_arr: [G; OUT_712] = { let __args: [G; IN_712] = [__v_47]; let __cu = unconstrained; if let Some(result) = record.function_queries[712].get_mut(&__args[..]) { if !__cu && *result.multiplicity == G::ZERO { aiur_fn_712(__args, record, io_buffer, false)? } else { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_712] = unsafe { *(result.output.as_ptr() as *const [G; OUT_712]) }; __ret } } else { aiur_fn_712(__args, record, io_buffer, __cu)? } }; + let __r_arr: [G; OUT_708] = { let __args: [G; IN_708] = [__v_47]; let __cu = unconstrained; if let Some(result) = record.function_queries[708].get_mut(&__args[..]) { if !__cu && *result.multiplicity == G::ZERO { aiur_fn_708(__args, record, io_buffer, false)? } else { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_708] = unsafe { *(result.output.as_ptr() as *const [G; OUT_708]) }; __ret } } else { aiur_fn_708(__args, record, io_buffer, __cu)? } }; let __v_48: G = __r_arr[0]; let __v_49: G = __r_arr[1]; let __v_50: G = __r_arr[2]; @@ -60036,21 +59764,21 @@ fn aiur_fn_713( if (__v_82 != __v_32) { return Err(ExecError::AssertEqMismatch { lhs: __v_82.as_canonical_u64(), rhs: __v_32.as_canonical_u64(), msg: Some("assumption tree: recomputed merkle root != requested root".to_string()) }); } - let __ret: [G; OUT_713] = [__v_49]; - if let Some(result) = record.function_queries[713].get_mut(&inp[..]) { debug_assert_eq!(result.output, &__ret[..]); if !unconstrained { *result.multiplicity += G::ONE; } } else { record.function_queries[713].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained)); }; + let __ret: [G; OUT_709] = [__v_49]; + if let Some(result) = record.function_queries[709].get_mut(&inp[..]) { debug_assert_eq!(result.output, &__ret[..]); if !unconstrained { *result.multiplicity += G::ONE; } } else { record.function_queries[709].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained)); }; return Ok(__ret); }) } -const INPUT_SIZE_714: usize = 7; -const IN_714: usize = 7; -const OUT_714: usize = 6; -fn aiur_fn_714( - inp: [G; IN_714], +const INPUT_SIZE_710: usize = 7; +const IN_710: usize = 7; +const OUT_710: usize = 6; +fn aiur_fn_710( + inp: [G; IN_710], record: &mut QueryRecord, io_buffer: &mut IOBuffer, unconstrained: bool, -) -> Result<[G; OUT_714], ExecError> { +) -> Result<[G; OUT_710], ExecError> { stacker::maybe_grow(64 * 1024, 4 * 1024 * 1024, || { let __v_0: G = inp[0]; let __v_1: G = inp[1]; @@ -60065,28 +59793,28 @@ fn aiur_fn_714( let __v_9: G = __loaded[2]; match __v_7.as_canonical_u64() { 1u64 => { - let __ret: [G; OUT_714] = [__v_1, __v_2, __v_3, __v_4, __v_5, __v_6]; - if let Some(result) = record.function_queries[714].get_mut(&inp[..]) { debug_assert_eq!(result.output, &__ret[..]); if !unconstrained { *result.multiplicity += G::ONE; } } else { record.function_queries[714].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained)); }; + let __ret: [G; OUT_710] = [__v_1, __v_2, __v_3, __v_4, __v_5, __v_6]; + if let Some(result) = record.function_queries[710].get_mut(&inp[..]) { debug_assert_eq!(result.output, &__ret[..]); if !unconstrained { *result.multiplicity += G::ONE; } } else { record.function_queries[710].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained)); }; return Ok(__ret); }, 0u64 => { let __v_10: G = G::from_u64(1); - let __r_arr: [G; OUT_777] = { let __args: [G; IN_777] = [__v_8, __v_10, __v_1, __v_2, __v_3, __v_4, __v_5, __v_6]; let __cu = unconstrained; if let Some(result) = record.function_queries[777].get_mut(&__args[..]) { if !__cu && *result.multiplicity == G::ZERO { aiur_fn_777(__args, record, io_buffer, false)? } else { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_777] = unsafe { *(result.output.as_ptr() as *const [G; OUT_777]) }; __ret } } else { aiur_fn_777(__args, record, io_buffer, __cu)? } }; + let __r_arr: [G; OUT_773] = { let __args: [G; IN_773] = [__v_8, __v_10, __v_1, __v_2, __v_3, __v_4, __v_5, __v_6]; let __cu = unconstrained; if let Some(result) = record.function_queries[773].get_mut(&__args[..]) { if !__cu && *result.multiplicity == G::ZERO { aiur_fn_773(__args, record, io_buffer, false)? } else { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_773] = unsafe { *(result.output.as_ptr() as *const [G; OUT_773]) }; __ret } } else { aiur_fn_773(__args, record, io_buffer, __cu)? } }; let __v_11: G = __r_arr[0]; let __v_12: G = __r_arr[1]; let __v_13: G = __r_arr[2]; let __v_14: G = __r_arr[3]; let __v_15: G = __r_arr[4]; let __v_16: G = __r_arr[5]; - let __r_arr: [G; OUT_714] = { let __args: [G; IN_714] = [__v_9, __v_11, __v_12, __v_13, __v_14, __v_15, __v_16]; let __cu = unconstrained; if let Some(result) = record.function_queries[714].get_mut(&__args[..]) { if !__cu && *result.multiplicity == G::ZERO { aiur_fn_714(__args, record, io_buffer, false)? } else { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_714] = unsafe { *(result.output.as_ptr() as *const [G; OUT_714]) }; __ret } } else { aiur_fn_714(__args, record, io_buffer, __cu)? } }; + let __r_arr: [G; OUT_710] = { let __args: [G; IN_710] = [__v_9, __v_11, __v_12, __v_13, __v_14, __v_15, __v_16]; let __cu = unconstrained; if let Some(result) = record.function_queries[710].get_mut(&__args[..]) { if !__cu && *result.multiplicity == G::ZERO { aiur_fn_710(__args, record, io_buffer, false)? } else { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_710] = unsafe { *(result.output.as_ptr() as *const [G; OUT_710]) }; __ret } } else { aiur_fn_710(__args, record, io_buffer, __cu)? } }; let __v_17: G = __r_arr[0]; let __v_18: G = __r_arr[1]; let __v_19: G = __r_arr[2]; let __v_20: G = __r_arr[3]; let __v_21: G = __r_arr[4]; let __v_22: G = __r_arr[5]; - let __ret: [G; OUT_714] = [__v_17, __v_18, __v_19, __v_20, __v_21, __v_22]; - if let Some(result) = record.function_queries[714].get_mut(&inp[..]) { debug_assert_eq!(result.output, &__ret[..]); if !unconstrained { *result.multiplicity += G::ONE; } } else { record.function_queries[714].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained)); }; + let __ret: [G; OUT_710] = [__v_17, __v_18, __v_19, __v_20, __v_21, __v_22]; + if let Some(result) = record.function_queries[710].get_mut(&inp[..]) { debug_assert_eq!(result.output, &__ret[..]); if !unconstrained { *result.multiplicity += G::ONE; } } else { record.function_queries[710].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained)); }; return Ok(__ret); }, _ => { @@ -60096,15 +59824,15 @@ fn aiur_fn_714( }) } -const INPUT_SIZE_715: usize = 7; -const IN_715: usize = 7; -const OUT_715: usize = 1; -fn aiur_fn_715( - inp: [G; IN_715], +const INPUT_SIZE_711: usize = 7; +const IN_711: usize = 7; +const OUT_711: usize = 1; +fn aiur_fn_711( + inp: [G; IN_711], record: &mut QueryRecord, io_buffer: &mut IOBuffer, unconstrained: bool, -) -> Result<[G; OUT_715], ExecError> { +) -> Result<[G; OUT_711], ExecError> { stacker::maybe_grow(64 * 1024, 4 * 1024 * 1024, || { let __v_0: G = inp[0]; let __v_1: G = inp[1]; @@ -60114,23 +59842,23 @@ fn aiur_fn_715( let __v_5: G = inp[5]; let __v_6: G = inp[6]; let __v_7: G = G::from_u64(0); - let __r_arr: [G; OUT_761] = { let __args: [G; IN_761] = [__v_0, __v_1, __v_2, __v_3, __v_4, __v_5, __v_6, __v_7]; let __cu = unconstrained; if let Some(result) = record.function_queries[761].get_mut(&__args[..]) { if !__cu && *result.multiplicity == G::ZERO { aiur_fn_761(__args, record, io_buffer, false)? } else { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_761] = unsafe { *(result.output.as_ptr() as *const [G; OUT_761]) }; __ret } } else { aiur_fn_761(__args, record, io_buffer, __cu)? } }; + let __r_arr: [G; OUT_757] = { let __args: [G; IN_757] = [__v_0, __v_1, __v_2, __v_3, __v_4, __v_5, __v_6, __v_7]; let __cu = unconstrained; if let Some(result) = record.function_queries[757].get_mut(&__args[..]) { if !__cu && *result.multiplicity == G::ZERO { aiur_fn_757(__args, record, io_buffer, false)? } else { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_757] = unsafe { *(result.output.as_ptr() as *const [G; OUT_757]) }; __ret } } else { aiur_fn_757(__args, record, io_buffer, __cu)? } }; let __v_8: G = __r_arr[0]; - let __ret: [G; OUT_715] = [__v_8]; - if let Some(result) = record.function_queries[715].get_mut(&inp[..]) { debug_assert_eq!(result.output, &__ret[..]); if !unconstrained { *result.multiplicity += G::ONE; } } else { record.function_queries[715].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained)); }; + let __ret: [G; OUT_711] = [__v_8]; + if let Some(result) = record.function_queries[711].get_mut(&inp[..]) { debug_assert_eq!(result.output, &__ret[..]); if !unconstrained { *result.multiplicity += G::ONE; } } else { record.function_queries[711].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained)); }; return Ok(__ret); }) } -const INPUT_SIZE_716: usize = 14; -const IN_716: usize = 14; -const OUT_716: usize = 0; -fn aiur_fn_716( - inp: [G; IN_716], +const INPUT_SIZE_712: usize = 14; +const IN_712: usize = 14; +const OUT_712: usize = 0; +fn aiur_fn_712( + inp: [G; IN_712], record: &mut QueryRecord, io_buffer: &mut IOBuffer, unconstrained: bool, -) -> Result<[G; OUT_716], ExecError> { +) -> Result<[G; OUT_712], ExecError> { stacker::maybe_grow(64 * 1024, 4 * 1024 * 1024, || { let __v_0: G = inp[0]; let __v_1: G = inp[1]; @@ -60146,18 +59874,18 @@ fn aiur_fn_716( let __v_11: G = inp[11]; let __v_12: G = inp[12]; let __v_13: G = inp[13]; - let __r_arr: [G; OUT_715] = { let __args: [G; IN_715] = [__v_0, __v_7, __v_8, __v_9, __v_10, __v_11, __v_12]; let __cu = unconstrained; if let Some(result) = record.function_queries[715].get_mut(&__args[..]) { if !__cu && *result.multiplicity == G::ZERO { aiur_fn_715(__args, record, io_buffer, false)? } else { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_715] = unsafe { *(result.output.as_ptr() as *const [G; OUT_715]) }; __ret } } else { aiur_fn_715(__args, record, io_buffer, __cu)? } }; + let __r_arr: [G; OUT_711] = { let __args: [G; IN_711] = [__v_0, __v_7, __v_8, __v_9, __v_10, __v_11, __v_12]; let __cu = unconstrained; if let Some(result) = record.function_queries[711].get_mut(&__args[..]) { if !__cu && *result.multiplicity == G::ZERO { aiur_fn_711(__args, record, io_buffer, false)? } else { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_711] = unsafe { *(result.output.as_ptr() as *const [G; OUT_711]) }; __ret } } else { aiur_fn_711(__args, record, io_buffer, __cu)? } }; let __v_14: G = __r_arr[0]; match __v_14.as_canonical_u64() { 1u64 => { - let __ret: [G; OUT_716] = []; - if let Some(result) = record.function_queries[716].get_mut(&inp[..]) { debug_assert_eq!(result.output, &__ret[..]); if !unconstrained { *result.multiplicity += G::ONE; } } else { record.function_queries[716].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained)); }; + let __ret: [G; OUT_712] = []; + if let Some(result) = record.function_queries[712].get_mut(&inp[..]) { debug_assert_eq!(result.output, &__ret[..]); if !unconstrained { *result.multiplicity += G::ONE; } } else { record.function_queries[712].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained)); }; return Ok(__ret); }, _ => { let __mc_out___mc_0: [G; 0] = '__mc_0: { match __v_13.as_canonical_u64() { 1u64 => { - let __r_arr: [G; OUT_715] = { let __args: [G; IN_715] = [__v_0, __v_1, __v_2, __v_3, __v_4, __v_5, __v_6]; let __cu = unconstrained; if let Some(result) = record.function_queries[715].get_mut(&__args[..]) { if !__cu && *result.multiplicity == G::ZERO { aiur_fn_715(__args, record, io_buffer, false)? } else { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_715] = unsafe { *(result.output.as_ptr() as *const [G; OUT_715]) }; __ret } } else { aiur_fn_715(__args, record, io_buffer, __cu)? } }; + let __r_arr: [G; OUT_711] = { let __args: [G; IN_711] = [__v_0, __v_1, __v_2, __v_3, __v_4, __v_5, __v_6]; let __cu = unconstrained; if let Some(result) = record.function_queries[711].get_mut(&__args[..]) { if !__cu && *result.multiplicity == G::ZERO { aiur_fn_711(__args, record, io_buffer, false)? } else { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_711] = unsafe { *(result.output.as_ptr() as *const [G; OUT_711]) }; __ret } } else { aiur_fn_711(__args, record, io_buffer, __cu)? } }; let __v_15: G = __r_arr[0]; let __v_16: G = G::from_u64(1); if (__v_15 != __v_16) { @@ -60170,7 +59898,7 @@ fn aiur_fn_716( }, } }; - let __r_arr: [G; OUT_282] = { let __args: [G; IN_282] = [__v_0]; let __cu = unconstrained; if let Some(result) = record.function_queries[282].get_mut(&__args[..]) { if !__cu && *result.multiplicity == G::ZERO { aiur_fn_282(__args, record, io_buffer, false)? } else { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_282] = unsafe { *(result.output.as_ptr() as *const [G; OUT_282]) }; __ret } } else { aiur_fn_282(__args, record, io_buffer, __cu)? } }; + let __r_arr: [G; OUT_278] = { let __args: [G; IN_278] = [__v_0]; let __cu = unconstrained; if let Some(result) = record.function_queries[278].get_mut(&__args[..]) { if !__cu && *result.multiplicity == G::ZERO { aiur_fn_278(__args, record, io_buffer, false)? } else { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_278] = unsafe { *(result.output.as_ptr() as *const [G; OUT_278]) }; __ret } } else { aiur_fn_278(__args, record, io_buffer, __cu)? } }; let __v_15: G = __r_arr[0]; let __v_16: G = __r_arr[1]; let __v_17: G = __r_arr[2]; @@ -60224,14 +59952,14 @@ fn aiur_fn_716( let __mc_out___mc_1: [G; 0] = '__mc_1: { match __v_15.as_canonical_u64() { 8u64 => { let __v_63: G = G::from_u64(0); - let __r_arr: [G; OUT_708] = { let __args: [G; IN_708] = [__v_0, __v_16, __v_16, __v_63]; let __cu = unconstrained; if let Some(result) = record.function_queries[708].get_mut(&__args[..]) { if !__cu && *result.multiplicity == G::ZERO { aiur_fn_708(__args, record, io_buffer, false)? } else { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_708] = unsafe { *(result.output.as_ptr() as *const [G; OUT_708]) }; __ret } } else { aiur_fn_708(__args, record, io_buffer, __cu)? } }; + let __r_arr: [G; OUT_704] = { let __args: [G; IN_704] = [__v_0, __v_16, __v_16, __v_63]; let __cu = unconstrained; if let Some(result) = record.function_queries[704].get_mut(&__args[..]) { if !__cu && *result.multiplicity == G::ZERO { aiur_fn_704(__args, record, io_buffer, false)? } else { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_704] = unsafe { *(result.output.as_ptr() as *const [G; OUT_704]) }; __ret } } else { aiur_fn_704(__args, record, io_buffer, __cu)? } }; break '__mc_1 []; }, 7u64 => { match __v_16.as_canonical_u64() { _ => { - let __r_arr: [G; OUT_698] = { let __args: [G; IN_698] = [__v_0]; let __cu = unconstrained; if let Some(result) = record.function_queries[698].get_mut(&__args[..]) { if !__cu && *result.multiplicity == G::ZERO { aiur_fn_698(__args, record, io_buffer, false)? } else { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_698] = unsafe { *(result.output.as_ptr() as *const [G; OUT_698]) }; __ret } } else { aiur_fn_698(__args, record, io_buffer, __cu)? } }; - let __r_arr: [G; OUT_716] = { let __args: [G; IN_716] = [__v_24, __v_1, __v_2, __v_3, __v_4, __v_5, __v_6, __v_7, __v_8, __v_9, __v_10, __v_11, __v_12, __v_13]; let __cu = unconstrained; if let Some(result) = record.function_queries[716].get_mut(&__args[..]) { if !__cu && *result.multiplicity == G::ZERO { aiur_fn_716(__args, record, io_buffer, false)? } else { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_716] = unsafe { *(result.output.as_ptr() as *const [G; OUT_716]) }; __ret } } else { aiur_fn_716(__args, record, io_buffer, __cu)? } }; + let __r_arr: [G; OUT_694] = { let __args: [G; IN_694] = [__v_0]; let __cu = unconstrained; if let Some(result) = record.function_queries[694].get_mut(&__args[..]) { if !__cu && *result.multiplicity == G::ZERO { aiur_fn_694(__args, record, io_buffer, false)? } else { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_694] = unsafe { *(result.output.as_ptr() as *const [G; OUT_694]) }; __ret } } else { aiur_fn_694(__args, record, io_buffer, __cu)? } }; + let __r_arr: [G; OUT_712] = { let __args: [G; IN_712] = [__v_24, __v_1, __v_2, __v_3, __v_4, __v_5, __v_6, __v_7, __v_8, __v_9, __v_10, __v_11, __v_12, __v_13]; let __cu = unconstrained; if let Some(result) = record.function_queries[712].get_mut(&__args[..]) { if !__cu && *result.multiplicity == G::ZERO { aiur_fn_712(__args, record, io_buffer, false)? } else { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_712] = unsafe { *(result.output.as_ptr() as *const [G; OUT_712]) }; __ret } } else { aiur_fn_712(__args, record, io_buffer, __cu)? } }; break '__mc_1 []; }, } @@ -60239,8 +59967,8 @@ fn aiur_fn_716( 6u64 => { match __v_16.as_canonical_u64() { _ => { - let __r_arr: [G; OUT_698] = { let __args: [G; IN_698] = [__v_0]; let __cu = unconstrained; if let Some(result) = record.function_queries[698].get_mut(&__args[..]) { if !__cu && *result.multiplicity == G::ZERO { aiur_fn_698(__args, record, io_buffer, false)? } else { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_698] = unsafe { *(result.output.as_ptr() as *const [G; OUT_698]) }; __ret } } else { aiur_fn_698(__args, record, io_buffer, __cu)? } }; - let __r_arr: [G; OUT_716] = { let __args: [G; IN_716] = [__v_24, __v_1, __v_2, __v_3, __v_4, __v_5, __v_6, __v_7, __v_8, __v_9, __v_10, __v_11, __v_12, __v_13]; let __cu = unconstrained; if let Some(result) = record.function_queries[716].get_mut(&__args[..]) { if !__cu && *result.multiplicity == G::ZERO { aiur_fn_716(__args, record, io_buffer, false)? } else { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_716] = unsafe { *(result.output.as_ptr() as *const [G; OUT_716]) }; __ret } } else { aiur_fn_716(__args, record, io_buffer, __cu)? } }; + let __r_arr: [G; OUT_694] = { let __args: [G; IN_694] = [__v_0]; let __cu = unconstrained; if let Some(result) = record.function_queries[694].get_mut(&__args[..]) { if !__cu && *result.multiplicity == G::ZERO { aiur_fn_694(__args, record, io_buffer, false)? } else { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_694] = unsafe { *(result.output.as_ptr() as *const [G; OUT_694]) }; __ret } } else { aiur_fn_694(__args, record, io_buffer, __cu)? } }; + let __r_arr: [G; OUT_712] = { let __args: [G; IN_712] = [__v_24, __v_1, __v_2, __v_3, __v_4, __v_5, __v_6, __v_7, __v_8, __v_9, __v_10, __v_11, __v_12, __v_13]; let __cu = unconstrained; if let Some(result) = record.function_queries[712].get_mut(&__args[..]) { if !__cu && *result.multiplicity == G::ZERO { aiur_fn_712(__args, record, io_buffer, false)? } else { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_712] = unsafe { *(result.output.as_ptr() as *const [G; OUT_712]) }; __ret } } else { aiur_fn_712(__args, record, io_buffer, __cu)? } }; break '__mc_1 []; }, } @@ -60248,8 +59976,8 @@ fn aiur_fn_716( 4u64 => { match __v_16.as_canonical_u64() { _ => { - let __r_arr: [G; OUT_698] = { let __args: [G; IN_698] = [__v_0]; let __cu = unconstrained; if let Some(result) = record.function_queries[698].get_mut(&__args[..]) { if !__cu && *result.multiplicity == G::ZERO { aiur_fn_698(__args, record, io_buffer, false)? } else { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_698] = unsafe { *(result.output.as_ptr() as *const [G; OUT_698]) }; __ret } } else { aiur_fn_698(__args, record, io_buffer, __cu)? } }; - let __r_arr: [G; OUT_716] = { let __args: [G; IN_716] = [__v_32, __v_1, __v_2, __v_3, __v_4, __v_5, __v_6, __v_7, __v_8, __v_9, __v_10, __v_11, __v_12, __v_13]; let __cu = unconstrained; if let Some(result) = record.function_queries[716].get_mut(&__args[..]) { if !__cu && *result.multiplicity == G::ZERO { aiur_fn_716(__args, record, io_buffer, false)? } else { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_716] = unsafe { *(result.output.as_ptr() as *const [G; OUT_716]) }; __ret } } else { aiur_fn_716(__args, record, io_buffer, __cu)? } }; + let __r_arr: [G; OUT_694] = { let __args: [G; IN_694] = [__v_0]; let __cu = unconstrained; if let Some(result) = record.function_queries[694].get_mut(&__args[..]) { if !__cu && *result.multiplicity == G::ZERO { aiur_fn_694(__args, record, io_buffer, false)? } else { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_694] = unsafe { *(result.output.as_ptr() as *const [G; OUT_694]) }; __ret } } else { aiur_fn_694(__args, record, io_buffer, __cu)? } }; + let __r_arr: [G; OUT_712] = { let __args: [G; IN_712] = [__v_32, __v_1, __v_2, __v_3, __v_4, __v_5, __v_6, __v_7, __v_8, __v_9, __v_10, __v_11, __v_12, __v_13]; let __cu = unconstrained; if let Some(result) = record.function_queries[712].get_mut(&__args[..]) { if !__cu && *result.multiplicity == G::ZERO { aiur_fn_712(__args, record, io_buffer, false)? } else { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_712] = unsafe { *(result.output.as_ptr() as *const [G; OUT_712]) }; __ret } } else { aiur_fn_712(__args, record, io_buffer, __cu)? } }; break '__mc_1 []; }, } @@ -60257,24 +59985,24 @@ fn aiur_fn_716( 5u64 => { match __v_16.as_canonical_u64() { _ => { - let __r_arr: [G; OUT_698] = { let __args: [G; IN_698] = [__v_0]; let __cu = unconstrained; if let Some(result) = record.function_queries[698].get_mut(&__args[..]) { if !__cu && *result.multiplicity == G::ZERO { aiur_fn_698(__args, record, io_buffer, false)? } else { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_698] = unsafe { *(result.output.as_ptr() as *const [G; OUT_698]) }; __ret } } else { aiur_fn_698(__args, record, io_buffer, __cu)? } }; - let __r_arr: [G; OUT_716] = { let __args: [G; IN_716] = [__v_24, __v_1, __v_2, __v_3, __v_4, __v_5, __v_6, __v_7, __v_8, __v_9, __v_10, __v_11, __v_12, __v_13]; let __cu = unconstrained; if let Some(result) = record.function_queries[716].get_mut(&__args[..]) { if !__cu && *result.multiplicity == G::ZERO { aiur_fn_716(__args, record, io_buffer, false)? } else { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_716] = unsafe { *(result.output.as_ptr() as *const [G; OUT_716]) }; __ret } } else { aiur_fn_716(__args, record, io_buffer, __cu)? } }; + let __r_arr: [G; OUT_694] = { let __args: [G; IN_694] = [__v_0]; let __cu = unconstrained; if let Some(result) = record.function_queries[694].get_mut(&__args[..]) { if !__cu && *result.multiplicity == G::ZERO { aiur_fn_694(__args, record, io_buffer, false)? } else { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_694] = unsafe { *(result.output.as_ptr() as *const [G; OUT_694]) }; __ret } } else { aiur_fn_694(__args, record, io_buffer, __cu)? } }; + let __r_arr: [G; OUT_712] = { let __args: [G; IN_712] = [__v_24, __v_1, __v_2, __v_3, __v_4, __v_5, __v_6, __v_7, __v_8, __v_9, __v_10, __v_11, __v_12, __v_13]; let __cu = unconstrained; if let Some(result) = record.function_queries[712].get_mut(&__args[..]) { if !__cu && *result.multiplicity == G::ZERO { aiur_fn_712(__args, record, io_buffer, false)? } else { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_712] = unsafe { *(result.output.as_ptr() as *const [G; OUT_712]) }; __ret } } else { aiur_fn_712(__args, record, io_buffer, __cu)? } }; break '__mc_1 []; }, } }, _ => { - let __r_arr: [G; OUT_698] = { let __args: [G; IN_698] = [__v_0]; let __cu = unconstrained; if let Some(result) = record.function_queries[698].get_mut(&__args[..]) { if !__cu && *result.multiplicity == G::ZERO { aiur_fn_698(__args, record, io_buffer, false)? } else { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_698] = unsafe { *(result.output.as_ptr() as *const [G; OUT_698]) }; __ret } } else { aiur_fn_698(__args, record, io_buffer, __cu)? } }; + let __r_arr: [G; OUT_694] = { let __args: [G; IN_694] = [__v_0]; let __cu = unconstrained; if let Some(result) = record.function_queries[694].get_mut(&__args[..]) { if !__cu && *result.multiplicity == G::ZERO { aiur_fn_694(__args, record, io_buffer, false)? } else { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_694] = unsafe { *(result.output.as_ptr() as *const [G; OUT_694]) }; __ret } } else { aiur_fn_694(__args, record, io_buffer, __cu)? } }; break '__mc_1 []; }, } }; - let __r_arr: [G; OUT_704] = { let __args: [G; IN_704] = [__v_15, __v_16, __v_17, __v_18, __v_19, __v_20, __v_21, __v_22, __v_23, __v_24, __v_25, __v_26, __v_27, __v_28, __v_29, __v_30, __v_31, __v_32, __v_33, __v_34, __v_35, __v_36, __v_37, __v_38, __v_39, __v_40, __v_41, __v_42, __v_43, __v_44, __v_45, __v_46, __v_47, __v_48, __v_49, __v_50, __v_51, __v_52, __v_53, __v_54, __v_55, __v_56, __v_57, __v_58, __v_59, __v_60, __v_61, __v_62]; let __cu = unconstrained; if let Some(result) = record.function_queries[704].get_mut(&__args[..]) { if !__cu && *result.multiplicity == G::ZERO { aiur_fn_704(__args, record, io_buffer, false)? } else { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_704] = unsafe { *(result.output.as_ptr() as *const [G; OUT_704]) }; __ret } } else { aiur_fn_704(__args, record, io_buffer, __cu)? } }; + let __r_arr: [G; OUT_700] = { let __args: [G; IN_700] = [__v_15, __v_16, __v_17, __v_18, __v_19, __v_20, __v_21, __v_22, __v_23, __v_24, __v_25, __v_26, __v_27, __v_28, __v_29, __v_30, __v_31, __v_32, __v_33, __v_34, __v_35, __v_36, __v_37, __v_38, __v_39, __v_40, __v_41, __v_42, __v_43, __v_44, __v_45, __v_46, __v_47, __v_48, __v_49, __v_50, __v_51, __v_52, __v_53, __v_54, __v_55, __v_56, __v_57, __v_58, __v_59, __v_60, __v_61, __v_62]; let __cu = unconstrained; if let Some(result) = record.function_queries[700].get_mut(&__args[..]) { if !__cu && *result.multiplicity == G::ZERO { aiur_fn_700(__args, record, io_buffer, false)? } else { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_700] = unsafe { *(result.output.as_ptr() as *const [G; OUT_700]) }; __ret } } else { aiur_fn_700(__args, record, io_buffer, __cu)? } }; let __v_63: G = __r_arr[0]; let __v_64: G = G::from_u64(0); - let __r_arr: [G; OUT_717] = { let __args: [G; IN_717] = [__v_61, __v_63, __v_64, __v_1, __v_2, __v_3, __v_4, __v_5, __v_6, __v_7, __v_8, __v_9, __v_10, __v_11, __v_12, __v_13]; let __cu = unconstrained; if let Some(result) = record.function_queries[717].get_mut(&__args[..]) { if !__cu && *result.multiplicity == G::ZERO { aiur_fn_717(__args, record, io_buffer, false)? } else { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_717] = unsafe { *(result.output.as_ptr() as *const [G; OUT_717]) }; __ret } } else { aiur_fn_717(__args, record, io_buffer, __cu)? } }; - let __ret: [G; OUT_716] = []; - if let Some(result) = record.function_queries[716].get_mut(&inp[..]) { debug_assert_eq!(result.output, &__ret[..]); if !unconstrained { *result.multiplicity += G::ONE; } } else { record.function_queries[716].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained)); }; + let __r_arr: [G; OUT_713] = { let __args: [G; IN_713] = [__v_61, __v_63, __v_64, __v_1, __v_2, __v_3, __v_4, __v_5, __v_6, __v_7, __v_8, __v_9, __v_10, __v_11, __v_12, __v_13]; let __cu = unconstrained; if let Some(result) = record.function_queries[713].get_mut(&__args[..]) { if !__cu && *result.multiplicity == G::ZERO { aiur_fn_713(__args, record, io_buffer, false)? } else { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_713] = unsafe { *(result.output.as_ptr() as *const [G; OUT_713]) }; __ret } } else { aiur_fn_713(__args, record, io_buffer, __cu)? } }; + let __ret: [G; OUT_712] = []; + if let Some(result) = record.function_queries[712].get_mut(&inp[..]) { debug_assert_eq!(result.output, &__ret[..]); if !unconstrained { *result.multiplicity += G::ONE; } } else { record.function_queries[712].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained)); }; return Ok(__ret); }, } @@ -60283,15 +60011,15 @@ fn aiur_fn_716( }) } -const INPUT_SIZE_717: usize = 16; -const IN_717: usize = 16; -const OUT_717: usize = 0; -fn aiur_fn_717( - inp: [G; IN_717], +const INPUT_SIZE_713: usize = 16; +const IN_713: usize = 16; +const OUT_713: usize = 0; +fn aiur_fn_713( + inp: [G; IN_713], record: &mut QueryRecord, io_buffer: &mut IOBuffer, unconstrained: bool, -) -> Result<[G; OUT_717], ExecError> { +) -> Result<[G; OUT_713], ExecError> { stacker::maybe_grow(64 * 1024, 4 * 1024 * 1024, || { let __v_0: G = inp[0]; let __v_1: G = inp[1]; @@ -60315,16 +60043,16 @@ fn aiur_fn_717( let __v_18: G = __loaded[2]; match __v_16.as_canonical_u64() { 1u64 => { - let __ret: [G; OUT_717] = []; - if let Some(result) = record.function_queries[717].get_mut(&inp[..]) { debug_assert_eq!(result.output, &__ret[..]); if !unconstrained { *result.multiplicity += G::ONE; } } else { record.function_queries[717].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained)); }; + let __ret: [G; OUT_713] = []; + if let Some(result) = record.function_queries[713].get_mut(&inp[..]) { debug_assert_eq!(result.output, &__ret[..]); if !unconstrained { *result.multiplicity += G::ONE; } } else { record.function_queries[713].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained)); }; return Ok(__ret); }, 0u64 => { - let __r_arr: [G; OUT_705] = { let __args: [G; IN_705] = [__v_1, __v_2]; let __cu = unconstrained; if let Some(result) = record.function_queries[705].get_mut(&__args[..]) { if !__cu && *result.multiplicity == G::ZERO { aiur_fn_705(__args, record, io_buffer, false)? } else { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_705] = unsafe { *(result.output.as_ptr() as *const [G; OUT_705]) }; __ret } } else { aiur_fn_705(__args, record, io_buffer, __cu)? } }; + let __r_arr: [G; OUT_701] = { let __args: [G; IN_701] = [__v_1, __v_2]; let __cu = unconstrained; if let Some(result) = record.function_queries[701].get_mut(&__args[..]) { if !__cu && *result.multiplicity == G::ZERO { aiur_fn_701(__args, record, io_buffer, false)? } else { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_701] = unsafe { *(result.output.as_ptr() as *const [G; OUT_701]) }; __ret } } else { aiur_fn_701(__args, record, io_buffer, __cu)? } }; let __v_19: G = __r_arr[0]; let __mc_out___mc_0: [G; 0] = '__mc_0: { match __v_19.as_canonical_u64() { 1u64 => { - let __r_arr: [G; OUT_716] = { let __args: [G; IN_716] = [__v_17, __v_3, __v_4, __v_5, __v_6, __v_7, __v_8, __v_9, __v_10, __v_11, __v_12, __v_13, __v_14, __v_15]; let __cu = unconstrained; if let Some(result) = record.function_queries[716].get_mut(&__args[..]) { if !__cu && *result.multiplicity == G::ZERO { aiur_fn_716(__args, record, io_buffer, false)? } else { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_716] = unsafe { *(result.output.as_ptr() as *const [G; OUT_716]) }; __ret } } else { aiur_fn_716(__args, record, io_buffer, __cu)? } }; + let __r_arr: [G; OUT_712] = { let __args: [G; IN_712] = [__v_17, __v_3, __v_4, __v_5, __v_6, __v_7, __v_8, __v_9, __v_10, __v_11, __v_12, __v_13, __v_14, __v_15]; let __cu = unconstrained; if let Some(result) = record.function_queries[712].get_mut(&__args[..]) { if !__cu && *result.multiplicity == G::ZERO { aiur_fn_712(__args, record, io_buffer, false)? } else { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_712] = unsafe { *(result.output.as_ptr() as *const [G; OUT_712]) }; __ret } } else { aiur_fn_712(__args, record, io_buffer, __cu)? } }; break '__mc_0 []; }, _ => { @@ -60334,9 +60062,9 @@ fn aiur_fn_717( }; let __v_20: G = G::from_u64(1); let __v_21: G = (__v_2 + __v_20); - let __r_arr: [G; OUT_717] = { let __args: [G; IN_717] = [__v_18, __v_1, __v_21, __v_3, __v_4, __v_5, __v_6, __v_7, __v_8, __v_9, __v_10, __v_11, __v_12, __v_13, __v_14, __v_15]; let __cu = unconstrained; if let Some(result) = record.function_queries[717].get_mut(&__args[..]) { if !__cu && *result.multiplicity == G::ZERO { aiur_fn_717(__args, record, io_buffer, false)? } else { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_717] = unsafe { *(result.output.as_ptr() as *const [G; OUT_717]) }; __ret } } else { aiur_fn_717(__args, record, io_buffer, __cu)? } }; - let __ret: [G; OUT_717] = []; - if let Some(result) = record.function_queries[717].get_mut(&inp[..]) { debug_assert_eq!(result.output, &__ret[..]); if !unconstrained { *result.multiplicity += G::ONE; } } else { record.function_queries[717].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained)); }; + let __r_arr: [G; OUT_713] = { let __args: [G; IN_713] = [__v_18, __v_1, __v_21, __v_3, __v_4, __v_5, __v_6, __v_7, __v_8, __v_9, __v_10, __v_11, __v_12, __v_13, __v_14, __v_15]; let __cu = unconstrained; if let Some(result) = record.function_queries[713].get_mut(&__args[..]) { if !__cu && *result.multiplicity == G::ZERO { aiur_fn_713(__args, record, io_buffer, false)? } else { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_713] = unsafe { *(result.output.as_ptr() as *const [G; OUT_713]) }; __ret } } else { aiur_fn_713(__args, record, io_buffer, __cu)? } }; + let __ret: [G; OUT_713] = []; + if let Some(result) = record.function_queries[713].get_mut(&inp[..]) { debug_assert_eq!(result.output, &__ret[..]); if !unconstrained { *result.multiplicity += G::ONE; } } else { record.function_queries[713].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained)); }; return Ok(__ret); }, _ => { @@ -60346,15 +60074,15 @@ fn aiur_fn_717( }) } -const INPUT_SIZE_718: usize = 13; -const IN_718: usize = 13; -const OUT_718: usize = 0; -fn aiur_fn_718( - inp: [G; IN_718], +const INPUT_SIZE_714: usize = 13; +const IN_714: usize = 13; +const OUT_714: usize = 0; +fn aiur_fn_714( + inp: [G; IN_714], record: &mut QueryRecord, io_buffer: &mut IOBuffer, unconstrained: bool, -) -> Result<[G; OUT_718], ExecError> { +) -> Result<[G; OUT_714], ExecError> { stacker::maybe_grow(64 * 1024, 4 * 1024 * 1024, || { let __v_0: G = inp[0]; let __v_1: G = inp[1]; @@ -60375,16 +60103,16 @@ fn aiur_fn_718( let __v_15: G = __loaded[2]; match __v_13.as_canonical_u64() { 1u64 => { - let __ret: [G; OUT_718] = []; - if let Some(result) = record.function_queries[718].get_mut(&inp[..]) { debug_assert_eq!(result.output, &__ret[..]); if !unconstrained { *result.multiplicity += G::ONE; } } else { record.function_queries[718].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained)); }; + let __ret: [G; OUT_714] = []; + if let Some(result) = record.function_queries[714].get_mut(&inp[..]) { debug_assert_eq!(result.output, &__ret[..]); if !unconstrained { *result.multiplicity += G::ONE; } } else { record.function_queries[714].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained)); }; return Ok(__ret); }, 0u64 => { let __v_16: G = G::from_u64(1); - let __r_arr: [G; OUT_716] = { let __args: [G; IN_716] = [__v_14, __v_1, __v_2, __v_3, __v_4, __v_5, __v_6, __v_7, __v_8, __v_9, __v_10, __v_11, __v_12, __v_16]; let __cu = unconstrained; if let Some(result) = record.function_queries[716].get_mut(&__args[..]) { if !__cu && *result.multiplicity == G::ZERO { aiur_fn_716(__args, record, io_buffer, false)? } else { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_716] = unsafe { *(result.output.as_ptr() as *const [G; OUT_716]) }; __ret } } else { aiur_fn_716(__args, record, io_buffer, __cu)? } }; - let __r_arr: [G; OUT_718] = { let __args: [G; IN_718] = [__v_15, __v_1, __v_2, __v_3, __v_4, __v_5, __v_6, __v_7, __v_8, __v_9, __v_10, __v_11, __v_12]; let __cu = unconstrained; if let Some(result) = record.function_queries[718].get_mut(&__args[..]) { if !__cu && *result.multiplicity == G::ZERO { aiur_fn_718(__args, record, io_buffer, false)? } else { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_718] = unsafe { *(result.output.as_ptr() as *const [G; OUT_718]) }; __ret } } else { aiur_fn_718(__args, record, io_buffer, __cu)? } }; - let __ret: [G; OUT_718] = []; - if let Some(result) = record.function_queries[718].get_mut(&inp[..]) { debug_assert_eq!(result.output, &__ret[..]); if !unconstrained { *result.multiplicity += G::ONE; } } else { record.function_queries[718].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained)); }; + let __r_arr: [G; OUT_712] = { let __args: [G; IN_712] = [__v_14, __v_1, __v_2, __v_3, __v_4, __v_5, __v_6, __v_7, __v_8, __v_9, __v_10, __v_11, __v_12, __v_16]; let __cu = unconstrained; if let Some(result) = record.function_queries[712].get_mut(&__args[..]) { if !__cu && *result.multiplicity == G::ZERO { aiur_fn_712(__args, record, io_buffer, false)? } else { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_712] = unsafe { *(result.output.as_ptr() as *const [G; OUT_712]) }; __ret } } else { aiur_fn_712(__args, record, io_buffer, __cu)? } }; + let __r_arr: [G; OUT_714] = { let __args: [G; IN_714] = [__v_15, __v_1, __v_2, __v_3, __v_4, __v_5, __v_6, __v_7, __v_8, __v_9, __v_10, __v_11, __v_12]; let __cu = unconstrained; if let Some(result) = record.function_queries[714].get_mut(&__args[..]) { if !__cu && *result.multiplicity == G::ZERO { aiur_fn_714(__args, record, io_buffer, false)? } else { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_714] = unsafe { *(result.output.as_ptr() as *const [G; OUT_714]) }; __ret } } else { aiur_fn_714(__args, record, io_buffer, __cu)? } }; + let __ret: [G; OUT_714] = []; + if let Some(result) = record.function_queries[714].get_mut(&inp[..]) { debug_assert_eq!(result.output, &__ret[..]); if !unconstrained { *result.multiplicity += G::ONE; } } else { record.function_queries[714].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained)); }; return Ok(__ret); }, _ => { @@ -60394,20 +60122,20 @@ fn aiur_fn_718( }) } -const INPUT_SIZE_719: usize = 3; -const IN_719: usize = 3; -const OUT_719: usize = 0; -fn aiur_fn_719( - inp: [G; IN_719], +const INPUT_SIZE_715: usize = 3; +const IN_715: usize = 3; +const OUT_715: usize = 0; +fn aiur_fn_715( + inp: [G; IN_715], record: &mut QueryRecord, io_buffer: &mut IOBuffer, unconstrained: bool, -) -> Result<[G; OUT_719], ExecError> { +) -> Result<[G; OUT_715], ExecError> { stacker::maybe_grow(64 * 1024, 4 * 1024 * 1024, || { let __v_0: G = inp[0]; let __v_1: G = inp[1]; let __v_2: G = inp[2]; - let __r_arr: [G; OUT_713] = { let __args: [G; IN_713] = [__v_0]; let __cu = unconstrained; if let Some(result) = record.function_queries[713].get_mut(&__args[..]) { if !__cu && *result.multiplicity == G::ZERO { aiur_fn_713(__args, record, io_buffer, false)? } else { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_713] = unsafe { *(result.output.as_ptr() as *const [G; OUT_713]) }; __ret } } else { aiur_fn_713(__args, record, io_buffer, __cu)? } }; + let __r_arr: [G; OUT_709] = { let __args: [G; IN_709] = [__v_0]; let __cu = unconstrained; if let Some(result) = record.function_queries[709].get_mut(&__args[..]) { if !__cu && *result.multiplicity == G::ZERO { aiur_fn_709(__args, record, io_buffer, false)? } else { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_709] = unsafe { *(result.output.as_ptr() as *const [G; OUT_709]) }; __ret } } else { aiur_fn_709(__args, record, io_buffer, __cu)? } }; let __v_3: G = __r_arr[0]; let __mc_out___mc_0: [G; 1] = '__mc_0: { match __v_1.as_canonical_u64() { 1u64 => { @@ -60417,7 +60145,7 @@ fn aiur_fn_719( break '__mc_0 [__v_6]; }, 0u64 => { - let __r_arr: [G; OUT_713] = { let __args: [G; IN_713] = [__v_2]; let __cu = unconstrained; if let Some(result) = record.function_queries[713].get_mut(&__args[..]) { if !__cu && *result.multiplicity == G::ZERO { aiur_fn_713(__args, record, io_buffer, false)? } else { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_713] = unsafe { *(result.output.as_ptr() as *const [G; OUT_713]) }; __ret } } else { aiur_fn_713(__args, record, io_buffer, __cu)? } }; + let __r_arr: [G; OUT_709] = { let __args: [G; IN_709] = [__v_2]; let __cu = unconstrained; if let Some(result) = record.function_queries[709].get_mut(&__args[..]) { if !__cu && *result.multiplicity == G::ZERO { aiur_fn_709(__args, record, io_buffer, false)? } else { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_709] = unsafe { *(result.output.as_ptr() as *const [G; OUT_709]) }; __ret } } else { aiur_fn_709(__args, record, io_buffer, __cu)? } }; let __v_4: G = __r_arr[0]; break '__mc_0 [__v_4]; }, @@ -60429,7 +60157,7 @@ fn aiur_fn_719( let __v_4: G = __mc_out___mc_0[0]; let __v_5: G = G::from_u64(1); let __v_6: G = G::from_u64(1); - let __r_arr: [G; OUT_714] = { let __args: [G; IN_714] = [__v_3, __v_5, __v_6, __v_6, __v_6, __v_6, __v_6]; let __cu = unconstrained; if let Some(result) = record.function_queries[714].get_mut(&__args[..]) { if !__cu && *result.multiplicity == G::ZERO { aiur_fn_714(__args, record, io_buffer, false)? } else { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_714] = unsafe { *(result.output.as_ptr() as *const [G; OUT_714]) }; __ret } } else { aiur_fn_714(__args, record, io_buffer, __cu)? } }; + let __r_arr: [G; OUT_710] = { let __args: [G; IN_710] = [__v_3, __v_5, __v_6, __v_6, __v_6, __v_6, __v_6]; let __cu = unconstrained; if let Some(result) = record.function_queries[710].get_mut(&__args[..]) { if !__cu && *result.multiplicity == G::ZERO { aiur_fn_710(__args, record, io_buffer, false)? } else { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_710] = unsafe { *(result.output.as_ptr() as *const [G; OUT_710]) }; __ret } } else { aiur_fn_710(__args, record, io_buffer, __cu)? } }; let __v_7: G = __r_arr[0]; let __v_8: G = __r_arr[1]; let __v_9: G = __r_arr[2]; @@ -60438,29 +60166,29 @@ fn aiur_fn_719( let __v_12: G = __r_arr[5]; let __v_13: G = G::from_u64(1); let __v_14: G = G::from_u64(1); - let __r_arr: [G; OUT_714] = { let __args: [G; IN_714] = [__v_4, __v_13, __v_14, __v_14, __v_14, __v_14, __v_14]; let __cu = unconstrained; if let Some(result) = record.function_queries[714].get_mut(&__args[..]) { if !__cu && *result.multiplicity == G::ZERO { aiur_fn_714(__args, record, io_buffer, false)? } else { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_714] = unsafe { *(result.output.as_ptr() as *const [G; OUT_714]) }; __ret } } else { aiur_fn_714(__args, record, io_buffer, __cu)? } }; + let __r_arr: [G; OUT_710] = { let __args: [G; IN_710] = [__v_4, __v_13, __v_14, __v_14, __v_14, __v_14, __v_14]; let __cu = unconstrained; if let Some(result) = record.function_queries[710].get_mut(&__args[..]) { if !__cu && *result.multiplicity == G::ZERO { aiur_fn_710(__args, record, io_buffer, false)? } else { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_710] = unsafe { *(result.output.as_ptr() as *const [G; OUT_710]) }; __ret } } else { aiur_fn_710(__args, record, io_buffer, __cu)? } }; let __v_15: G = __r_arr[0]; let __v_16: G = __r_arr[1]; let __v_17: G = __r_arr[2]; let __v_18: G = __r_arr[3]; let __v_19: G = __r_arr[4]; let __v_20: G = __r_arr[5]; - let __r_arr: [G; OUT_718] = { let __args: [G; IN_718] = [__v_3, __v_7, __v_8, __v_9, __v_10, __v_11, __v_12, __v_15, __v_16, __v_17, __v_18, __v_19, __v_20]; let __cu = unconstrained; if let Some(result) = record.function_queries[718].get_mut(&__args[..]) { if !__cu && *result.multiplicity == G::ZERO { aiur_fn_718(__args, record, io_buffer, false)? } else { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_718] = unsafe { *(result.output.as_ptr() as *const [G; OUT_718]) }; __ret } } else { aiur_fn_718(__args, record, io_buffer, __cu)? } }; - let __ret: [G; OUT_719] = []; - if let Some(result) = record.function_queries[719].get_mut(&inp[..]) { debug_assert_eq!(result.output, &__ret[..]); if !unconstrained { *result.multiplicity += G::ONE; } } else { record.function_queries[719].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained)); }; + let __r_arr: [G; OUT_714] = { let __args: [G; IN_714] = [__v_3, __v_7, __v_8, __v_9, __v_10, __v_11, __v_12, __v_15, __v_16, __v_17, __v_18, __v_19, __v_20]; let __cu = unconstrained; if let Some(result) = record.function_queries[714].get_mut(&__args[..]) { if !__cu && *result.multiplicity == G::ZERO { aiur_fn_714(__args, record, io_buffer, false)? } else { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_714] = unsafe { *(result.output.as_ptr() as *const [G; OUT_714]) }; __ret } } else { aiur_fn_714(__args, record, io_buffer, __cu)? } }; + let __ret: [G; OUT_715] = []; + if let Some(result) = record.function_queries[715].get_mut(&inp[..]) { debug_assert_eq!(result.output, &__ret[..]); if !unconstrained { *result.multiplicity += G::ONE; } } else { record.function_queries[715].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained)); }; return Ok(__ret); }) } -const INPUT_SIZE_720: usize = 1; -const IN_720: usize = 1; -const OUT_720: usize = 3; -fn aiur_fn_720( - inp: [G; IN_720], +const INPUT_SIZE_716: usize = 1; +const IN_716: usize = 1; +const OUT_716: usize = 3; +fn aiur_fn_716( + inp: [G; IN_716], record: &mut QueryRecord, io_buffer: &mut IOBuffer, unconstrained: bool, -) -> Result<[G; OUT_720], ExecError> { +) -> Result<[G; OUT_716], ExecError> { stacker::maybe_grow(64 * 1024, 4 * 1024 * 1024, || { let __v_0: G = inp[0]; let __r_arr: [G; OUT_72] = { let __args: [G; IN_72] = [__v_0]; let __cu = unconstrained; if let Some(result) = record.function_queries[72].get_mut(&__args[..]) { if !__cu && *result.multiplicity == G::ZERO { aiur_fn_72(__args, record, io_buffer, false)? } else { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_72] = unsafe { *(result.output.as_ptr() as *const [G; OUT_72]) }; __ret } } else { aiur_fn_72(__args, record, io_buffer, __cu)? } }; @@ -60470,8 +60198,8 @@ fn aiur_fn_720( 0u64 => { let __v_3: G = G::from_u64(1); let __v_4: G = G::from_u64(1); - let __ret: [G; OUT_720] = [__v_3, __v_4, __v_2]; - if let Some(result) = record.function_queries[720].get_mut(&inp[..]) { debug_assert_eq!(result.output, &__ret[..]); if !unconstrained { *result.multiplicity += G::ONE; } } else { record.function_queries[720].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained)); }; + let __ret: [G; OUT_716] = [__v_3, __v_4, __v_2]; + if let Some(result) = record.function_queries[716].get_mut(&inp[..]) { debug_assert_eq!(result.output, &__ret[..]); if !unconstrained { *result.multiplicity += G::ONE; } } else { record.function_queries[716].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained)); }; return Ok(__ret); }, 1u64 => { @@ -60479,8 +60207,8 @@ fn aiur_fn_720( let __v_3: G = __r_arr[0]; let __v_4: G = __r_arr[1]; let __v_5: G = G::from_u64(0); - let __ret: [G; OUT_720] = [__v_5, __v_3, __v_4]; - if let Some(result) = record.function_queries[720].get_mut(&inp[..]) { debug_assert_eq!(result.output, &__ret[..]); if !unconstrained { *result.multiplicity += G::ONE; } } else { record.function_queries[720].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained)); }; + let __ret: [G; OUT_716] = [__v_5, __v_3, __v_4]; + if let Some(result) = record.function_queries[716].get_mut(&inp[..]) { debug_assert_eq!(result.output, &__ret[..]); if !unconstrained { *result.multiplicity += G::ONE; } } else { record.function_queries[716].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained)); }; return Ok(__ret); }, _ => { @@ -60490,15 +60218,15 @@ fn aiur_fn_720( }) } -const INPUT_SIZE_721: usize = 2; -const IN_721: usize = 2; -const OUT_721: usize = 10; -fn aiur_fn_721( - inp: [G; IN_721], +const INPUT_SIZE_717: usize = 2; +const IN_717: usize = 2; +const OUT_717: usize = 10; +fn aiur_fn_717( + inp: [G; IN_717], record: &mut QueryRecord, io_buffer: &mut IOBuffer, unconstrained: bool, -) -> Result<[G; OUT_721], ExecError> { +) -> Result<[G; OUT_717], ExecError> { stacker::maybe_grow(64 * 1024, 4 * 1024 * 1024, || { let __v_0: G = inp[0]; let __v_1: G = inp[1]; @@ -60506,8 +60234,8 @@ fn aiur_fn_721( 0u64 => { let __v_2: G = G::from_u64(1); let __v_3: G = G::from_u64(1); - let __ret: [G; OUT_721] = [__v_2, __v_3, __v_3, __v_3, __v_3, __v_3, __v_3, __v_3, __v_3, __v_1]; - if let Some(result) = record.function_queries[721].get_mut(&inp[..]) { debug_assert_eq!(result.output, &__ret[..]); if !unconstrained { *result.multiplicity += G::ONE; } } else { record.function_queries[721].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained)); }; + let __ret: [G; OUT_717] = [__v_2, __v_3, __v_3, __v_3, __v_3, __v_3, __v_3, __v_3, __v_3, __v_1]; + if let Some(result) = record.function_queries[717].get_mut(&inp[..]) { debug_assert_eq!(result.output, &__ret[..]); if !unconstrained { *result.multiplicity += G::ONE; } } else { record.function_queries[717].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained)); }; return Ok(__ret); }, _ => { @@ -60522,23 +60250,23 @@ fn aiur_fn_721( let __v_9: G = __r_arr[7]; let __v_10: G = __r_arr[8]; let __v_11: G = G::from_u64(0); - let __ret: [G; OUT_721] = [__v_11, __v_2, __v_3, __v_4, __v_5, __v_6, __v_7, __v_8, __v_9, __v_10]; - if let Some(result) = record.function_queries[721].get_mut(&inp[..]) { debug_assert_eq!(result.output, &__ret[..]); if !unconstrained { *result.multiplicity += G::ONE; } } else { record.function_queries[721].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained)); }; + let __ret: [G; OUT_717] = [__v_11, __v_2, __v_3, __v_4, __v_5, __v_6, __v_7, __v_8, __v_9, __v_10]; + if let Some(result) = record.function_queries[717].get_mut(&inp[..]) { debug_assert_eq!(result.output, &__ret[..]); if !unconstrained { *result.multiplicity += G::ONE; } } else { record.function_queries[717].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained)); }; return Ok(__ret); }, } }) } -const INPUT_SIZE_722: usize = 2; -const IN_722: usize = 2; -const OUT_722: usize = 3; -fn aiur_fn_722( - inp: [G; IN_722], +const INPUT_SIZE_718: usize = 2; +const IN_718: usize = 2; +const OUT_718: usize = 3; +fn aiur_fn_718( + inp: [G; IN_718], record: &mut QueryRecord, io_buffer: &mut IOBuffer, unconstrained: bool, -) -> Result<[G; OUT_722], ExecError> { +) -> Result<[G; OUT_718], ExecError> { stacker::maybe_grow(64 * 1024, 4 * 1024 * 1024, || { let __v_0: G = inp[0]; let __v_1: G = inp[1]; @@ -60546,8 +60274,8 @@ fn aiur_fn_722( 0u64 => { let __v_2: G = G::from_u64(1); let __v_3: G = G::from_u64(1); - let __ret: [G; OUT_722] = [__v_2, __v_3, __v_1]; - if let Some(result) = record.function_queries[722].get_mut(&inp[..]) { debug_assert_eq!(result.output, &__ret[..]); if !unconstrained { *result.multiplicity += G::ONE; } } else { record.function_queries[722].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained)); }; + let __ret: [G; OUT_718] = [__v_2, __v_3, __v_1]; + if let Some(result) = record.function_queries[718].get_mut(&inp[..]) { debug_assert_eq!(result.output, &__ret[..]); if !unconstrained { *result.multiplicity += G::ONE; } } else { record.function_queries[718].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained)); }; return Ok(__ret); }, _ => { @@ -60555,23 +60283,23 @@ fn aiur_fn_722( let __v_2: G = __r_arr[0]; let __v_3: G = __r_arr[1]; let __v_4: G = G::from_u64(0); - let __ret: [G; OUT_722] = [__v_4, __v_2, __v_3]; - if let Some(result) = record.function_queries[722].get_mut(&inp[..]) { debug_assert_eq!(result.output, &__ret[..]); if !unconstrained { *result.multiplicity += G::ONE; } } else { record.function_queries[722].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained)); }; + let __ret: [G; OUT_718] = [__v_4, __v_2, __v_3]; + if let Some(result) = record.function_queries[718].get_mut(&inp[..]) { debug_assert_eq!(result.output, &__ret[..]); if !unconstrained { *result.multiplicity += G::ONE; } } else { record.function_queries[718].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained)); }; return Ok(__ret); }, } }) } -const INPUT_SIZE_723: usize = 2; -const IN_723: usize = 2; -const OUT_723: usize = 3; -fn aiur_fn_723( - inp: [G; IN_723], +const INPUT_SIZE_719: usize = 2; +const IN_719: usize = 2; +const OUT_719: usize = 3; +fn aiur_fn_719( + inp: [G; IN_719], record: &mut QueryRecord, io_buffer: &mut IOBuffer, unconstrained: bool, -) -> Result<[G; OUT_723], ExecError> { +) -> Result<[G; OUT_719], ExecError> { stacker::maybe_grow(64 * 1024, 4 * 1024 * 1024, || { let __v_0: G = inp[0]; let __v_1: G = inp[1]; @@ -60579,8 +60307,8 @@ fn aiur_fn_723( 0u64 => { let __v_2: G = G::from_u64(1); let __v_3: G = G::from_u64(1); - let __ret: [G; OUT_723] = [__v_2, __v_3, __v_1]; - if let Some(result) = record.function_queries[723].get_mut(&inp[..]) { debug_assert_eq!(result.output, &__ret[..]); if !unconstrained { *result.multiplicity += G::ONE; } } else { record.function_queries[723].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained)); }; + let __ret: [G; OUT_719] = [__v_2, __v_3, __v_1]; + if let Some(result) = record.function_queries[719].get_mut(&inp[..]) { debug_assert_eq!(result.output, &__ret[..]); if !unconstrained { *result.multiplicity += G::ONE; } } else { record.function_queries[719].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained)); }; return Ok(__ret); }, _ => { @@ -60588,23 +60316,23 @@ fn aiur_fn_723( let __v_2: G = __r_arr[0]; let __v_3: G = __r_arr[1]; let __v_4: G = G::from_u64(0); - let __ret: [G; OUT_723] = [__v_4, __v_2, __v_3]; - if let Some(result) = record.function_queries[723].get_mut(&inp[..]) { debug_assert_eq!(result.output, &__ret[..]); if !unconstrained { *result.multiplicity += G::ONE; } } else { record.function_queries[723].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained)); }; + let __ret: [G; OUT_719] = [__v_4, __v_2, __v_3]; + if let Some(result) = record.function_queries[719].get_mut(&inp[..]) { debug_assert_eq!(result.output, &__ret[..]); if !unconstrained { *result.multiplicity += G::ONE; } } else { record.function_queries[719].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained)); }; return Ok(__ret); }, } }) } -const INPUT_SIZE_724: usize = 2; -const IN_724: usize = 2; -const OUT_724: usize = 3; -fn aiur_fn_724( - inp: [G; IN_724], +const INPUT_SIZE_720: usize = 2; +const IN_720: usize = 2; +const OUT_720: usize = 3; +fn aiur_fn_720( + inp: [G; IN_720], record: &mut QueryRecord, io_buffer: &mut IOBuffer, unconstrained: bool, -) -> Result<[G; OUT_724], ExecError> { +) -> Result<[G; OUT_720], ExecError> { stacker::maybe_grow(64 * 1024, 4 * 1024 * 1024, || { let __v_0: G = inp[0]; let __v_1: G = inp[1]; @@ -60612,8 +60340,8 @@ fn aiur_fn_724( 0u64 => { let __v_2: G = G::from_u64(1); let __v_3: G = G::from_u64(1); - let __ret: [G; OUT_724] = [__v_2, __v_3, __v_1]; - if let Some(result) = record.function_queries[724].get_mut(&inp[..]) { debug_assert_eq!(result.output, &__ret[..]); if !unconstrained { *result.multiplicity += G::ONE; } } else { record.function_queries[724].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained)); }; + let __ret: [G; OUT_720] = [__v_2, __v_3, __v_1]; + if let Some(result) = record.function_queries[720].get_mut(&inp[..]) { debug_assert_eq!(result.output, &__ret[..]); if !unconstrained { *result.multiplicity += G::ONE; } } else { record.function_queries[720].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained)); }; return Ok(__ret); }, _ => { @@ -60624,22 +60352,22 @@ fn aiur_fn_724( 0u64 => { let __v_4: G = G::from_u64(0); let __v_5: G = G::from_u64(0); - let __ret: [G; OUT_724] = [__v_4, __v_5, __v_3]; - if let Some(result) = record.function_queries[724].get_mut(&inp[..]) { debug_assert_eq!(result.output, &__ret[..]); if !unconstrained { *result.multiplicity += G::ONE; } } else { record.function_queries[724].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained)); }; + let __ret: [G; OUT_720] = [__v_4, __v_5, __v_3]; + if let Some(result) = record.function_queries[720].get_mut(&inp[..]) { debug_assert_eq!(result.output, &__ret[..]); if !unconstrained { *result.multiplicity += G::ONE; } } else { record.function_queries[720].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained)); }; return Ok(__ret); }, 1u64 => { let __v_4: G = G::from_u64(0); let __v_5: G = G::from_u64(1); - let __ret: [G; OUT_724] = [__v_4, __v_5, __v_3]; - if let Some(result) = record.function_queries[724].get_mut(&inp[..]) { debug_assert_eq!(result.output, &__ret[..]); if !unconstrained { *result.multiplicity += G::ONE; } } else { record.function_queries[724].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained)); }; + let __ret: [G; OUT_720] = [__v_4, __v_5, __v_3]; + if let Some(result) = record.function_queries[720].get_mut(&inp[..]) { debug_assert_eq!(result.output, &__ret[..]); if !unconstrained { *result.multiplicity += G::ONE; } } else { record.function_queries[720].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained)); }; return Ok(__ret); }, 2u64 => { let __v_4: G = G::from_u64(0); let __v_5: G = G::from_u64(2); - let __ret: [G; OUT_724] = [__v_4, __v_5, __v_3]; - if let Some(result) = record.function_queries[724].get_mut(&inp[..]) { debug_assert_eq!(result.output, &__ret[..]); if !unconstrained { *result.multiplicity += G::ONE; } } else { record.function_queries[724].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained)); }; + let __ret: [G; OUT_720] = [__v_4, __v_5, __v_3]; + if let Some(result) = record.function_queries[720].get_mut(&inp[..]) { debug_assert_eq!(result.output, &__ret[..]); if !unconstrained { *result.multiplicity += G::ONE; } } else { record.function_queries[720].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained)); }; return Ok(__ret); }, _ => { @@ -60651,15 +60379,15 @@ fn aiur_fn_724( }) } -const INPUT_SIZE_725: usize = 2; -const IN_725: usize = 2; -const OUT_725: usize = 3; -fn aiur_fn_725( - inp: [G; IN_725], +const INPUT_SIZE_721: usize = 2; +const IN_721: usize = 2; +const OUT_721: usize = 3; +fn aiur_fn_721( + inp: [G; IN_721], record: &mut QueryRecord, io_buffer: &mut IOBuffer, unconstrained: bool, -) -> Result<[G; OUT_725], ExecError> { +) -> Result<[G; OUT_721], ExecError> { stacker::maybe_grow(64 * 1024, 4 * 1024 * 1024, || { let __v_0: G = inp[0]; let __v_1: G = inp[1]; @@ -60667,8 +60395,8 @@ fn aiur_fn_725( 0u64 => { let __v_2: G = G::from_u64(1); let __v_3: G = G::from_u64(1); - let __ret: [G; OUT_725] = [__v_2, __v_3, __v_1]; - if let Some(result) = record.function_queries[725].get_mut(&inp[..]) { debug_assert_eq!(result.output, &__ret[..]); if !unconstrained { *result.multiplicity += G::ONE; } } else { record.function_queries[725].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained)); }; + let __ret: [G; OUT_721] = [__v_2, __v_3, __v_1]; + if let Some(result) = record.function_queries[721].get_mut(&inp[..]) { debug_assert_eq!(result.output, &__ret[..]); if !unconstrained { *result.multiplicity += G::ONE; } } else { record.function_queries[721].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained)); }; return Ok(__ret); }, _ => { @@ -60679,29 +60407,29 @@ fn aiur_fn_725( 0u64 => { let __v_4: G = G::from_u64(0); let __v_5: G = G::from_u64(0); - let __ret: [G; OUT_725] = [__v_4, __v_5, __v_3]; - if let Some(result) = record.function_queries[725].get_mut(&inp[..]) { debug_assert_eq!(result.output, &__ret[..]); if !unconstrained { *result.multiplicity += G::ONE; } } else { record.function_queries[725].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained)); }; + let __ret: [G; OUT_721] = [__v_4, __v_5, __v_3]; + if let Some(result) = record.function_queries[721].get_mut(&inp[..]) { debug_assert_eq!(result.output, &__ret[..]); if !unconstrained { *result.multiplicity += G::ONE; } } else { record.function_queries[721].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained)); }; return Ok(__ret); }, 1u64 => { let __v_4: G = G::from_u64(0); let __v_5: G = G::from_u64(1); - let __ret: [G; OUT_725] = [__v_4, __v_5, __v_3]; - if let Some(result) = record.function_queries[725].get_mut(&inp[..]) { debug_assert_eq!(result.output, &__ret[..]); if !unconstrained { *result.multiplicity += G::ONE; } } else { record.function_queries[725].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained)); }; + let __ret: [G; OUT_721] = [__v_4, __v_5, __v_3]; + if let Some(result) = record.function_queries[721].get_mut(&inp[..]) { debug_assert_eq!(result.output, &__ret[..]); if !unconstrained { *result.multiplicity += G::ONE; } } else { record.function_queries[721].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained)); }; return Ok(__ret); }, 2u64 => { let __v_4: G = G::from_u64(0); let __v_5: G = G::from_u64(2); - let __ret: [G; OUT_725] = [__v_4, __v_5, __v_3]; - if let Some(result) = record.function_queries[725].get_mut(&inp[..]) { debug_assert_eq!(result.output, &__ret[..]); if !unconstrained { *result.multiplicity += G::ONE; } } else { record.function_queries[725].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained)); }; + let __ret: [G; OUT_721] = [__v_4, __v_5, __v_3]; + if let Some(result) = record.function_queries[721].get_mut(&inp[..]) { debug_assert_eq!(result.output, &__ret[..]); if !unconstrained { *result.multiplicity += G::ONE; } } else { record.function_queries[721].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained)); }; return Ok(__ret); }, 3u64 => { let __v_4: G = G::from_u64(0); let __v_5: G = G::from_u64(3); - let __ret: [G; OUT_725] = [__v_4, __v_5, __v_3]; - if let Some(result) = record.function_queries[725].get_mut(&inp[..]) { debug_assert_eq!(result.output, &__ret[..]); if !unconstrained { *result.multiplicity += G::ONE; } } else { record.function_queries[725].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained)); }; + let __ret: [G; OUT_721] = [__v_4, __v_5, __v_3]; + if let Some(result) = record.function_queries[721].get_mut(&inp[..]) { debug_assert_eq!(result.output, &__ret[..]); if !unconstrained { *result.multiplicity += G::ONE; } } else { record.function_queries[721].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained)); }; return Ok(__ret); }, _ => { @@ -60713,15 +60441,15 @@ fn aiur_fn_725( }) } -const INPUT_SIZE_726: usize = 9; -const IN_726: usize = 9; -const OUT_726: usize = 2; -fn aiur_fn_726( - inp: [G; IN_726], +const INPUT_SIZE_722: usize = 9; +const IN_722: usize = 9; +const OUT_722: usize = 2; +fn aiur_fn_722( + inp: [G; IN_722], record: &mut QueryRecord, io_buffer: &mut IOBuffer, unconstrained: bool, -) -> Result<[G; OUT_726], ExecError> { +) -> Result<[G; OUT_722], ExecError> { stacker::maybe_grow(64 * 1024, 4 * 1024 * 1024, || { let __v_0: G = inp[0]; let __v_1: G = inp[1]; @@ -60739,8 +60467,8 @@ fn aiur_fn_726( let __v_10: G = G::from_u64(1); let __v_11: G = G::from_u64(1); let __v_12: G = { let __values: [G; 19] = [__v_10, __v_11, __v_11, __v_11, __v_11, __v_11, __v_11, __v_11, __v_11, __v_11, __v_11, __v_11, __v_11, __v_11, __v_11, __v_11, __v_11, __v_11, __v_11]; let __mq = record.memory_queries.get_mut(&19).ok_or(ExecError::InvalidMemorySize(19))?; if let Some(result) = __mq.get_mut(&__values[..]) { if !unconstrained { *result.multiplicity += G::ONE; } result.output[0] } else { let __ptr = G::from_usize(__mq.len()); __mq.insert(&__values[..], &[__ptr], G::from_bool(!unconstrained)); __ptr } }; - let __ret: [G; OUT_726] = [__v_12, __v_0]; - if let Some(result) = record.function_queries[726].get_mut(&inp[..]) { debug_assert_eq!(result.output, &__ret[..]); if !unconstrained { *result.multiplicity += G::ONE; } } else { record.function_queries[726].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained)); }; + let __ret: [G; OUT_722] = [__v_12, __v_0]; + if let Some(result) = record.function_queries[722].get_mut(&inp[..]) { debug_assert_eq!(result.output, &__ret[..]); if !unconstrained { *result.multiplicity += G::ONE; } } else { record.function_queries[722].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained)); }; return Ok(__ret); }, _ => { @@ -60772,28 +60500,28 @@ fn aiur_fn_726( let __v_33: G = __r_arr[5]; let __v_34: G = __r_arr[6]; let __v_35: G = __r_arr[7]; - let __r_arr: [G; OUT_726] = { let __args: [G; IN_726] = [__v_27, __v_28, __v_29, __v_30, __v_31, __v_32, __v_33, __v_34, __v_35]; let __cu = unconstrained; if let Some(result) = record.function_queries[726].get_mut(&__args[..]) { if !__cu && *result.multiplicity == G::ZERO { aiur_fn_726(__args, record, io_buffer, false)? } else { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_726] = unsafe { *(result.output.as_ptr() as *const [G; OUT_726]) }; __ret } } else { aiur_fn_726(__args, record, io_buffer, __cu)? } }; + let __r_arr: [G; OUT_722] = { let __args: [G; IN_722] = [__v_27, __v_28, __v_29, __v_30, __v_31, __v_32, __v_33, __v_34, __v_35]; let __cu = unconstrained; if let Some(result) = record.function_queries[722].get_mut(&__args[..]) { if !__cu && *result.multiplicity == G::ZERO { aiur_fn_722(__args, record, io_buffer, false)? } else { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_722] = unsafe { *(result.output.as_ptr() as *const [G; OUT_722]) }; __ret } } else { aiur_fn_722(__args, record, io_buffer, __cu)? } }; let __v_36: G = __r_arr[0]; let __v_37: G = __r_arr[1]; let __v_38: G = G::from_u64(0); let __v_39: G = { let __values: [G; 19] = [__v_38, __v_10, __v_11, __v_12, __v_13, __v_14, __v_15, __v_16, __v_17, __v_18, __v_19, __v_20, __v_21, __v_22, __v_23, __v_24, __v_25, __v_26, __v_36]; let __mq = record.memory_queries.get_mut(&19).ok_or(ExecError::InvalidMemorySize(19))?; if let Some(result) = __mq.get_mut(&__values[..]) { if !unconstrained { *result.multiplicity += G::ONE; } result.output[0] } else { let __ptr = G::from_usize(__mq.len()); __mq.insert(&__values[..], &[__ptr], G::from_bool(!unconstrained)); __ptr } }; - let __ret: [G; OUT_726] = [__v_39, __v_37]; - if let Some(result) = record.function_queries[726].get_mut(&inp[..]) { debug_assert_eq!(result.output, &__ret[..]); if !unconstrained { *result.multiplicity += G::ONE; } } else { record.function_queries[726].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained)); }; + let __ret: [G; OUT_722] = [__v_39, __v_37]; + if let Some(result) = record.function_queries[722].get_mut(&inp[..]) { debug_assert_eq!(result.output, &__ret[..]); if !unconstrained { *result.multiplicity += G::ONE; } } else { record.function_queries[722].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained)); }; return Ok(__ret); }, } }) } -const INPUT_SIZE_727: usize = 2; -const IN_727: usize = 2; -const OUT_727: usize = 3; -fn aiur_fn_727( - inp: [G; IN_727], +const INPUT_SIZE_723: usize = 2; +const IN_723: usize = 2; +const OUT_723: usize = 3; +fn aiur_fn_723( + inp: [G; IN_723], record: &mut QueryRecord, io_buffer: &mut IOBuffer, unconstrained: bool, -) -> Result<[G; OUT_727], ExecError> { +) -> Result<[G; OUT_723], ExecError> { stacker::maybe_grow(64 * 1024, 4 * 1024 * 1024, || { let __v_0: G = inp[0]; let __v_1: G = inp[1]; @@ -60801,8 +60529,8 @@ fn aiur_fn_727( 0u64 => { let __v_2: G = G::from_u64(1); let __v_3: G = G::from_u64(1); - let __ret: [G; OUT_727] = [__v_2, __v_3, __v_1]; - if let Some(result) = record.function_queries[727].get_mut(&inp[..]) { debug_assert_eq!(result.output, &__ret[..]); if !unconstrained { *result.multiplicity += G::ONE; } } else { record.function_queries[727].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained)); }; + let __ret: [G; OUT_723] = [__v_2, __v_3, __v_1]; + if let Some(result) = record.function_queries[723].get_mut(&inp[..]) { debug_assert_eq!(result.output, &__ret[..]); if !unconstrained { *result.multiplicity += G::ONE; } } else { record.function_queries[723].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained)); }; return Ok(__ret); }, _ => { @@ -60816,27 +60544,27 @@ fn aiur_fn_727( let __v_8: G = __r_arr[6]; let __v_9: G = __r_arr[7]; let __v_10: G = __r_arr[8]; - let __r_arr: [G; OUT_726] = { let __args: [G; IN_726] = [__v_10, __v_2, __v_3, __v_4, __v_5, __v_6, __v_7, __v_8, __v_9]; let __cu = unconstrained; if let Some(result) = record.function_queries[726].get_mut(&__args[..]) { if !__cu && *result.multiplicity == G::ZERO { aiur_fn_726(__args, record, io_buffer, false)? } else { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_726] = unsafe { *(result.output.as_ptr() as *const [G; OUT_726]) }; __ret } } else { aiur_fn_726(__args, record, io_buffer, __cu)? } }; + let __r_arr: [G; OUT_722] = { let __args: [G; IN_722] = [__v_10, __v_2, __v_3, __v_4, __v_5, __v_6, __v_7, __v_8, __v_9]; let __cu = unconstrained; if let Some(result) = record.function_queries[722].get_mut(&__args[..]) { if !__cu && *result.multiplicity == G::ZERO { aiur_fn_722(__args, record, io_buffer, false)? } else { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_722] = unsafe { *(result.output.as_ptr() as *const [G; OUT_722]) }; __ret } } else { aiur_fn_722(__args, record, io_buffer, __cu)? } }; let __v_11: G = __r_arr[0]; let __v_12: G = __r_arr[1]; let __v_13: G = G::from_u64(0); - let __ret: [G; OUT_727] = [__v_13, __v_11, __v_12]; - if let Some(result) = record.function_queries[727].get_mut(&inp[..]) { debug_assert_eq!(result.output, &__ret[..]); if !unconstrained { *result.multiplicity += G::ONE; } } else { record.function_queries[727].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained)); }; + let __ret: [G; OUT_723] = [__v_13, __v_11, __v_12]; + if let Some(result) = record.function_queries[723].get_mut(&inp[..]) { debug_assert_eq!(result.output, &__ret[..]); if !unconstrained { *result.multiplicity += G::ONE; } } else { record.function_queries[723].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained)); }; return Ok(__ret); }, } }) } -const INPUT_SIZE_728: usize = 1; -const IN_728: usize = 1; -const OUT_728: usize = 41; -fn aiur_fn_728( - inp: [G; IN_728], +const INPUT_SIZE_724: usize = 1; +const IN_724: usize = 1; +const OUT_724: usize = 41; +fn aiur_fn_724( + inp: [G; IN_724], record: &mut QueryRecord, io_buffer: &mut IOBuffer, unconstrained: bool, -) -> Result<[G; OUT_728], ExecError> { +) -> Result<[G; OUT_724], ExecError> { stacker::maybe_grow(64 * 1024, 4 * 1024 * 1024, || { let __v_0: G = inp[0]; let __r_arr: [G; OUT_74] = { let __args: [G; IN_74] = [__v_0]; let __cu = unconstrained; if let Some(result) = record.function_queries[74].get_mut(&__args[..]) { if !__cu && *result.multiplicity == G::ZERO { aiur_fn_74(__args, record, io_buffer, false)? } else { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_74] = unsafe { *(result.output.as_ptr() as *const [G; OUT_74]) }; __ret } } else { aiur_fn_74(__args, record, io_buffer, __cu)? } }; @@ -60858,11 +60586,11 @@ fn aiur_fn_728( let __v_15: G = __b1_out[5]; let __v_16: G = __b1_out[6]; let __v_17: G = __b1_out[7]; - let __r_arr: [G; OUT_723] = { let __args: [G; IN_723] = [__v_10, __v_9]; let __cu = unconstrained; if let Some(result) = record.function_queries[723].get_mut(&__args[..]) { if !__cu && *result.multiplicity == G::ZERO { aiur_fn_723(__args, record, io_buffer, false)? } else { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_723] = unsafe { *(result.output.as_ptr() as *const [G; OUT_723]) }; __ret } } else { aiur_fn_723(__args, record, io_buffer, __cu)? } }; + let __r_arr: [G; OUT_719] = { let __args: [G; IN_719] = [__v_10, __v_9]; let __cu = unconstrained; if let Some(result) = record.function_queries[719].get_mut(&__args[..]) { if !__cu && *result.multiplicity == G::ZERO { aiur_fn_719(__args, record, io_buffer, false)? } else { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_719] = unsafe { *(result.output.as_ptr() as *const [G; OUT_719]) }; __ret } } else { aiur_fn_719(__args, record, io_buffer, __cu)? } }; let __v_18: G = __r_arr[0]; let __v_19: G = __r_arr[1]; let __v_20: G = __r_arr[2]; - let __r_arr: [G; OUT_721] = { let __args: [G; IN_721] = [__v_11, __v_20]; let __cu = unconstrained; if let Some(result) = record.function_queries[721].get_mut(&__args[..]) { if !__cu && *result.multiplicity == G::ZERO { aiur_fn_721(__args, record, io_buffer, false)? } else { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_721] = unsafe { *(result.output.as_ptr() as *const [G; OUT_721]) }; __ret } } else { aiur_fn_721(__args, record, io_buffer, __cu)? } }; + let __r_arr: [G; OUT_717] = { let __args: [G; IN_717] = [__v_11, __v_20]; let __cu = unconstrained; if let Some(result) = record.function_queries[717].get_mut(&__args[..]) { if !__cu && *result.multiplicity == G::ZERO { aiur_fn_717(__args, record, io_buffer, false)? } else { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_717] = unsafe { *(result.output.as_ptr() as *const [G; OUT_717]) }; __ret } } else { aiur_fn_717(__args, record, io_buffer, __cu)? } }; let __v_21: G = __r_arr[0]; let __v_22: G = __r_arr[1]; let __v_23: G = __r_arr[2]; @@ -60873,7 +60601,7 @@ fn aiur_fn_728( let __v_28: G = __r_arr[7]; let __v_29: G = __r_arr[8]; let __v_30: G = __r_arr[9]; - let __r_arr: [G; OUT_721] = { let __args: [G; IN_721] = [__v_12, __v_30]; let __cu = unconstrained; if let Some(result) = record.function_queries[721].get_mut(&__args[..]) { if !__cu && *result.multiplicity == G::ZERO { aiur_fn_721(__args, record, io_buffer, false)? } else { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_721] = unsafe { *(result.output.as_ptr() as *const [G; OUT_721]) }; __ret } } else { aiur_fn_721(__args, record, io_buffer, __cu)? } }; + let __r_arr: [G; OUT_717] = { let __args: [G; IN_717] = [__v_12, __v_30]; let __cu = unconstrained; if let Some(result) = record.function_queries[717].get_mut(&__args[..]) { if !__cu && *result.multiplicity == G::ZERO { aiur_fn_717(__args, record, io_buffer, false)? } else { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_717] = unsafe { *(result.output.as_ptr() as *const [G; OUT_717]) }; __ret } } else { aiur_fn_717(__args, record, io_buffer, __cu)? } }; let __v_31: G = __r_arr[0]; let __v_32: G = __r_arr[1]; let __v_33: G = __r_arr[2]; @@ -60884,7 +60612,7 @@ fn aiur_fn_728( let __v_38: G = __r_arr[7]; let __v_39: G = __r_arr[8]; let __v_40: G = __r_arr[9]; - let __r_arr: [G; OUT_721] = { let __args: [G; IN_721] = [__v_13, __v_40]; let __cu = unconstrained; if let Some(result) = record.function_queries[721].get_mut(&__args[..]) { if !__cu && *result.multiplicity == G::ZERO { aiur_fn_721(__args, record, io_buffer, false)? } else { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_721] = unsafe { *(result.output.as_ptr() as *const [G; OUT_721]) }; __ret } } else { aiur_fn_721(__args, record, io_buffer, __cu)? } }; + let __r_arr: [G; OUT_717] = { let __args: [G; IN_717] = [__v_13, __v_40]; let __cu = unconstrained; if let Some(result) = record.function_queries[717].get_mut(&__args[..]) { if !__cu && *result.multiplicity == G::ZERO { aiur_fn_717(__args, record, io_buffer, false)? } else { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_717] = unsafe { *(result.output.as_ptr() as *const [G; OUT_717]) }; __ret } } else { aiur_fn_717(__args, record, io_buffer, __cu)? } }; let __v_41: G = __r_arr[0]; let __v_42: G = __r_arr[1]; let __v_43: G = __r_arr[2]; @@ -60895,7 +60623,7 @@ fn aiur_fn_728( let __v_48: G = __r_arr[7]; let __v_49: G = __r_arr[8]; let __v_50: G = __r_arr[9]; - let __r_arr: [G; OUT_721] = { let __args: [G; IN_721] = [__v_14, __v_50]; let __cu = unconstrained; if let Some(result) = record.function_queries[721].get_mut(&__args[..]) { if !__cu && *result.multiplicity == G::ZERO { aiur_fn_721(__args, record, io_buffer, false)? } else { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_721] = unsafe { *(result.output.as_ptr() as *const [G; OUT_721]) }; __ret } } else { aiur_fn_721(__args, record, io_buffer, __cu)? } }; + let __r_arr: [G; OUT_717] = { let __args: [G; IN_717] = [__v_14, __v_50]; let __cu = unconstrained; if let Some(result) = record.function_queries[717].get_mut(&__args[..]) { if !__cu && *result.multiplicity == G::ZERO { aiur_fn_717(__args, record, io_buffer, false)? } else { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_717] = unsafe { *(result.output.as_ptr() as *const [G; OUT_717]) }; __ret } } else { aiur_fn_717(__args, record, io_buffer, __cu)? } }; let __v_51: G = __r_arr[0]; let __v_52: G = __r_arr[1]; let __v_53: G = __r_arr[2]; @@ -60906,25 +60634,25 @@ fn aiur_fn_728( let __v_58: G = __r_arr[7]; let __v_59: G = __r_arr[8]; let __v_60: G = __r_arr[9]; - let __r_arr: [G; OUT_722] = { let __args: [G; IN_722] = [__v_15, __v_60]; let __cu = unconstrained; if let Some(result) = record.function_queries[722].get_mut(&__args[..]) { if !__cu && *result.multiplicity == G::ZERO { aiur_fn_722(__args, record, io_buffer, false)? } else { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_722] = unsafe { *(result.output.as_ptr() as *const [G; OUT_722]) }; __ret } } else { aiur_fn_722(__args, record, io_buffer, __cu)? } }; + let __r_arr: [G; OUT_718] = { let __args: [G; IN_718] = [__v_15, __v_60]; let __cu = unconstrained; if let Some(result) = record.function_queries[718].get_mut(&__args[..]) { if !__cu && *result.multiplicity == G::ZERO { aiur_fn_718(__args, record, io_buffer, false)? } else { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_718] = unsafe { *(result.output.as_ptr() as *const [G; OUT_718]) }; __ret } } else { aiur_fn_718(__args, record, io_buffer, __cu)? } }; let __v_61: G = __r_arr[0]; let __v_62: G = __r_arr[1]; let __v_63: G = __r_arr[2]; - let __ret: [G; OUT_728] = [__v_18, __v_19, __v_21, __v_22, __v_23, __v_24, __v_25, __v_26, __v_27, __v_28, __v_29, __v_31, __v_32, __v_33, __v_34, __v_35, __v_36, __v_37, __v_38, __v_39, __v_41, __v_42, __v_43, __v_44, __v_45, __v_46, __v_47, __v_48, __v_49, __v_51, __v_52, __v_53, __v_54, __v_55, __v_56, __v_57, __v_58, __v_59, __v_61, __v_62, __v_63]; - if let Some(result) = record.function_queries[728].get_mut(&inp[..]) { debug_assert_eq!(result.output, &__ret[..]); if !unconstrained { *result.multiplicity += G::ONE; } } else { record.function_queries[728].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained)); }; + let __ret: [G; OUT_724] = [__v_18, __v_19, __v_21, __v_22, __v_23, __v_24, __v_25, __v_26, __v_27, __v_28, __v_29, __v_31, __v_32, __v_33, __v_34, __v_35, __v_36, __v_37, __v_38, __v_39, __v_41, __v_42, __v_43, __v_44, __v_45, __v_46, __v_47, __v_48, __v_49, __v_51, __v_52, __v_53, __v_54, __v_55, __v_56, __v_57, __v_58, __v_59, __v_61, __v_62, __v_63]; + if let Some(result) = record.function_queries[724].get_mut(&inp[..]) { debug_assert_eq!(result.output, &__ret[..]); if !unconstrained { *result.multiplicity += G::ONE; } } else { record.function_queries[724].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained)); }; return Ok(__ret); }) } -const INPUT_SIZE_729: usize = 1; -const IN_729: usize = 1; -const OUT_729: usize = 49; -fn aiur_fn_729( - inp: [G; IN_729], +const INPUT_SIZE_725: usize = 1; +const IN_725: usize = 1; +const OUT_725: usize = 49; +fn aiur_fn_725( + inp: [G; IN_725], record: &mut QueryRecord, io_buffer: &mut IOBuffer, unconstrained: bool, -) -> Result<[G; OUT_729], ExecError> { +) -> Result<[G; OUT_725], ExecError> { stacker::maybe_grow(64 * 1024, 4 * 1024 * 1024, || { let __v_0: G = inp[0]; let __r_arr: [G; OUT_74] = { let __args: [G; IN_74] = [__v_0]; let __cu = unconstrained; if let Some(result) = record.function_queries[74].get_mut(&__args[..]) { if !__cu && *result.multiplicity == G::ZERO { aiur_fn_74(__args, record, io_buffer, false)? } else { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_74] = unsafe { *(result.output.as_ptr() as *const [G; OUT_74]) }; __ret } } else { aiur_fn_74(__args, record, io_buffer, __cu)? } }; @@ -60937,7 +60665,7 @@ fn aiur_fn_729( let __v_7: G = __r_arr[6]; let __v_8: G = __r_arr[7]; let __v_9: G = __r_arr[8]; - let __r_arr: [G; OUT_728] = { let __args: [G; IN_728] = [__v_9]; let __cu = unconstrained; if let Some(result) = record.function_queries[728].get_mut(&__args[..]) { if !__cu && *result.multiplicity == G::ZERO { aiur_fn_728(__args, record, io_buffer, false)? } else { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_728] = unsafe { *(result.output.as_ptr() as *const [G; OUT_728]) }; __ret } } else { aiur_fn_728(__args, record, io_buffer, __cu)? } }; + let __r_arr: [G; OUT_724] = { let __args: [G; IN_724] = [__v_9]; let __cu = unconstrained; if let Some(result) = record.function_queries[724].get_mut(&__args[..]) { if !__cu && *result.multiplicity == G::ZERO { aiur_fn_724(__args, record, io_buffer, false)? } else { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_724] = unsafe { *(result.output.as_ptr() as *const [G; OUT_724]) }; __ret } } else { aiur_fn_724(__args, record, io_buffer, __cu)? } }; let __v_10: G = __r_arr[0]; let __v_11: G = __r_arr[1]; let __v_12: G = __r_arr[2]; @@ -60979,21 +60707,21 @@ fn aiur_fn_729( let __v_48: G = __r_arr[38]; let __v_49: G = __r_arr[39]; let __v_50: G = __r_arr[40]; - let __ret: [G; OUT_729] = [__v_1, __v_2, __v_3, __v_4, __v_5, __v_6, __v_7, __v_8, __v_10, __v_11, __v_12, __v_13, __v_14, __v_15, __v_16, __v_17, __v_18, __v_19, __v_20, __v_21, __v_22, __v_23, __v_24, __v_25, __v_26, __v_27, __v_28, __v_29, __v_30, __v_31, __v_32, __v_33, __v_34, __v_35, __v_36, __v_37, __v_38, __v_39, __v_40, __v_41, __v_42, __v_43, __v_44, __v_45, __v_46, __v_47, __v_48, __v_49, __v_50]; - if let Some(result) = record.function_queries[729].get_mut(&inp[..]) { debug_assert_eq!(result.output, &__ret[..]); if !unconstrained { *result.multiplicity += G::ONE; } } else { record.function_queries[729].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained)); }; + let __ret: [G; OUT_725] = [__v_1, __v_2, __v_3, __v_4, __v_5, __v_6, __v_7, __v_8, __v_10, __v_11, __v_12, __v_13, __v_14, __v_15, __v_16, __v_17, __v_18, __v_19, __v_20, __v_21, __v_22, __v_23, __v_24, __v_25, __v_26, __v_27, __v_28, __v_29, __v_30, __v_31, __v_32, __v_33, __v_34, __v_35, __v_36, __v_37, __v_38, __v_39, __v_40, __v_41, __v_42, __v_43, __v_44, __v_45, __v_46, __v_47, __v_48, __v_49, __v_50]; + if let Some(result) = record.function_queries[725].get_mut(&inp[..]) { debug_assert_eq!(result.output, &__ret[..]); if !unconstrained { *result.multiplicity += G::ONE; } } else { record.function_queries[725].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained)); }; return Ok(__ret); }) } -const INPUT_SIZE_730: usize = 9; -const IN_730: usize = 9; -const OUT_730: usize = 2; -fn aiur_fn_730( - inp: [G; IN_730], +const INPUT_SIZE_726: usize = 9; +const IN_726: usize = 9; +const OUT_726: usize = 2; +fn aiur_fn_726( + inp: [G; IN_726], record: &mut QueryRecord, io_buffer: &mut IOBuffer, unconstrained: bool, -) -> Result<[G; OUT_730], ExecError> { +) -> Result<[G; OUT_726], ExecError> { stacker::maybe_grow(64 * 1024, 4 * 1024 * 1024, || { let __v_0: G = inp[0]; let __v_1: G = inp[1]; @@ -61011,12 +60739,12 @@ fn aiur_fn_730( let __v_10: G = G::from_u64(1); let __v_11: G = G::from_u64(1); let __v_12: G = { let __values: [G; 50] = [__v_10, __v_11, __v_11, __v_11, __v_11, __v_11, __v_11, __v_11, __v_11, __v_11, __v_11, __v_11, __v_11, __v_11, __v_11, __v_11, __v_11, __v_11, __v_11, __v_11, __v_11, __v_11, __v_11, __v_11, __v_11, __v_11, __v_11, __v_11, __v_11, __v_11, __v_11, __v_11, __v_11, __v_11, __v_11, __v_11, __v_11, __v_11, __v_11, __v_11, __v_11, __v_11, __v_11, __v_11, __v_11, __v_11, __v_11, __v_11, __v_11, __v_11]; let __mq = record.memory_queries.get_mut(&50).ok_or(ExecError::InvalidMemorySize(50))?; if let Some(result) = __mq.get_mut(&__values[..]) { if !unconstrained { *result.multiplicity += G::ONE; } result.output[0] } else { let __ptr = G::from_usize(__mq.len()); __mq.insert(&__values[..], &[__ptr], G::from_bool(!unconstrained)); __ptr } }; - let __ret: [G; OUT_730] = [__v_12, __v_0]; - if let Some(result) = record.function_queries[730].get_mut(&inp[..]) { debug_assert_eq!(result.output, &__ret[..]); if !unconstrained { *result.multiplicity += G::ONE; } } else { record.function_queries[730].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained)); }; + let __ret: [G; OUT_726] = [__v_12, __v_0]; + if let Some(result) = record.function_queries[726].get_mut(&inp[..]) { debug_assert_eq!(result.output, &__ret[..]); if !unconstrained { *result.multiplicity += G::ONE; } } else { record.function_queries[726].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained)); }; return Ok(__ret); }, _ => { - let __r_arr: [G; OUT_729] = { let __args: [G; IN_729] = [__v_0]; let __cu = unconstrained; if let Some(result) = record.function_queries[729].get_mut(&__args[..]) { if !__cu && *result.multiplicity == G::ZERO { aiur_fn_729(__args, record, io_buffer, false)? } else { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_729] = unsafe { *(result.output.as_ptr() as *const [G; OUT_729]) }; __ret } } else { aiur_fn_729(__args, record, io_buffer, __cu)? } }; + let __r_arr: [G; OUT_725] = { let __args: [G; IN_725] = [__v_0]; let __cu = unconstrained; if let Some(result) = record.function_queries[725].get_mut(&__args[..]) { if !__cu && *result.multiplicity == G::ZERO { aiur_fn_725(__args, record, io_buffer, false)? } else { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_725] = unsafe { *(result.output.as_ptr() as *const [G; OUT_725]) }; __ret } } else { aiur_fn_725(__args, record, io_buffer, __cu)? } }; let __v_10: G = __r_arr[0]; let __v_11: G = __r_arr[1]; let __v_12: G = __r_arr[2]; @@ -61075,28 +60803,28 @@ fn aiur_fn_730( let __v_64: G = __r_arr[5]; let __v_65: G = __r_arr[6]; let __v_66: G = __r_arr[7]; - let __r_arr: [G; OUT_730] = { let __args: [G; IN_730] = [__v_58, __v_59, __v_60, __v_61, __v_62, __v_63, __v_64, __v_65, __v_66]; let __cu = unconstrained; if let Some(result) = record.function_queries[730].get_mut(&__args[..]) { if !__cu && *result.multiplicity == G::ZERO { aiur_fn_730(__args, record, io_buffer, false)? } else { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_730] = unsafe { *(result.output.as_ptr() as *const [G; OUT_730]) }; __ret } } else { aiur_fn_730(__args, record, io_buffer, __cu)? } }; + let __r_arr: [G; OUT_726] = { let __args: [G; IN_726] = [__v_58, __v_59, __v_60, __v_61, __v_62, __v_63, __v_64, __v_65, __v_66]; let __cu = unconstrained; if let Some(result) = record.function_queries[726].get_mut(&__args[..]) { if !__cu && *result.multiplicity == G::ZERO { aiur_fn_726(__args, record, io_buffer, false)? } else { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_726] = unsafe { *(result.output.as_ptr() as *const [G; OUT_726]) }; __ret } } else { aiur_fn_726(__args, record, io_buffer, __cu)? } }; let __v_67: G = __r_arr[0]; let __v_68: G = __r_arr[1]; let __v_69: G = G::from_u64(0); let __v_70: G = { let __values: [G; 50] = [__v_69, __v_10, __v_11, __v_12, __v_13, __v_14, __v_15, __v_16, __v_17, __v_18, __v_19, __v_20, __v_21, __v_22, __v_23, __v_24, __v_25, __v_26, __v_27, __v_28, __v_29, __v_30, __v_31, __v_32, __v_33, __v_34, __v_35, __v_36, __v_37, __v_38, __v_39, __v_40, __v_41, __v_42, __v_43, __v_44, __v_45, __v_46, __v_47, __v_48, __v_49, __v_50, __v_51, __v_52, __v_53, __v_54, __v_55, __v_56, __v_57, __v_67]; let __mq = record.memory_queries.get_mut(&50).ok_or(ExecError::InvalidMemorySize(50))?; if let Some(result) = __mq.get_mut(&__values[..]) { if !unconstrained { *result.multiplicity += G::ONE; } result.output[0] } else { let __ptr = G::from_usize(__mq.len()); __mq.insert(&__values[..], &[__ptr], G::from_bool(!unconstrained)); __ptr } }; - let __ret: [G; OUT_730] = [__v_70, __v_68]; - if let Some(result) = record.function_queries[730].get_mut(&inp[..]) { debug_assert_eq!(result.output, &__ret[..]); if !unconstrained { *result.multiplicity += G::ONE; } } else { record.function_queries[730].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained)); }; + let __ret: [G; OUT_726] = [__v_70, __v_68]; + if let Some(result) = record.function_queries[726].get_mut(&inp[..]) { debug_assert_eq!(result.output, &__ret[..]); if !unconstrained { *result.multiplicity += G::ONE; } } else { record.function_queries[726].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained)); }; return Ok(__ret); }, } }) } -const INPUT_SIZE_731: usize = 2; -const IN_731: usize = 2; -const OUT_731: usize = 3; -fn aiur_fn_731( - inp: [G; IN_731], +const INPUT_SIZE_727: usize = 2; +const IN_727: usize = 2; +const OUT_727: usize = 3; +fn aiur_fn_727( + inp: [G; IN_727], record: &mut QueryRecord, io_buffer: &mut IOBuffer, unconstrained: bool, -) -> Result<[G; OUT_731], ExecError> { +) -> Result<[G; OUT_727], ExecError> { stacker::maybe_grow(64 * 1024, 4 * 1024 * 1024, || { let __v_0: G = inp[0]; let __v_1: G = inp[1]; @@ -61104,8 +60832,8 @@ fn aiur_fn_731( 0u64 => { let __v_2: G = G::from_u64(1); let __v_3: G = G::from_u64(1); - let __ret: [G; OUT_731] = [__v_2, __v_3, __v_1]; - if let Some(result) = record.function_queries[731].get_mut(&inp[..]) { debug_assert_eq!(result.output, &__ret[..]); if !unconstrained { *result.multiplicity += G::ONE; } } else { record.function_queries[731].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained)); }; + let __ret: [G; OUT_727] = [__v_2, __v_3, __v_1]; + if let Some(result) = record.function_queries[727].get_mut(&inp[..]) { debug_assert_eq!(result.output, &__ret[..]); if !unconstrained { *result.multiplicity += G::ONE; } } else { record.function_queries[727].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained)); }; return Ok(__ret); }, _ => { @@ -61119,27 +60847,27 @@ fn aiur_fn_731( let __v_8: G = __r_arr[6]; let __v_9: G = __r_arr[7]; let __v_10: G = __r_arr[8]; - let __r_arr: [G; OUT_730] = { let __args: [G; IN_730] = [__v_10, __v_2, __v_3, __v_4, __v_5, __v_6, __v_7, __v_8, __v_9]; let __cu = unconstrained; if let Some(result) = record.function_queries[730].get_mut(&__args[..]) { if !__cu && *result.multiplicity == G::ZERO { aiur_fn_730(__args, record, io_buffer, false)? } else { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_730] = unsafe { *(result.output.as_ptr() as *const [G; OUT_730]) }; __ret } } else { aiur_fn_730(__args, record, io_buffer, __cu)? } }; + let __r_arr: [G; OUT_726] = { let __args: [G; IN_726] = [__v_10, __v_2, __v_3, __v_4, __v_5, __v_6, __v_7, __v_8, __v_9]; let __cu = unconstrained; if let Some(result) = record.function_queries[726].get_mut(&__args[..]) { if !__cu && *result.multiplicity == G::ZERO { aiur_fn_726(__args, record, io_buffer, false)? } else { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_726] = unsafe { *(result.output.as_ptr() as *const [G; OUT_726]) }; __ret } } else { aiur_fn_726(__args, record, io_buffer, __cu)? } }; let __v_11: G = __r_arr[0]; let __v_12: G = __r_arr[1]; let __v_13: G = G::from_u64(0); - let __ret: [G; OUT_731] = [__v_13, __v_11, __v_12]; - if let Some(result) = record.function_queries[731].get_mut(&inp[..]) { debug_assert_eq!(result.output, &__ret[..]); if !unconstrained { *result.multiplicity += G::ONE; } } else { record.function_queries[731].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained)); }; + let __ret: [G; OUT_727] = [__v_13, __v_11, __v_12]; + if let Some(result) = record.function_queries[727].get_mut(&inp[..]) { debug_assert_eq!(result.output, &__ret[..]); if !unconstrained { *result.multiplicity += G::ONE; } } else { record.function_queries[727].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained)); }; return Ok(__ret); }, } }) } -const INPUT_SIZE_732: usize = 1; -const IN_732: usize = 1; -const OUT_732: usize = 55; -fn aiur_fn_732( - inp: [G; IN_732], +const INPUT_SIZE_728: usize = 1; +const IN_728: usize = 1; +const OUT_728: usize = 55; +fn aiur_fn_728( + inp: [G; IN_728], record: &mut QueryRecord, io_buffer: &mut IOBuffer, unconstrained: bool, -) -> Result<[G; OUT_732], ExecError> { +) -> Result<[G; OUT_728], ExecError> { stacker::maybe_grow(64 * 1024, 4 * 1024 * 1024, || { let __v_0: G = inp[0]; let __r_arr: [G; OUT_72] = { let __args: [G; IN_72] = [__v_0]; let __cu = unconstrained; if let Some(result) = record.function_queries[72].get_mut(&__args[..]) { if !__cu && *result.multiplicity == G::ZERO { aiur_fn_72(__args, record, io_buffer, false)? } else { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_72] = unsafe { *(result.output.as_ptr() as *const [G; OUT_72]) }; __ret } } else { aiur_fn_72(__args, record, io_buffer, __cu)? } }; @@ -61175,15 +60903,15 @@ fn aiur_fn_732( let __v_27: G = __b1_out[7]; match __v_1.as_canonical_u64() { 0u64 => { - let __r_arr: [G; OUT_724] = { let __args: [G; IN_724] = [__v_12, __v_11]; let __cu = unconstrained; if let Some(result) = record.function_queries[724].get_mut(&__args[..]) { if !__cu && *result.multiplicity == G::ZERO { aiur_fn_724(__args, record, io_buffer, false)? } else { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_724] = unsafe { *(result.output.as_ptr() as *const [G; OUT_724]) }; __ret } } else { aiur_fn_724(__args, record, io_buffer, __cu)? } }; + let __r_arr: [G; OUT_720] = { let __args: [G; IN_720] = [__v_12, __v_11]; let __cu = unconstrained; if let Some(result) = record.function_queries[720].get_mut(&__args[..]) { if !__cu && *result.multiplicity == G::ZERO { aiur_fn_720(__args, record, io_buffer, false)? } else { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_720] = unsafe { *(result.output.as_ptr() as *const [G; OUT_720]) }; __ret } } else { aiur_fn_720(__args, record, io_buffer, __cu)? } }; let __v_28: G = __r_arr[0]; let __v_29: G = __r_arr[1]; let __v_30: G = __r_arr[2]; - let __r_arr: [G; OUT_724] = { let __args: [G; IN_724] = [__v_13, __v_30]; let __cu = unconstrained; if let Some(result) = record.function_queries[724].get_mut(&__args[..]) { if !__cu && *result.multiplicity == G::ZERO { aiur_fn_724(__args, record, io_buffer, false)? } else { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_724] = unsafe { *(result.output.as_ptr() as *const [G; OUT_724]) }; __ret } } else { aiur_fn_724(__args, record, io_buffer, __cu)? } }; + let __r_arr: [G; OUT_720] = { let __args: [G; IN_720] = [__v_13, __v_30]; let __cu = unconstrained; if let Some(result) = record.function_queries[720].get_mut(&__args[..]) { if !__cu && *result.multiplicity == G::ZERO { aiur_fn_720(__args, record, io_buffer, false)? } else { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_720] = unsafe { *(result.output.as_ptr() as *const [G; OUT_720]) }; __ret } } else { aiur_fn_720(__args, record, io_buffer, __cu)? } }; let __v_31: G = __r_arr[0]; let __v_32: G = __r_arr[1]; let __v_33: G = __r_arr[2]; - let __r_arr: [G; OUT_721] = { let __args: [G; IN_721] = [__v_14, __v_33]; let __cu = unconstrained; if let Some(result) = record.function_queries[721].get_mut(&__args[..]) { if !__cu && *result.multiplicity == G::ZERO { aiur_fn_721(__args, record, io_buffer, false)? } else { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_721] = unsafe { *(result.output.as_ptr() as *const [G; OUT_721]) }; __ret } } else { aiur_fn_721(__args, record, io_buffer, __cu)? } }; + let __r_arr: [G; OUT_717] = { let __args: [G; IN_717] = [__v_14, __v_33]; let __cu = unconstrained; if let Some(result) = record.function_queries[717].get_mut(&__args[..]) { if !__cu && *result.multiplicity == G::ZERO { aiur_fn_717(__args, record, io_buffer, false)? } else { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_717] = unsafe { *(result.output.as_ptr() as *const [G; OUT_717]) }; __ret } } else { aiur_fn_717(__args, record, io_buffer, __cu)? } }; let __v_34: G = __r_arr[0]; let __v_35: G = __r_arr[1]; let __v_36: G = __r_arr[2]; @@ -61194,26 +60922,26 @@ fn aiur_fn_732( let __v_41: G = __r_arr[7]; let __v_42: G = __r_arr[8]; let __v_43: G = __r_arr[9]; - let __r_arr: [G; OUT_722] = { let __args: [G; IN_722] = [__v_15, __v_43]; let __cu = unconstrained; if let Some(result) = record.function_queries[722].get_mut(&__args[..]) { if !__cu && *result.multiplicity == G::ZERO { aiur_fn_722(__args, record, io_buffer, false)? } else { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_722] = unsafe { *(result.output.as_ptr() as *const [G; OUT_722]) }; __ret } } else { aiur_fn_722(__args, record, io_buffer, __cu)? } }; + let __r_arr: [G; OUT_718] = { let __args: [G; IN_718] = [__v_15, __v_43]; let __cu = unconstrained; if let Some(result) = record.function_queries[718].get_mut(&__args[..]) { if !__cu && *result.multiplicity == G::ZERO { aiur_fn_718(__args, record, io_buffer, false)? } else { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_718] = unsafe { *(result.output.as_ptr() as *const [G; OUT_718]) }; __ret } } else { aiur_fn_718(__args, record, io_buffer, __cu)? } }; let __v_44: G = __r_arr[0]; let __v_45: G = __r_arr[1]; let __v_46: G = __r_arr[2]; - let __r_arr: [G; OUT_722] = { let __args: [G; IN_722] = [__v_16, __v_46]; let __cu = unconstrained; if let Some(result) = record.function_queries[722].get_mut(&__args[..]) { if !__cu && *result.multiplicity == G::ZERO { aiur_fn_722(__args, record, io_buffer, false)? } else { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_722] = unsafe { *(result.output.as_ptr() as *const [G; OUT_722]) }; __ret } } else { aiur_fn_722(__args, record, io_buffer, __cu)? } }; + let __r_arr: [G; OUT_718] = { let __args: [G; IN_718] = [__v_16, __v_46]; let __cu = unconstrained; if let Some(result) = record.function_queries[718].get_mut(&__args[..]) { if !__cu && *result.multiplicity == G::ZERO { aiur_fn_718(__args, record, io_buffer, false)? } else { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_718] = unsafe { *(result.output.as_ptr() as *const [G; OUT_718]) }; __ret } } else { aiur_fn_718(__args, record, io_buffer, __cu)? } }; let __v_47: G = __r_arr[0]; let __v_48: G = __r_arr[1]; let __v_49: G = __r_arr[2]; let __v_50: G = G::from_u64(0); let __v_51: G = G::from_u64(0); - let __ret: [G; OUT_732] = [__v_50, __v_28, __v_29, __v_31, __v_32, __v_34, __v_35, __v_36, __v_37, __v_38, __v_39, __v_40, __v_41, __v_42, __v_44, __v_45, __v_47, __v_48, __v_51, __v_51, __v_51, __v_51, __v_51, __v_51, __v_51, __v_51, __v_51, __v_51, __v_51, __v_51, __v_51, __v_51, __v_51, __v_51, __v_51, __v_51, __v_51, __v_51, __v_51, __v_51, __v_51, __v_51, __v_51, __v_51, __v_51, __v_51, __v_51, __v_51, __v_51, __v_51, __v_51, __v_51, __v_51, __v_51, __v_49]; - if let Some(result) = record.function_queries[732].get_mut(&inp[..]) { debug_assert_eq!(result.output, &__ret[..]); if !unconstrained { *result.multiplicity += G::ONE; } } else { record.function_queries[732].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained)); }; + let __ret: [G; OUT_728] = [__v_50, __v_28, __v_29, __v_31, __v_32, __v_34, __v_35, __v_36, __v_37, __v_38, __v_39, __v_40, __v_41, __v_42, __v_44, __v_45, __v_47, __v_48, __v_51, __v_51, __v_51, __v_51, __v_51, __v_51, __v_51, __v_51, __v_51, __v_51, __v_51, __v_51, __v_51, __v_51, __v_51, __v_51, __v_51, __v_51, __v_51, __v_51, __v_51, __v_51, __v_51, __v_51, __v_51, __v_51, __v_51, __v_51, __v_51, __v_51, __v_51, __v_51, __v_51, __v_51, __v_51, __v_51, __v_49]; + if let Some(result) = record.function_queries[728].get_mut(&inp[..]) { debug_assert_eq!(result.output, &__ret[..]); if !unconstrained { *result.multiplicity += G::ONE; } } else { record.function_queries[728].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained)); }; return Ok(__ret); }, 1u64 => { - let __r_arr: [G; OUT_723] = { let __args: [G; IN_723] = [__v_12, __v_11]; let __cu = unconstrained; if let Some(result) = record.function_queries[723].get_mut(&__args[..]) { if !__cu && *result.multiplicity == G::ZERO { aiur_fn_723(__args, record, io_buffer, false)? } else { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_723] = unsafe { *(result.output.as_ptr() as *const [G; OUT_723]) }; __ret } } else { aiur_fn_723(__args, record, io_buffer, __cu)? } }; + let __r_arr: [G; OUT_719] = { let __args: [G; IN_719] = [__v_12, __v_11]; let __cu = unconstrained; if let Some(result) = record.function_queries[719].get_mut(&__args[..]) { if !__cu && *result.multiplicity == G::ZERO { aiur_fn_719(__args, record, io_buffer, false)? } else { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_719] = unsafe { *(result.output.as_ptr() as *const [G; OUT_719]) }; __ret } } else { aiur_fn_719(__args, record, io_buffer, __cu)? } }; let __v_28: G = __r_arr[0]; let __v_29: G = __r_arr[1]; let __v_30: G = __r_arr[2]; - let __r_arr: [G; OUT_721] = { let __args: [G; IN_721] = [__v_13, __v_30]; let __cu = unconstrained; if let Some(result) = record.function_queries[721].get_mut(&__args[..]) { if !__cu && *result.multiplicity == G::ZERO { aiur_fn_721(__args, record, io_buffer, false)? } else { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_721] = unsafe { *(result.output.as_ptr() as *const [G; OUT_721]) }; __ret } } else { aiur_fn_721(__args, record, io_buffer, __cu)? } }; + let __r_arr: [G; OUT_717] = { let __args: [G; IN_717] = [__v_13, __v_30]; let __cu = unconstrained; if let Some(result) = record.function_queries[717].get_mut(&__args[..]) { if !__cu && *result.multiplicity == G::ZERO { aiur_fn_717(__args, record, io_buffer, false)? } else { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_717] = unsafe { *(result.output.as_ptr() as *const [G; OUT_717]) }; __ret } } else { aiur_fn_717(__args, record, io_buffer, __cu)? } }; let __v_31: G = __r_arr[0]; let __v_32: G = __r_arr[1]; let __v_33: G = __r_arr[2]; @@ -61224,7 +60952,7 @@ fn aiur_fn_732( let __v_38: G = __r_arr[7]; let __v_39: G = __r_arr[8]; let __v_40: G = __r_arr[9]; - let __r_arr: [G; OUT_721] = { let __args: [G; IN_721] = [__v_14, __v_40]; let __cu = unconstrained; if let Some(result) = record.function_queries[721].get_mut(&__args[..]) { if !__cu && *result.multiplicity == G::ZERO { aiur_fn_721(__args, record, io_buffer, false)? } else { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_721] = unsafe { *(result.output.as_ptr() as *const [G; OUT_721]) }; __ret } } else { aiur_fn_721(__args, record, io_buffer, __cu)? } }; + let __r_arr: [G; OUT_717] = { let __args: [G; IN_717] = [__v_14, __v_40]; let __cu = unconstrained; if let Some(result) = record.function_queries[717].get_mut(&__args[..]) { if !__cu && *result.multiplicity == G::ZERO { aiur_fn_717(__args, record, io_buffer, false)? } else { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_717] = unsafe { *(result.output.as_ptr() as *const [G; OUT_717]) }; __ret } } else { aiur_fn_717(__args, record, io_buffer, __cu)? } }; let __v_41: G = __r_arr[0]; let __v_42: G = __r_arr[1]; let __v_43: G = __r_arr[2]; @@ -61235,7 +60963,7 @@ fn aiur_fn_732( let __v_48: G = __r_arr[7]; let __v_49: G = __r_arr[8]; let __v_50: G = __r_arr[9]; - let __r_arr: [G; OUT_721] = { let __args: [G; IN_721] = [__v_15, __v_50]; let __cu = unconstrained; if let Some(result) = record.function_queries[721].get_mut(&__args[..]) { if !__cu && *result.multiplicity == G::ZERO { aiur_fn_721(__args, record, io_buffer, false)? } else { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_721] = unsafe { *(result.output.as_ptr() as *const [G; OUT_721]) }; __ret } } else { aiur_fn_721(__args, record, io_buffer, __cu)? } }; + let __r_arr: [G; OUT_717] = { let __args: [G; IN_717] = [__v_15, __v_50]; let __cu = unconstrained; if let Some(result) = record.function_queries[717].get_mut(&__args[..]) { if !__cu && *result.multiplicity == G::ZERO { aiur_fn_717(__args, record, io_buffer, false)? } else { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_717] = unsafe { *(result.output.as_ptr() as *const [G; OUT_717]) }; __ret } } else { aiur_fn_717(__args, record, io_buffer, __cu)? } }; let __v_51: G = __r_arr[0]; let __v_52: G = __r_arr[1]; let __v_53: G = __r_arr[2]; @@ -61246,30 +60974,30 @@ fn aiur_fn_732( let __v_58: G = __r_arr[7]; let __v_59: G = __r_arr[8]; let __v_60: G = __r_arr[9]; - let __r_arr: [G; OUT_722] = { let __args: [G; IN_722] = [__v_16, __v_60]; let __cu = unconstrained; if let Some(result) = record.function_queries[722].get_mut(&__args[..]) { if !__cu && *result.multiplicity == G::ZERO { aiur_fn_722(__args, record, io_buffer, false)? } else { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_722] = unsafe { *(result.output.as_ptr() as *const [G; OUT_722]) }; __ret } } else { aiur_fn_722(__args, record, io_buffer, __cu)? } }; + let __r_arr: [G; OUT_718] = { let __args: [G; IN_718] = [__v_16, __v_60]; let __cu = unconstrained; if let Some(result) = record.function_queries[718].get_mut(&__args[..]) { if !__cu && *result.multiplicity == G::ZERO { aiur_fn_718(__args, record, io_buffer, false)? } else { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_718] = unsafe { *(result.output.as_ptr() as *const [G; OUT_718]) }; __ret } } else { aiur_fn_718(__args, record, io_buffer, __cu)? } }; let __v_61: G = __r_arr[0]; let __v_62: G = __r_arr[1]; let __v_63: G = __r_arr[2]; - let __r_arr: [G; OUT_731] = { let __args: [G; IN_731] = [__v_17, __v_63]; let __cu = unconstrained; if let Some(result) = record.function_queries[731].get_mut(&__args[..]) { if !__cu && *result.multiplicity == G::ZERO { aiur_fn_731(__args, record, io_buffer, false)? } else { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_731] = unsafe { *(result.output.as_ptr() as *const [G; OUT_731]) }; __ret } } else { aiur_fn_731(__args, record, io_buffer, __cu)? } }; + let __r_arr: [G; OUT_727] = { let __args: [G; IN_727] = [__v_17, __v_63]; let __cu = unconstrained; if let Some(result) = record.function_queries[727].get_mut(&__args[..]) { if !__cu && *result.multiplicity == G::ZERO { aiur_fn_727(__args, record, io_buffer, false)? } else { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_727] = unsafe { *(result.output.as_ptr() as *const [G; OUT_727]) }; __ret } } else { aiur_fn_727(__args, record, io_buffer, __cu)? } }; let __v_64: G = __r_arr[0]; let __v_65: G = __r_arr[1]; let __v_66: G = __r_arr[2]; let __v_67: G = G::from_u64(1); let __v_68: G = G::from_u64(0); - let __ret: [G; OUT_732] = [__v_67, __v_28, __v_29, __v_31, __v_32, __v_33, __v_34, __v_35, __v_36, __v_37, __v_38, __v_39, __v_41, __v_42, __v_43, __v_44, __v_45, __v_46, __v_47, __v_48, __v_49, __v_51, __v_52, __v_53, __v_54, __v_55, __v_56, __v_57, __v_58, __v_59, __v_61, __v_62, __v_64, __v_65, __v_68, __v_68, __v_68, __v_68, __v_68, __v_68, __v_68, __v_68, __v_68, __v_68, __v_68, __v_68, __v_68, __v_68, __v_68, __v_68, __v_68, __v_68, __v_68, __v_68, __v_66]; - if let Some(result) = record.function_queries[732].get_mut(&inp[..]) { debug_assert_eq!(result.output, &__ret[..]); if !unconstrained { *result.multiplicity += G::ONE; } } else { record.function_queries[732].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained)); }; + let __ret: [G; OUT_728] = [__v_67, __v_28, __v_29, __v_31, __v_32, __v_33, __v_34, __v_35, __v_36, __v_37, __v_38, __v_39, __v_41, __v_42, __v_43, __v_44, __v_45, __v_46, __v_47, __v_48, __v_49, __v_51, __v_52, __v_53, __v_54, __v_55, __v_56, __v_57, __v_58, __v_59, __v_61, __v_62, __v_64, __v_65, __v_68, __v_68, __v_68, __v_68, __v_68, __v_68, __v_68, __v_68, __v_68, __v_68, __v_68, __v_68, __v_68, __v_68, __v_68, __v_68, __v_68, __v_68, __v_68, __v_68, __v_66]; + if let Some(result) = record.function_queries[728].get_mut(&inp[..]) { debug_assert_eq!(result.output, &__ret[..]); if !unconstrained { *result.multiplicity += G::ONE; } } else { record.function_queries[728].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained)); }; return Ok(__ret); }, 2u64 => { - let __r_arr: [G; OUT_723] = { let __args: [G; IN_723] = [__v_12, __v_11]; let __cu = unconstrained; if let Some(result) = record.function_queries[723].get_mut(&__args[..]) { if !__cu && *result.multiplicity == G::ZERO { aiur_fn_723(__args, record, io_buffer, false)? } else { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_723] = unsafe { *(result.output.as_ptr() as *const [G; OUT_723]) }; __ret } } else { aiur_fn_723(__args, record, io_buffer, __cu)? } }; + let __r_arr: [G; OUT_719] = { let __args: [G; IN_719] = [__v_12, __v_11]; let __cu = unconstrained; if let Some(result) = record.function_queries[719].get_mut(&__args[..]) { if !__cu && *result.multiplicity == G::ZERO { aiur_fn_719(__args, record, io_buffer, false)? } else { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_719] = unsafe { *(result.output.as_ptr() as *const [G; OUT_719]) }; __ret } } else { aiur_fn_719(__args, record, io_buffer, __cu)? } }; let __v_28: G = __r_arr[0]; let __v_29: G = __r_arr[1]; let __v_30: G = __r_arr[2]; - let __r_arr: [G; OUT_723] = { let __args: [G; IN_723] = [__v_13, __v_30]; let __cu = unconstrained; if let Some(result) = record.function_queries[723].get_mut(&__args[..]) { if !__cu && *result.multiplicity == G::ZERO { aiur_fn_723(__args, record, io_buffer, false)? } else { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_723] = unsafe { *(result.output.as_ptr() as *const [G; OUT_723]) }; __ret } } else { aiur_fn_723(__args, record, io_buffer, __cu)? } }; + let __r_arr: [G; OUT_719] = { let __args: [G; IN_719] = [__v_13, __v_30]; let __cu = unconstrained; if let Some(result) = record.function_queries[719].get_mut(&__args[..]) { if !__cu && *result.multiplicity == G::ZERO { aiur_fn_719(__args, record, io_buffer, false)? } else { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_719] = unsafe { *(result.output.as_ptr() as *const [G; OUT_719]) }; __ret } } else { aiur_fn_719(__args, record, io_buffer, __cu)? } }; let __v_31: G = __r_arr[0]; let __v_32: G = __r_arr[1]; let __v_33: G = __r_arr[2]; - let __r_arr: [G; OUT_721] = { let __args: [G; IN_721] = [__v_14, __v_33]; let __cu = unconstrained; if let Some(result) = record.function_queries[721].get_mut(&__args[..]) { if !__cu && *result.multiplicity == G::ZERO { aiur_fn_721(__args, record, io_buffer, false)? } else { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_721] = unsafe { *(result.output.as_ptr() as *const [G; OUT_721]) }; __ret } } else { aiur_fn_721(__args, record, io_buffer, __cu)? } }; + let __r_arr: [G; OUT_717] = { let __args: [G; IN_717] = [__v_14, __v_33]; let __cu = unconstrained; if let Some(result) = record.function_queries[717].get_mut(&__args[..]) { if !__cu && *result.multiplicity == G::ZERO { aiur_fn_717(__args, record, io_buffer, false)? } else { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_717] = unsafe { *(result.output.as_ptr() as *const [G; OUT_717]) }; __ret } } else { aiur_fn_717(__args, record, io_buffer, __cu)? } }; let __v_34: G = __r_arr[0]; let __v_35: G = __r_arr[1]; let __v_36: G = __r_arr[2]; @@ -61280,7 +61008,7 @@ fn aiur_fn_732( let __v_41: G = __r_arr[7]; let __v_42: G = __r_arr[8]; let __v_43: G = __r_arr[9]; - let __r_arr: [G; OUT_721] = { let __args: [G; IN_721] = [__v_15, __v_43]; let __cu = unconstrained; if let Some(result) = record.function_queries[721].get_mut(&__args[..]) { if !__cu && *result.multiplicity == G::ZERO { aiur_fn_721(__args, record, io_buffer, false)? } else { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_721] = unsafe { *(result.output.as_ptr() as *const [G; OUT_721]) }; __ret } } else { aiur_fn_721(__args, record, io_buffer, __cu)? } }; + let __r_arr: [G; OUT_717] = { let __args: [G; IN_717] = [__v_15, __v_43]; let __cu = unconstrained; if let Some(result) = record.function_queries[717].get_mut(&__args[..]) { if !__cu && *result.multiplicity == G::ZERO { aiur_fn_717(__args, record, io_buffer, false)? } else { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_717] = unsafe { *(result.output.as_ptr() as *const [G; OUT_717]) }; __ret } } else { aiur_fn_717(__args, record, io_buffer, __cu)? } }; let __v_44: G = __r_arr[0]; let __v_45: G = __r_arr[1]; let __v_46: G = __r_arr[2]; @@ -61291,7 +61019,7 @@ fn aiur_fn_732( let __v_51: G = __r_arr[7]; let __v_52: G = __r_arr[8]; let __v_53: G = __r_arr[9]; - let __r_arr: [G; OUT_721] = { let __args: [G; IN_721] = [__v_16, __v_53]; let __cu = unconstrained; if let Some(result) = record.function_queries[721].get_mut(&__args[..]) { if !__cu && *result.multiplicity == G::ZERO { aiur_fn_721(__args, record, io_buffer, false)? } else { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_721] = unsafe { *(result.output.as_ptr() as *const [G; OUT_721]) }; __ret } } else { aiur_fn_721(__args, record, io_buffer, __cu)? } }; + let __r_arr: [G; OUT_717] = { let __args: [G; IN_717] = [__v_16, __v_53]; let __cu = unconstrained; if let Some(result) = record.function_queries[717].get_mut(&__args[..]) { if !__cu && *result.multiplicity == G::ZERO { aiur_fn_717(__args, record, io_buffer, false)? } else { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_717] = unsafe { *(result.output.as_ptr() as *const [G; OUT_717]) }; __ret } } else { aiur_fn_717(__args, record, io_buffer, __cu)? } }; let __v_54: G = __r_arr[0]; let __v_55: G = __r_arr[1]; let __v_56: G = __r_arr[2]; @@ -61302,7 +61030,7 @@ fn aiur_fn_732( let __v_61: G = __r_arr[7]; let __v_62: G = __r_arr[8]; let __v_63: G = __r_arr[9]; - let __r_arr: [G; OUT_721] = { let __args: [G; IN_721] = [__v_17, __v_63]; let __cu = unconstrained; if let Some(result) = record.function_queries[721].get_mut(&__args[..]) { if !__cu && *result.multiplicity == G::ZERO { aiur_fn_721(__args, record, io_buffer, false)? } else { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_721] = unsafe { *(result.output.as_ptr() as *const [G; OUT_721]) }; __ret } } else { aiur_fn_721(__args, record, io_buffer, __cu)? } }; + let __r_arr: [G; OUT_717] = { let __args: [G; IN_717] = [__v_17, __v_63]; let __cu = unconstrained; if let Some(result) = record.function_queries[717].get_mut(&__args[..]) { if !__cu && *result.multiplicity == G::ZERO { aiur_fn_717(__args, record, io_buffer, false)? } else { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_717] = unsafe { *(result.output.as_ptr() as *const [G; OUT_717]) }; __ret } } else { aiur_fn_717(__args, record, io_buffer, __cu)? } }; let __v_64: G = __r_arr[0]; let __v_65: G = __r_arr[1]; let __v_66: G = __r_arr[2]; @@ -61313,7 +61041,7 @@ fn aiur_fn_732( let __v_71: G = __r_arr[7]; let __v_72: G = __r_arr[8]; let __v_73: G = __r_arr[9]; - let __r_arr: [G; OUT_721] = { let __args: [G; IN_721] = [__v_18, __v_73]; let __cu = unconstrained; if let Some(result) = record.function_queries[721].get_mut(&__args[..]) { if !__cu && *result.multiplicity == G::ZERO { aiur_fn_721(__args, record, io_buffer, false)? } else { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_721] = unsafe { *(result.output.as_ptr() as *const [G; OUT_721]) }; __ret } } else { aiur_fn_721(__args, record, io_buffer, __cu)? } }; + let __r_arr: [G; OUT_717] = { let __args: [G; IN_717] = [__v_18, __v_73]; let __cu = unconstrained; if let Some(result) = record.function_queries[717].get_mut(&__args[..]) { if !__cu && *result.multiplicity == G::ZERO { aiur_fn_717(__args, record, io_buffer, false)? } else { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_717] = unsafe { *(result.output.as_ptr() as *const [G; OUT_717]) }; __ret } } else { aiur_fn_717(__args, record, io_buffer, __cu)? } }; let __v_74: G = __r_arr[0]; let __v_75: G = __r_arr[1]; let __v_76: G = __r_arr[2]; @@ -61324,17 +61052,17 @@ fn aiur_fn_732( let __v_81: G = __r_arr[7]; let __v_82: G = __r_arr[8]; let __v_83: G = __r_arr[9]; - let __r_arr: [G; OUT_722] = { let __args: [G; IN_722] = [__v_19, __v_83]; let __cu = unconstrained; if let Some(result) = record.function_queries[722].get_mut(&__args[..]) { if !__cu && *result.multiplicity == G::ZERO { aiur_fn_722(__args, record, io_buffer, false)? } else { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_722] = unsafe { *(result.output.as_ptr() as *const [G; OUT_722]) }; __ret } } else { aiur_fn_722(__args, record, io_buffer, __cu)? } }; + let __r_arr: [G; OUT_718] = { let __args: [G; IN_718] = [__v_19, __v_83]; let __cu = unconstrained; if let Some(result) = record.function_queries[718].get_mut(&__args[..]) { if !__cu && *result.multiplicity == G::ZERO { aiur_fn_718(__args, record, io_buffer, false)? } else { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_718] = unsafe { *(result.output.as_ptr() as *const [G; OUT_718]) }; __ret } } else { aiur_fn_718(__args, record, io_buffer, __cu)? } }; let __v_84: G = __r_arr[0]; let __v_85: G = __r_arr[1]; let __v_86: G = __r_arr[2]; - let __r_arr: [G; OUT_727] = { let __args: [G; IN_727] = [__v_20, __v_86]; let __cu = unconstrained; if let Some(result) = record.function_queries[727].get_mut(&__args[..]) { if !__cu && *result.multiplicity == G::ZERO { aiur_fn_727(__args, record, io_buffer, false)? } else { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_727] = unsafe { *(result.output.as_ptr() as *const [G; OUT_727]) }; __ret } } else { aiur_fn_727(__args, record, io_buffer, __cu)? } }; + let __r_arr: [G; OUT_723] = { let __args: [G; IN_723] = [__v_20, __v_86]; let __cu = unconstrained; if let Some(result) = record.function_queries[723].get_mut(&__args[..]) { if !__cu && *result.multiplicity == G::ZERO { aiur_fn_723(__args, record, io_buffer, false)? } else { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_723] = unsafe { *(result.output.as_ptr() as *const [G; OUT_723]) }; __ret } } else { aiur_fn_723(__args, record, io_buffer, __cu)? } }; let __v_87: G = __r_arr[0]; let __v_88: G = __r_arr[1]; let __v_89: G = __r_arr[2]; let __v_90: G = G::from_u64(2); - let __ret: [G; OUT_732] = [__v_90, __v_28, __v_29, __v_31, __v_32, __v_34, __v_35, __v_36, __v_37, __v_38, __v_39, __v_40, __v_41, __v_42, __v_44, __v_45, __v_46, __v_47, __v_48, __v_49, __v_50, __v_51, __v_52, __v_54, __v_55, __v_56, __v_57, __v_58, __v_59, __v_60, __v_61, __v_62, __v_64, __v_65, __v_66, __v_67, __v_68, __v_69, __v_70, __v_71, __v_72, __v_74, __v_75, __v_76, __v_77, __v_78, __v_79, __v_80, __v_81, __v_82, __v_84, __v_85, __v_87, __v_88, __v_89]; - if let Some(result) = record.function_queries[732].get_mut(&inp[..]) { debug_assert_eq!(result.output, &__ret[..]); if !unconstrained { *result.multiplicity += G::ONE; } } else { record.function_queries[732].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained)); }; + let __ret: [G; OUT_728] = [__v_90, __v_28, __v_29, __v_31, __v_32, __v_34, __v_35, __v_36, __v_37, __v_38, __v_39, __v_40, __v_41, __v_42, __v_44, __v_45, __v_46, __v_47, __v_48, __v_49, __v_50, __v_51, __v_52, __v_54, __v_55, __v_56, __v_57, __v_58, __v_59, __v_60, __v_61, __v_62, __v_64, __v_65, __v_66, __v_67, __v_68, __v_69, __v_70, __v_71, __v_72, __v_74, __v_75, __v_76, __v_77, __v_78, __v_79, __v_80, __v_81, __v_82, __v_84, __v_85, __v_87, __v_88, __v_89]; + if let Some(result) = record.function_queries[728].get_mut(&inp[..]) { debug_assert_eq!(result.output, &__ret[..]); if !unconstrained { *result.multiplicity += G::ONE; } } else { record.function_queries[728].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained)); }; return Ok(__ret); }, _ => { @@ -61344,15 +61072,15 @@ fn aiur_fn_732( }) } -const INPUT_SIZE_733: usize = 1; -const IN_733: usize = 1; -const OUT_733: usize = 63; -fn aiur_fn_733( - inp: [G; IN_733], +const INPUT_SIZE_729: usize = 1; +const IN_729: usize = 1; +const OUT_729: usize = 63; +fn aiur_fn_729( + inp: [G; IN_729], record: &mut QueryRecord, io_buffer: &mut IOBuffer, unconstrained: bool, -) -> Result<[G; OUT_733], ExecError> { +) -> Result<[G; OUT_729], ExecError> { stacker::maybe_grow(64 * 1024, 4 * 1024 * 1024, || { let __v_0: G = inp[0]; let __r_arr: [G; OUT_74] = { let __args: [G; IN_74] = [__v_0]; let __cu = unconstrained; if let Some(result) = record.function_queries[74].get_mut(&__args[..]) { if !__cu && *result.multiplicity == G::ZERO { aiur_fn_74(__args, record, io_buffer, false)? } else { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_74] = unsafe { *(result.output.as_ptr() as *const [G; OUT_74]) }; __ret } } else { aiur_fn_74(__args, record, io_buffer, __cu)? } }; @@ -61365,7 +61093,7 @@ fn aiur_fn_733( let __v_7: G = __r_arr[6]; let __v_8: G = __r_arr[7]; let __v_9: G = __r_arr[8]; - let __r_arr: [G; OUT_732] = { let __args: [G; IN_732] = [__v_9]; let __cu = unconstrained; if let Some(result) = record.function_queries[732].get_mut(&__args[..]) { if !__cu && *result.multiplicity == G::ZERO { aiur_fn_732(__args, record, io_buffer, false)? } else { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_732] = unsafe { *(result.output.as_ptr() as *const [G; OUT_732]) }; __ret } } else { aiur_fn_732(__args, record, io_buffer, __cu)? } }; + let __r_arr: [G; OUT_728] = { let __args: [G; IN_728] = [__v_9]; let __cu = unconstrained; if let Some(result) = record.function_queries[728].get_mut(&__args[..]) { if !__cu && *result.multiplicity == G::ZERO { aiur_fn_728(__args, record, io_buffer, false)? } else { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_728] = unsafe { *(result.output.as_ptr() as *const [G; OUT_728]) }; __ret } } else { aiur_fn_728(__args, record, io_buffer, __cu)? } }; let __v_10: G = __r_arr[0]; let __v_11: G = __r_arr[1]; let __v_12: G = __r_arr[2]; @@ -61421,21 +61149,21 @@ fn aiur_fn_733( let __v_62: G = __r_arr[52]; let __v_63: G = __r_arr[53]; let __v_64: G = __r_arr[54]; - let __ret: [G; OUT_733] = [__v_1, __v_2, __v_3, __v_4, __v_5, __v_6, __v_7, __v_8, __v_10, __v_11, __v_12, __v_13, __v_14, __v_15, __v_16, __v_17, __v_18, __v_19, __v_20, __v_21, __v_22, __v_23, __v_24, __v_25, __v_26, __v_27, __v_28, __v_29, __v_30, __v_31, __v_32, __v_33, __v_34, __v_35, __v_36, __v_37, __v_38, __v_39, __v_40, __v_41, __v_42, __v_43, __v_44, __v_45, __v_46, __v_47, __v_48, __v_49, __v_50, __v_51, __v_52, __v_53, __v_54, __v_55, __v_56, __v_57, __v_58, __v_59, __v_60, __v_61, __v_62, __v_63, __v_64]; - if let Some(result) = record.function_queries[733].get_mut(&inp[..]) { debug_assert_eq!(result.output, &__ret[..]); if !unconstrained { *result.multiplicity += G::ONE; } } else { record.function_queries[733].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained)); }; + let __ret: [G; OUT_729] = [__v_1, __v_2, __v_3, __v_4, __v_5, __v_6, __v_7, __v_8, __v_10, __v_11, __v_12, __v_13, __v_14, __v_15, __v_16, __v_17, __v_18, __v_19, __v_20, __v_21, __v_22, __v_23, __v_24, __v_25, __v_26, __v_27, __v_28, __v_29, __v_30, __v_31, __v_32, __v_33, __v_34, __v_35, __v_36, __v_37, __v_38, __v_39, __v_40, __v_41, __v_42, __v_43, __v_44, __v_45, __v_46, __v_47, __v_48, __v_49, __v_50, __v_51, __v_52, __v_53, __v_54, __v_55, __v_56, __v_57, __v_58, __v_59, __v_60, __v_61, __v_62, __v_63, __v_64]; + if let Some(result) = record.function_queries[729].get_mut(&inp[..]) { debug_assert_eq!(result.output, &__ret[..]); if !unconstrained { *result.multiplicity += G::ONE; } } else { record.function_queries[729].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained)); }; return Ok(__ret); }) } -const INPUT_SIZE_734: usize = 9; -const IN_734: usize = 9; -const OUT_734: usize = 2; -fn aiur_fn_734( - inp: [G; IN_734], +const INPUT_SIZE_730: usize = 9; +const IN_730: usize = 9; +const OUT_730: usize = 2; +fn aiur_fn_730( + inp: [G; IN_730], record: &mut QueryRecord, io_buffer: &mut IOBuffer, unconstrained: bool, -) -> Result<[G; OUT_734], ExecError> { +) -> Result<[G; OUT_730], ExecError> { stacker::maybe_grow(64 * 1024, 4 * 1024 * 1024, || { let __v_0: G = inp[0]; let __v_1: G = inp[1]; @@ -61453,12 +61181,12 @@ fn aiur_fn_734( let __v_10: G = G::from_u64(1); let __v_11: G = G::from_u64(1); let __v_12: G = { let __values: [G; 64] = [__v_10, __v_11, __v_11, __v_11, __v_11, __v_11, __v_11, __v_11, __v_11, __v_11, __v_11, __v_11, __v_11, __v_11, __v_11, __v_11, __v_11, __v_11, __v_11, __v_11, __v_11, __v_11, __v_11, __v_11, __v_11, __v_11, __v_11, __v_11, __v_11, __v_11, __v_11, __v_11, __v_11, __v_11, __v_11, __v_11, __v_11, __v_11, __v_11, __v_11, __v_11, __v_11, __v_11, __v_11, __v_11, __v_11, __v_11, __v_11, __v_11, __v_11, __v_11, __v_11, __v_11, __v_11, __v_11, __v_11, __v_11, __v_11, __v_11, __v_11, __v_11, __v_11, __v_11, __v_11]; let __mq = record.memory_queries.get_mut(&64).ok_or(ExecError::InvalidMemorySize(64))?; if let Some(result) = __mq.get_mut(&__values[..]) { if !unconstrained { *result.multiplicity += G::ONE; } result.output[0] } else { let __ptr = G::from_usize(__mq.len()); __mq.insert(&__values[..], &[__ptr], G::from_bool(!unconstrained)); __ptr } }; - let __ret: [G; OUT_734] = [__v_12, __v_0]; - if let Some(result) = record.function_queries[734].get_mut(&inp[..]) { debug_assert_eq!(result.output, &__ret[..]); if !unconstrained { *result.multiplicity += G::ONE; } } else { record.function_queries[734].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained)); }; + let __ret: [G; OUT_730] = [__v_12, __v_0]; + if let Some(result) = record.function_queries[730].get_mut(&inp[..]) { debug_assert_eq!(result.output, &__ret[..]); if !unconstrained { *result.multiplicity += G::ONE; } } else { record.function_queries[730].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained)); }; return Ok(__ret); }, _ => { - let __r_arr: [G; OUT_733] = { let __args: [G; IN_733] = [__v_0]; let __cu = unconstrained; if let Some(result) = record.function_queries[733].get_mut(&__args[..]) { if !__cu && *result.multiplicity == G::ZERO { aiur_fn_733(__args, record, io_buffer, false)? } else { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_733] = unsafe { *(result.output.as_ptr() as *const [G; OUT_733]) }; __ret } } else { aiur_fn_733(__args, record, io_buffer, __cu)? } }; + let __r_arr: [G; OUT_729] = { let __args: [G; IN_729] = [__v_0]; let __cu = unconstrained; if let Some(result) = record.function_queries[729].get_mut(&__args[..]) { if !__cu && *result.multiplicity == G::ZERO { aiur_fn_729(__args, record, io_buffer, false)? } else { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_729] = unsafe { *(result.output.as_ptr() as *const [G; OUT_729]) }; __ret } } else { aiur_fn_729(__args, record, io_buffer, __cu)? } }; let __v_10: G = __r_arr[0]; let __v_11: G = __r_arr[1]; let __v_12: G = __r_arr[2]; @@ -61531,28 +61259,28 @@ fn aiur_fn_734( let __v_78: G = __r_arr[5]; let __v_79: G = __r_arr[6]; let __v_80: G = __r_arr[7]; - let __r_arr: [G; OUT_734] = { let __args: [G; IN_734] = [__v_72, __v_73, __v_74, __v_75, __v_76, __v_77, __v_78, __v_79, __v_80]; let __cu = unconstrained; if let Some(result) = record.function_queries[734].get_mut(&__args[..]) { if !__cu && *result.multiplicity == G::ZERO { aiur_fn_734(__args, record, io_buffer, false)? } else { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_734] = unsafe { *(result.output.as_ptr() as *const [G; OUT_734]) }; __ret } } else { aiur_fn_734(__args, record, io_buffer, __cu)? } }; + let __r_arr: [G; OUT_730] = { let __args: [G; IN_730] = [__v_72, __v_73, __v_74, __v_75, __v_76, __v_77, __v_78, __v_79, __v_80]; let __cu = unconstrained; if let Some(result) = record.function_queries[730].get_mut(&__args[..]) { if !__cu && *result.multiplicity == G::ZERO { aiur_fn_730(__args, record, io_buffer, false)? } else { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_730] = unsafe { *(result.output.as_ptr() as *const [G; OUT_730]) }; __ret } } else { aiur_fn_730(__args, record, io_buffer, __cu)? } }; let __v_81: G = __r_arr[0]; let __v_82: G = __r_arr[1]; let __v_83: G = G::from_u64(0); let __v_84: G = { let __values: [G; 64] = [__v_83, __v_10, __v_11, __v_12, __v_13, __v_14, __v_15, __v_16, __v_17, __v_18, __v_19, __v_20, __v_21, __v_22, __v_23, __v_24, __v_25, __v_26, __v_27, __v_28, __v_29, __v_30, __v_31, __v_32, __v_33, __v_34, __v_35, __v_36, __v_37, __v_38, __v_39, __v_40, __v_41, __v_42, __v_43, __v_44, __v_45, __v_46, __v_47, __v_48, __v_49, __v_50, __v_51, __v_52, __v_53, __v_54, __v_55, __v_56, __v_57, __v_58, __v_59, __v_60, __v_61, __v_62, __v_63, __v_64, __v_65, __v_66, __v_67, __v_68, __v_69, __v_70, __v_71, __v_81]; let __mq = record.memory_queries.get_mut(&64).ok_or(ExecError::InvalidMemorySize(64))?; if let Some(result) = __mq.get_mut(&__values[..]) { if !unconstrained { *result.multiplicity += G::ONE; } result.output[0] } else { let __ptr = G::from_usize(__mq.len()); __mq.insert(&__values[..], &[__ptr], G::from_bool(!unconstrained)); __ptr } }; - let __ret: [G; OUT_734] = [__v_84, __v_82]; - if let Some(result) = record.function_queries[734].get_mut(&inp[..]) { debug_assert_eq!(result.output, &__ret[..]); if !unconstrained { *result.multiplicity += G::ONE; } } else { record.function_queries[734].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained)); }; + let __ret: [G; OUT_730] = [__v_84, __v_82]; + if let Some(result) = record.function_queries[730].get_mut(&inp[..]) { debug_assert_eq!(result.output, &__ret[..]); if !unconstrained { *result.multiplicity += G::ONE; } } else { record.function_queries[730].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained)); }; return Ok(__ret); }, } }) } -const INPUT_SIZE_735: usize = 1; -const IN_735: usize = 1; -const OUT_735: usize = 55; -fn aiur_fn_735( - inp: [G; IN_735], +const INPUT_SIZE_731: usize = 1; +const IN_731: usize = 1; +const OUT_731: usize = 55; +fn aiur_fn_731( + inp: [G; IN_731], record: &mut QueryRecord, io_buffer: &mut IOBuffer, unconstrained: bool, -) -> Result<[G; OUT_735], ExecError> { +) -> Result<[G; OUT_731], ExecError> { stacker::maybe_grow(64 * 1024, 4 * 1024 * 1024, || { let __v_0: G = inp[0]; let __r_arr: [G; OUT_72] = { let __args: [G; IN_72] = [__v_0]; let __cu = unconstrained; if let Some(result) = record.function_queries[72].get_mut(&__args[..]) { if !__cu && *result.multiplicity == G::ZERO { aiur_fn_72(__args, record, io_buffer, false)? } else { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_72] = unsafe { *(result.output.as_ptr() as *const [G; OUT_72]) }; __ret } } else { aiur_fn_72(__args, record, io_buffer, __cu)? } }; @@ -61588,15 +61316,15 @@ fn aiur_fn_735( let __v_27: G = __b1_out[7]; match __v_1.as_canonical_u64() { 0u64 => { - let __r_arr: [G; OUT_724] = { let __args: [G; IN_724] = [__v_12, __v_11]; let __cu = unconstrained; if let Some(result) = record.function_queries[724].get_mut(&__args[..]) { if !__cu && *result.multiplicity == G::ZERO { aiur_fn_724(__args, record, io_buffer, false)? } else { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_724] = unsafe { *(result.output.as_ptr() as *const [G; OUT_724]) }; __ret } } else { aiur_fn_724(__args, record, io_buffer, __cu)? } }; + let __r_arr: [G; OUT_720] = { let __args: [G; IN_720] = [__v_12, __v_11]; let __cu = unconstrained; if let Some(result) = record.function_queries[720].get_mut(&__args[..]) { if !__cu && *result.multiplicity == G::ZERO { aiur_fn_720(__args, record, io_buffer, false)? } else { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_720] = unsafe { *(result.output.as_ptr() as *const [G; OUT_720]) }; __ret } } else { aiur_fn_720(__args, record, io_buffer, __cu)? } }; let __v_28: G = __r_arr[0]; let __v_29: G = __r_arr[1]; let __v_30: G = __r_arr[2]; - let __r_arr: [G; OUT_724] = { let __args: [G; IN_724] = [__v_13, __v_30]; let __cu = unconstrained; if let Some(result) = record.function_queries[724].get_mut(&__args[..]) { if !__cu && *result.multiplicity == G::ZERO { aiur_fn_724(__args, record, io_buffer, false)? } else { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_724] = unsafe { *(result.output.as_ptr() as *const [G; OUT_724]) }; __ret } } else { aiur_fn_724(__args, record, io_buffer, __cu)? } }; + let __r_arr: [G; OUT_720] = { let __args: [G; IN_720] = [__v_13, __v_30]; let __cu = unconstrained; if let Some(result) = record.function_queries[720].get_mut(&__args[..]) { if !__cu && *result.multiplicity == G::ZERO { aiur_fn_720(__args, record, io_buffer, false)? } else { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_720] = unsafe { *(result.output.as_ptr() as *const [G; OUT_720]) }; __ret } } else { aiur_fn_720(__args, record, io_buffer, __cu)? } }; let __v_31: G = __r_arr[0]; let __v_32: G = __r_arr[1]; let __v_33: G = __r_arr[2]; - let __r_arr: [G; OUT_721] = { let __args: [G; IN_721] = [__v_14, __v_33]; let __cu = unconstrained; if let Some(result) = record.function_queries[721].get_mut(&__args[..]) { if !__cu && *result.multiplicity == G::ZERO { aiur_fn_721(__args, record, io_buffer, false)? } else { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_721] = unsafe { *(result.output.as_ptr() as *const [G; OUT_721]) }; __ret } } else { aiur_fn_721(__args, record, io_buffer, __cu)? } }; + let __r_arr: [G; OUT_717] = { let __args: [G; IN_717] = [__v_14, __v_33]; let __cu = unconstrained; if let Some(result) = record.function_queries[717].get_mut(&__args[..]) { if !__cu && *result.multiplicity == G::ZERO { aiur_fn_717(__args, record, io_buffer, false)? } else { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_717] = unsafe { *(result.output.as_ptr() as *const [G; OUT_717]) }; __ret } } else { aiur_fn_717(__args, record, io_buffer, __cu)? } }; let __v_34: G = __r_arr[0]; let __v_35: G = __r_arr[1]; let __v_36: G = __r_arr[2]; @@ -61607,30 +61335,30 @@ fn aiur_fn_735( let __v_41: G = __r_arr[7]; let __v_42: G = __r_arr[8]; let __v_43: G = __r_arr[9]; - let __r_arr: [G; OUT_722] = { let __args: [G; IN_722] = [__v_15, __v_43]; let __cu = unconstrained; if let Some(result) = record.function_queries[722].get_mut(&__args[..]) { if !__cu && *result.multiplicity == G::ZERO { aiur_fn_722(__args, record, io_buffer, false)? } else { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_722] = unsafe { *(result.output.as_ptr() as *const [G; OUT_722]) }; __ret } } else { aiur_fn_722(__args, record, io_buffer, __cu)? } }; + let __r_arr: [G; OUT_718] = { let __args: [G; IN_718] = [__v_15, __v_43]; let __cu = unconstrained; if let Some(result) = record.function_queries[718].get_mut(&__args[..]) { if !__cu && *result.multiplicity == G::ZERO { aiur_fn_718(__args, record, io_buffer, false)? } else { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_718] = unsafe { *(result.output.as_ptr() as *const [G; OUT_718]) }; __ret } } else { aiur_fn_718(__args, record, io_buffer, __cu)? } }; let __v_44: G = __r_arr[0]; let __v_45: G = __r_arr[1]; let __v_46: G = __r_arr[2]; - let __r_arr: [G; OUT_722] = { let __args: [G; IN_722] = [__v_16, __v_46]; let __cu = unconstrained; if let Some(result) = record.function_queries[722].get_mut(&__args[..]) { if !__cu && *result.multiplicity == G::ZERO { aiur_fn_722(__args, record, io_buffer, false)? } else { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_722] = unsafe { *(result.output.as_ptr() as *const [G; OUT_722]) }; __ret } } else { aiur_fn_722(__args, record, io_buffer, __cu)? } }; + let __r_arr: [G; OUT_718] = { let __args: [G; IN_718] = [__v_16, __v_46]; let __cu = unconstrained; if let Some(result) = record.function_queries[718].get_mut(&__args[..]) { if !__cu && *result.multiplicity == G::ZERO { aiur_fn_718(__args, record, io_buffer, false)? } else { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_718] = unsafe { *(result.output.as_ptr() as *const [G; OUT_718]) }; __ret } } else { aiur_fn_718(__args, record, io_buffer, __cu)? } }; let __v_47: G = __r_arr[0]; let __v_48: G = __r_arr[1]; let __v_49: G = __r_arr[2]; let __v_50: G = G::from_u64(0); let __v_51: G = G::from_u64(0); - let __ret: [G; OUT_735] = [__v_50, __v_28, __v_29, __v_31, __v_32, __v_34, __v_35, __v_36, __v_37, __v_38, __v_39, __v_40, __v_41, __v_42, __v_44, __v_45, __v_47, __v_48, __v_51, __v_51, __v_51, __v_51, __v_51, __v_51, __v_51, __v_51, __v_51, __v_51, __v_51, __v_51, __v_51, __v_51, __v_51, __v_51, __v_51, __v_51, __v_51, __v_51, __v_51, __v_51, __v_51, __v_51, __v_51, __v_51, __v_51, __v_51, __v_51, __v_51, __v_51, __v_51, __v_51, __v_51, __v_51, __v_51, __v_49]; - if let Some(result) = record.function_queries[735].get_mut(&inp[..]) { debug_assert_eq!(result.output, &__ret[..]); if !unconstrained { *result.multiplicity += G::ONE; } } else { record.function_queries[735].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained)); }; + let __ret: [G; OUT_731] = [__v_50, __v_28, __v_29, __v_31, __v_32, __v_34, __v_35, __v_36, __v_37, __v_38, __v_39, __v_40, __v_41, __v_42, __v_44, __v_45, __v_47, __v_48, __v_51, __v_51, __v_51, __v_51, __v_51, __v_51, __v_51, __v_51, __v_51, __v_51, __v_51, __v_51, __v_51, __v_51, __v_51, __v_51, __v_51, __v_51, __v_51, __v_51, __v_51, __v_51, __v_51, __v_51, __v_51, __v_51, __v_51, __v_51, __v_51, __v_51, __v_51, __v_51, __v_51, __v_51, __v_51, __v_51, __v_49]; + if let Some(result) = record.function_queries[731].get_mut(&inp[..]) { debug_assert_eq!(result.output, &__ret[..]); if !unconstrained { *result.multiplicity += G::ONE; } } else { record.function_queries[731].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained)); }; return Ok(__ret); }, 1u64 => { - let __r_arr: [G; OUT_723] = { let __args: [G; IN_723] = [__v_12, __v_11]; let __cu = unconstrained; if let Some(result) = record.function_queries[723].get_mut(&__args[..]) { if !__cu && *result.multiplicity == G::ZERO { aiur_fn_723(__args, record, io_buffer, false)? } else { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_723] = unsafe { *(result.output.as_ptr() as *const [G; OUT_723]) }; __ret } } else { aiur_fn_723(__args, record, io_buffer, __cu)? } }; + let __r_arr: [G; OUT_719] = { let __args: [G; IN_719] = [__v_12, __v_11]; let __cu = unconstrained; if let Some(result) = record.function_queries[719].get_mut(&__args[..]) { if !__cu && *result.multiplicity == G::ZERO { aiur_fn_719(__args, record, io_buffer, false)? } else { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_719] = unsafe { *(result.output.as_ptr() as *const [G; OUT_719]) }; __ret } } else { aiur_fn_719(__args, record, io_buffer, __cu)? } }; let __v_28: G = __r_arr[0]; let __v_29: G = __r_arr[1]; let __v_30: G = __r_arr[2]; - let __r_arr: [G; OUT_723] = { let __args: [G; IN_723] = [__v_13, __v_30]; let __cu = unconstrained; if let Some(result) = record.function_queries[723].get_mut(&__args[..]) { if !__cu && *result.multiplicity == G::ZERO { aiur_fn_723(__args, record, io_buffer, false)? } else { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_723] = unsafe { *(result.output.as_ptr() as *const [G; OUT_723]) }; __ret } } else { aiur_fn_723(__args, record, io_buffer, __cu)? } }; + let __r_arr: [G; OUT_719] = { let __args: [G; IN_719] = [__v_13, __v_30]; let __cu = unconstrained; if let Some(result) = record.function_queries[719].get_mut(&__args[..]) { if !__cu && *result.multiplicity == G::ZERO { aiur_fn_719(__args, record, io_buffer, false)? } else { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_719] = unsafe { *(result.output.as_ptr() as *const [G; OUT_719]) }; __ret } } else { aiur_fn_719(__args, record, io_buffer, __cu)? } }; let __v_31: G = __r_arr[0]; let __v_32: G = __r_arr[1]; let __v_33: G = __r_arr[2]; - let __r_arr: [G; OUT_721] = { let __args: [G; IN_721] = [__v_14, __v_33]; let __cu = unconstrained; if let Some(result) = record.function_queries[721].get_mut(&__args[..]) { if !__cu && *result.multiplicity == G::ZERO { aiur_fn_721(__args, record, io_buffer, false)? } else { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_721] = unsafe { *(result.output.as_ptr() as *const [G; OUT_721]) }; __ret } } else { aiur_fn_721(__args, record, io_buffer, __cu)? } }; + let __r_arr: [G; OUT_717] = { let __args: [G; IN_717] = [__v_14, __v_33]; let __cu = unconstrained; if let Some(result) = record.function_queries[717].get_mut(&__args[..]) { if !__cu && *result.multiplicity == G::ZERO { aiur_fn_717(__args, record, io_buffer, false)? } else { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_717] = unsafe { *(result.output.as_ptr() as *const [G; OUT_717]) }; __ret } } else { aiur_fn_717(__args, record, io_buffer, __cu)? } }; let __v_34: G = __r_arr[0]; let __v_35: G = __r_arr[1]; let __v_36: G = __r_arr[2]; @@ -61641,7 +61369,7 @@ fn aiur_fn_735( let __v_41: G = __r_arr[7]; let __v_42: G = __r_arr[8]; let __v_43: G = __r_arr[9]; - let __r_arr: [G; OUT_721] = { let __args: [G; IN_721] = [__v_15, __v_43]; let __cu = unconstrained; if let Some(result) = record.function_queries[721].get_mut(&__args[..]) { if !__cu && *result.multiplicity == G::ZERO { aiur_fn_721(__args, record, io_buffer, false)? } else { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_721] = unsafe { *(result.output.as_ptr() as *const [G; OUT_721]) }; __ret } } else { aiur_fn_721(__args, record, io_buffer, __cu)? } }; + let __r_arr: [G; OUT_717] = { let __args: [G; IN_717] = [__v_15, __v_43]; let __cu = unconstrained; if let Some(result) = record.function_queries[717].get_mut(&__args[..]) { if !__cu && *result.multiplicity == G::ZERO { aiur_fn_717(__args, record, io_buffer, false)? } else { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_717] = unsafe { *(result.output.as_ptr() as *const [G; OUT_717]) }; __ret } } else { aiur_fn_717(__args, record, io_buffer, __cu)? } }; let __v_44: G = __r_arr[0]; let __v_45: G = __r_arr[1]; let __v_46: G = __r_arr[2]; @@ -61652,7 +61380,7 @@ fn aiur_fn_735( let __v_51: G = __r_arr[7]; let __v_52: G = __r_arr[8]; let __v_53: G = __r_arr[9]; - let __r_arr: [G; OUT_721] = { let __args: [G; IN_721] = [__v_16, __v_53]; let __cu = unconstrained; if let Some(result) = record.function_queries[721].get_mut(&__args[..]) { if !__cu && *result.multiplicity == G::ZERO { aiur_fn_721(__args, record, io_buffer, false)? } else { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_721] = unsafe { *(result.output.as_ptr() as *const [G; OUT_721]) }; __ret } } else { aiur_fn_721(__args, record, io_buffer, __cu)? } }; + let __r_arr: [G; OUT_717] = { let __args: [G; IN_717] = [__v_16, __v_53]; let __cu = unconstrained; if let Some(result) = record.function_queries[717].get_mut(&__args[..]) { if !__cu && *result.multiplicity == G::ZERO { aiur_fn_717(__args, record, io_buffer, false)? } else { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_717] = unsafe { *(result.output.as_ptr() as *const [G; OUT_717]) }; __ret } } else { aiur_fn_717(__args, record, io_buffer, __cu)? } }; let __v_54: G = __r_arr[0]; let __v_55: G = __r_arr[1]; let __v_56: G = __r_arr[2]; @@ -61663,7 +61391,7 @@ fn aiur_fn_735( let __v_61: G = __r_arr[7]; let __v_62: G = __r_arr[8]; let __v_63: G = __r_arr[9]; - let __r_arr: [G; OUT_721] = { let __args: [G; IN_721] = [__v_17, __v_63]; let __cu = unconstrained; if let Some(result) = record.function_queries[721].get_mut(&__args[..]) { if !__cu && *result.multiplicity == G::ZERO { aiur_fn_721(__args, record, io_buffer, false)? } else { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_721] = unsafe { *(result.output.as_ptr() as *const [G; OUT_721]) }; __ret } } else { aiur_fn_721(__args, record, io_buffer, __cu)? } }; + let __r_arr: [G; OUT_717] = { let __args: [G; IN_717] = [__v_17, __v_63]; let __cu = unconstrained; if let Some(result) = record.function_queries[717].get_mut(&__args[..]) { if !__cu && *result.multiplicity == G::ZERO { aiur_fn_717(__args, record, io_buffer, false)? } else { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_717] = unsafe { *(result.output.as_ptr() as *const [G; OUT_717]) }; __ret } } else { aiur_fn_717(__args, record, io_buffer, __cu)? } }; let __v_64: G = __r_arr[0]; let __v_65: G = __r_arr[1]; let __v_66: G = __r_arr[2]; @@ -61674,7 +61402,7 @@ fn aiur_fn_735( let __v_71: G = __r_arr[7]; let __v_72: G = __r_arr[8]; let __v_73: G = __r_arr[9]; - let __r_arr: [G; OUT_721] = { let __args: [G; IN_721] = [__v_18, __v_73]; let __cu = unconstrained; if let Some(result) = record.function_queries[721].get_mut(&__args[..]) { if !__cu && *result.multiplicity == G::ZERO { aiur_fn_721(__args, record, io_buffer, false)? } else { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_721] = unsafe { *(result.output.as_ptr() as *const [G; OUT_721]) }; __ret } } else { aiur_fn_721(__args, record, io_buffer, __cu)? } }; + let __r_arr: [G; OUT_717] = { let __args: [G; IN_717] = [__v_18, __v_73]; let __cu = unconstrained; if let Some(result) = record.function_queries[717].get_mut(&__args[..]) { if !__cu && *result.multiplicity == G::ZERO { aiur_fn_717(__args, record, io_buffer, false)? } else { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_717] = unsafe { *(result.output.as_ptr() as *const [G; OUT_717]) }; __ret } } else { aiur_fn_717(__args, record, io_buffer, __cu)? } }; let __v_74: G = __r_arr[0]; let __v_75: G = __r_arr[1]; let __v_76: G = __r_arr[2]; @@ -61685,25 +61413,25 @@ fn aiur_fn_735( let __v_81: G = __r_arr[7]; let __v_82: G = __r_arr[8]; let __v_83: G = __r_arr[9]; - let __r_arr: [G; OUT_722] = { let __args: [G; IN_722] = [__v_19, __v_83]; let __cu = unconstrained; if let Some(result) = record.function_queries[722].get_mut(&__args[..]) { if !__cu && *result.multiplicity == G::ZERO { aiur_fn_722(__args, record, io_buffer, false)? } else { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_722] = unsafe { *(result.output.as_ptr() as *const [G; OUT_722]) }; __ret } } else { aiur_fn_722(__args, record, io_buffer, __cu)? } }; + let __r_arr: [G; OUT_718] = { let __args: [G; IN_718] = [__v_19, __v_83]; let __cu = unconstrained; if let Some(result) = record.function_queries[718].get_mut(&__args[..]) { if !__cu && *result.multiplicity == G::ZERO { aiur_fn_718(__args, record, io_buffer, false)? } else { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_718] = unsafe { *(result.output.as_ptr() as *const [G; OUT_718]) }; __ret } } else { aiur_fn_718(__args, record, io_buffer, __cu)? } }; let __v_84: G = __r_arr[0]; let __v_85: G = __r_arr[1]; let __v_86: G = __r_arr[2]; - let __r_arr: [G; OUT_727] = { let __args: [G; IN_727] = [__v_20, __v_86]; let __cu = unconstrained; if let Some(result) = record.function_queries[727].get_mut(&__args[..]) { if !__cu && *result.multiplicity == G::ZERO { aiur_fn_727(__args, record, io_buffer, false)? } else { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_727] = unsafe { *(result.output.as_ptr() as *const [G; OUT_727]) }; __ret } } else { aiur_fn_727(__args, record, io_buffer, __cu)? } }; + let __r_arr: [G; OUT_723] = { let __args: [G; IN_723] = [__v_20, __v_86]; let __cu = unconstrained; if let Some(result) = record.function_queries[723].get_mut(&__args[..]) { if !__cu && *result.multiplicity == G::ZERO { aiur_fn_723(__args, record, io_buffer, false)? } else { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_723] = unsafe { *(result.output.as_ptr() as *const [G; OUT_723]) }; __ret } } else { aiur_fn_723(__args, record, io_buffer, __cu)? } }; let __v_87: G = __r_arr[0]; let __v_88: G = __r_arr[1]; let __v_89: G = __r_arr[2]; let __v_90: G = G::from_u64(1); - let __ret: [G; OUT_735] = [__v_90, __v_28, __v_29, __v_31, __v_32, __v_34, __v_35, __v_36, __v_37, __v_38, __v_39, __v_40, __v_41, __v_42, __v_44, __v_45, __v_46, __v_47, __v_48, __v_49, __v_50, __v_51, __v_52, __v_54, __v_55, __v_56, __v_57, __v_58, __v_59, __v_60, __v_61, __v_62, __v_64, __v_65, __v_66, __v_67, __v_68, __v_69, __v_70, __v_71, __v_72, __v_74, __v_75, __v_76, __v_77, __v_78, __v_79, __v_80, __v_81, __v_82, __v_84, __v_85, __v_87, __v_88, __v_89]; - if let Some(result) = record.function_queries[735].get_mut(&inp[..]) { debug_assert_eq!(result.output, &__ret[..]); if !unconstrained { *result.multiplicity += G::ONE; } } else { record.function_queries[735].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained)); }; + let __ret: [G; OUT_731] = [__v_90, __v_28, __v_29, __v_31, __v_32, __v_34, __v_35, __v_36, __v_37, __v_38, __v_39, __v_40, __v_41, __v_42, __v_44, __v_45, __v_46, __v_47, __v_48, __v_49, __v_50, __v_51, __v_52, __v_54, __v_55, __v_56, __v_57, __v_58, __v_59, __v_60, __v_61, __v_62, __v_64, __v_65, __v_66, __v_67, __v_68, __v_69, __v_70, __v_71, __v_72, __v_74, __v_75, __v_76, __v_77, __v_78, __v_79, __v_80, __v_81, __v_82, __v_84, __v_85, __v_87, __v_88, __v_89]; + if let Some(result) = record.function_queries[731].get_mut(&inp[..]) { debug_assert_eq!(result.output, &__ret[..]); if !unconstrained { *result.multiplicity += G::ONE; } } else { record.function_queries[731].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained)); }; return Ok(__ret); }, 2u64 => { - let __r_arr: [G; OUT_723] = { let __args: [G; IN_723] = [__v_12, __v_11]; let __cu = unconstrained; if let Some(result) = record.function_queries[723].get_mut(&__args[..]) { if !__cu && *result.multiplicity == G::ZERO { aiur_fn_723(__args, record, io_buffer, false)? } else { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_723] = unsafe { *(result.output.as_ptr() as *const [G; OUT_723]) }; __ret } } else { aiur_fn_723(__args, record, io_buffer, __cu)? } }; + let __r_arr: [G; OUT_719] = { let __args: [G; IN_719] = [__v_12, __v_11]; let __cu = unconstrained; if let Some(result) = record.function_queries[719].get_mut(&__args[..]) { if !__cu && *result.multiplicity == G::ZERO { aiur_fn_719(__args, record, io_buffer, false)? } else { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_719] = unsafe { *(result.output.as_ptr() as *const [G; OUT_719]) }; __ret } } else { aiur_fn_719(__args, record, io_buffer, __cu)? } }; let __v_28: G = __r_arr[0]; let __v_29: G = __r_arr[1]; let __v_30: G = __r_arr[2]; - let __r_arr: [G; OUT_721] = { let __args: [G; IN_721] = [__v_13, __v_30]; let __cu = unconstrained; if let Some(result) = record.function_queries[721].get_mut(&__args[..]) { if !__cu && *result.multiplicity == G::ZERO { aiur_fn_721(__args, record, io_buffer, false)? } else { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_721] = unsafe { *(result.output.as_ptr() as *const [G; OUT_721]) }; __ret } } else { aiur_fn_721(__args, record, io_buffer, __cu)? } }; + let __r_arr: [G; OUT_717] = { let __args: [G; IN_717] = [__v_13, __v_30]; let __cu = unconstrained; if let Some(result) = record.function_queries[717].get_mut(&__args[..]) { if !__cu && *result.multiplicity == G::ZERO { aiur_fn_717(__args, record, io_buffer, false)? } else { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_717] = unsafe { *(result.output.as_ptr() as *const [G; OUT_717]) }; __ret } } else { aiur_fn_717(__args, record, io_buffer, __cu)? } }; let __v_31: G = __r_arr[0]; let __v_32: G = __r_arr[1]; let __v_33: G = __r_arr[2]; @@ -61714,22 +61442,22 @@ fn aiur_fn_735( let __v_38: G = __r_arr[7]; let __v_39: G = __r_arr[8]; let __v_40: G = __r_arr[9]; - let __r_arr: [G; OUT_722] = { let __args: [G; IN_722] = [__v_14, __v_40]; let __cu = unconstrained; if let Some(result) = record.function_queries[722].get_mut(&__args[..]) { if !__cu && *result.multiplicity == G::ZERO { aiur_fn_722(__args, record, io_buffer, false)? } else { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_722] = unsafe { *(result.output.as_ptr() as *const [G; OUT_722]) }; __ret } } else { aiur_fn_722(__args, record, io_buffer, __cu)? } }; + let __r_arr: [G; OUT_718] = { let __args: [G; IN_718] = [__v_14, __v_40]; let __cu = unconstrained; if let Some(result) = record.function_queries[718].get_mut(&__args[..]) { if !__cu && *result.multiplicity == G::ZERO { aiur_fn_718(__args, record, io_buffer, false)? } else { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_718] = unsafe { *(result.output.as_ptr() as *const [G; OUT_718]) }; __ret } } else { aiur_fn_718(__args, record, io_buffer, __cu)? } }; let __v_41: G = __r_arr[0]; let __v_42: G = __r_arr[1]; let __v_43: G = __r_arr[2]; let __v_44: G = G::from_u64(2); let __v_45: G = G::from_u64(0); - let __ret: [G; OUT_735] = [__v_44, __v_28, __v_29, __v_31, __v_32, __v_33, __v_34, __v_35, __v_36, __v_37, __v_38, __v_39, __v_41, __v_42, __v_45, __v_45, __v_45, __v_45, __v_45, __v_45, __v_45, __v_45, __v_45, __v_45, __v_45, __v_45, __v_45, __v_45, __v_45, __v_45, __v_45, __v_45, __v_45, __v_45, __v_45, __v_45, __v_45, __v_45, __v_45, __v_45, __v_45, __v_45, __v_45, __v_45, __v_45, __v_45, __v_45, __v_45, __v_45, __v_45, __v_45, __v_45, __v_45, __v_45, __v_43]; - if let Some(result) = record.function_queries[735].get_mut(&inp[..]) { debug_assert_eq!(result.output, &__ret[..]); if !unconstrained { *result.multiplicity += G::ONE; } } else { record.function_queries[735].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained)); }; + let __ret: [G; OUT_731] = [__v_44, __v_28, __v_29, __v_31, __v_32, __v_33, __v_34, __v_35, __v_36, __v_37, __v_38, __v_39, __v_41, __v_42, __v_45, __v_45, __v_45, __v_45, __v_45, __v_45, __v_45, __v_45, __v_45, __v_45, __v_45, __v_45, __v_45, __v_45, __v_45, __v_45, __v_45, __v_45, __v_45, __v_45, __v_45, __v_45, __v_45, __v_45, __v_45, __v_45, __v_45, __v_45, __v_45, __v_45, __v_45, __v_45, __v_45, __v_45, __v_45, __v_45, __v_45, __v_45, __v_45, __v_45, __v_43]; + if let Some(result) = record.function_queries[731].get_mut(&inp[..]) { debug_assert_eq!(result.output, &__ret[..]); if !unconstrained { *result.multiplicity += G::ONE; } } else { record.function_queries[731].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained)); }; return Ok(__ret); }, 3u64 => { - let __r_arr: [G; OUT_725] = { let __args: [G; IN_725] = [__v_12, __v_11]; let __cu = unconstrained; if let Some(result) = record.function_queries[725].get_mut(&__args[..]) { if !__cu && *result.multiplicity == G::ZERO { aiur_fn_725(__args, record, io_buffer, false)? } else { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_725] = unsafe { *(result.output.as_ptr() as *const [G; OUT_725]) }; __ret } } else { aiur_fn_725(__args, record, io_buffer, __cu)? } }; + let __r_arr: [G; OUT_721] = { let __args: [G; IN_721] = [__v_12, __v_11]; let __cu = unconstrained; if let Some(result) = record.function_queries[721].get_mut(&__args[..]) { if !__cu && *result.multiplicity == G::ZERO { aiur_fn_721(__args, record, io_buffer, false)? } else { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_721] = unsafe { *(result.output.as_ptr() as *const [G; OUT_721]) }; __ret } } else { aiur_fn_721(__args, record, io_buffer, __cu)? } }; let __v_28: G = __r_arr[0]; let __v_29: G = __r_arr[1]; let __v_30: G = __r_arr[2]; - let __r_arr: [G; OUT_721] = { let __args: [G; IN_721] = [__v_13, __v_30]; let __cu = unconstrained; if let Some(result) = record.function_queries[721].get_mut(&__args[..]) { if !__cu && *result.multiplicity == G::ZERO { aiur_fn_721(__args, record, io_buffer, false)? } else { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_721] = unsafe { *(result.output.as_ptr() as *const [G; OUT_721]) }; __ret } } else { aiur_fn_721(__args, record, io_buffer, __cu)? } }; + let __r_arr: [G; OUT_717] = { let __args: [G; IN_717] = [__v_13, __v_30]; let __cu = unconstrained; if let Some(result) = record.function_queries[717].get_mut(&__args[..]) { if !__cu && *result.multiplicity == G::ZERO { aiur_fn_717(__args, record, io_buffer, false)? } else { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_717] = unsafe { *(result.output.as_ptr() as *const [G; OUT_717]) }; __ret } } else { aiur_fn_717(__args, record, io_buffer, __cu)? } }; let __v_31: G = __r_arr[0]; let __v_32: G = __r_arr[1]; let __v_33: G = __r_arr[2]; @@ -61740,18 +61468,18 @@ fn aiur_fn_735( let __v_38: G = __r_arr[7]; let __v_39: G = __r_arr[8]; let __v_40: G = __r_arr[9]; - let __r_arr: [G; OUT_722] = { let __args: [G; IN_722] = [__v_14, __v_40]; let __cu = unconstrained; if let Some(result) = record.function_queries[722].get_mut(&__args[..]) { if !__cu && *result.multiplicity == G::ZERO { aiur_fn_722(__args, record, io_buffer, false)? } else { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_722] = unsafe { *(result.output.as_ptr() as *const [G; OUT_722]) }; __ret } } else { aiur_fn_722(__args, record, io_buffer, __cu)? } }; + let __r_arr: [G; OUT_718] = { let __args: [G; IN_718] = [__v_14, __v_40]; let __cu = unconstrained; if let Some(result) = record.function_queries[718].get_mut(&__args[..]) { if !__cu && *result.multiplicity == G::ZERO { aiur_fn_718(__args, record, io_buffer, false)? } else { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_718] = unsafe { *(result.output.as_ptr() as *const [G; OUT_718]) }; __ret } } else { aiur_fn_718(__args, record, io_buffer, __cu)? } }; let __v_41: G = __r_arr[0]; let __v_42: G = __r_arr[1]; let __v_43: G = __r_arr[2]; let __v_44: G = G::from_u64(3); let __v_45: G = G::from_u64(0); - let __ret: [G; OUT_735] = [__v_44, __v_28, __v_29, __v_31, __v_32, __v_33, __v_34, __v_35, __v_36, __v_37, __v_38, __v_39, __v_41, __v_42, __v_45, __v_45, __v_45, __v_45, __v_45, __v_45, __v_45, __v_45, __v_45, __v_45, __v_45, __v_45, __v_45, __v_45, __v_45, __v_45, __v_45, __v_45, __v_45, __v_45, __v_45, __v_45, __v_45, __v_45, __v_45, __v_45, __v_45, __v_45, __v_45, __v_45, __v_45, __v_45, __v_45, __v_45, __v_45, __v_45, __v_45, __v_45, __v_45, __v_45, __v_43]; - if let Some(result) = record.function_queries[735].get_mut(&inp[..]) { debug_assert_eq!(result.output, &__ret[..]); if !unconstrained { *result.multiplicity += G::ONE; } } else { record.function_queries[735].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained)); }; + let __ret: [G; OUT_731] = [__v_44, __v_28, __v_29, __v_31, __v_32, __v_33, __v_34, __v_35, __v_36, __v_37, __v_38, __v_39, __v_41, __v_42, __v_45, __v_45, __v_45, __v_45, __v_45, __v_45, __v_45, __v_45, __v_45, __v_45, __v_45, __v_45, __v_45, __v_45, __v_45, __v_45, __v_45, __v_45, __v_45, __v_45, __v_45, __v_45, __v_45, __v_45, __v_45, __v_45, __v_45, __v_45, __v_45, __v_45, __v_45, __v_45, __v_45, __v_45, __v_45, __v_45, __v_45, __v_45, __v_45, __v_45, __v_43]; + if let Some(result) = record.function_queries[731].get_mut(&inp[..]) { debug_assert_eq!(result.output, &__ret[..]); if !unconstrained { *result.multiplicity += G::ONE; } } else { record.function_queries[731].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained)); }; return Ok(__ret); }, 4u64 => { - let __r_arr: [G; OUT_721] = { let __args: [G; IN_721] = [__v_12, __v_11]; let __cu = unconstrained; if let Some(result) = record.function_queries[721].get_mut(&__args[..]) { if !__cu && *result.multiplicity == G::ZERO { aiur_fn_721(__args, record, io_buffer, false)? } else { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_721] = unsafe { *(result.output.as_ptr() as *const [G; OUT_721]) }; __ret } } else { aiur_fn_721(__args, record, io_buffer, __cu)? } }; + let __r_arr: [G; OUT_717] = { let __args: [G; IN_717] = [__v_12, __v_11]; let __cu = unconstrained; if let Some(result) = record.function_queries[717].get_mut(&__args[..]) { if !__cu && *result.multiplicity == G::ZERO { aiur_fn_717(__args, record, io_buffer, false)? } else { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_717] = unsafe { *(result.output.as_ptr() as *const [G; OUT_717]) }; __ret } } else { aiur_fn_717(__args, record, io_buffer, __cu)? } }; let __v_28: G = __r_arr[0]; let __v_29: G = __r_arr[1]; let __v_30: G = __r_arr[2]; @@ -61762,7 +61490,7 @@ fn aiur_fn_735( let __v_35: G = __r_arr[7]; let __v_36: G = __r_arr[8]; let __v_37: G = __r_arr[9]; - let __r_arr: [G; OUT_721] = { let __args: [G; IN_721] = [__v_13, __v_37]; let __cu = unconstrained; if let Some(result) = record.function_queries[721].get_mut(&__args[..]) { if !__cu && *result.multiplicity == G::ZERO { aiur_fn_721(__args, record, io_buffer, false)? } else { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_721] = unsafe { *(result.output.as_ptr() as *const [G; OUT_721]) }; __ret } } else { aiur_fn_721(__args, record, io_buffer, __cu)? } }; + let __r_arr: [G; OUT_717] = { let __args: [G; IN_717] = [__v_13, __v_37]; let __cu = unconstrained; if let Some(result) = record.function_queries[717].get_mut(&__args[..]) { if !__cu && *result.multiplicity == G::ZERO { aiur_fn_717(__args, record, io_buffer, false)? } else { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_717] = unsafe { *(result.output.as_ptr() as *const [G; OUT_717]) }; __ret } } else { aiur_fn_717(__args, record, io_buffer, __cu)? } }; let __v_38: G = __r_arr[0]; let __v_39: G = __r_arr[1]; let __v_40: G = __r_arr[2]; @@ -61773,18 +61501,18 @@ fn aiur_fn_735( let __v_45: G = __r_arr[7]; let __v_46: G = __r_arr[8]; let __v_47: G = __r_arr[9]; - let __r_arr: [G; OUT_722] = { let __args: [G; IN_722] = [__v_14, __v_47]; let __cu = unconstrained; if let Some(result) = record.function_queries[722].get_mut(&__args[..]) { if !__cu && *result.multiplicity == G::ZERO { aiur_fn_722(__args, record, io_buffer, false)? } else { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_722] = unsafe { *(result.output.as_ptr() as *const [G; OUT_722]) }; __ret } } else { aiur_fn_722(__args, record, io_buffer, __cu)? } }; + let __r_arr: [G; OUT_718] = { let __args: [G; IN_718] = [__v_14, __v_47]; let __cu = unconstrained; if let Some(result) = record.function_queries[718].get_mut(&__args[..]) { if !__cu && *result.multiplicity == G::ZERO { aiur_fn_718(__args, record, io_buffer, false)? } else { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_718] = unsafe { *(result.output.as_ptr() as *const [G; OUT_718]) }; __ret } } else { aiur_fn_718(__args, record, io_buffer, __cu)? } }; let __v_48: G = __r_arr[0]; let __v_49: G = __r_arr[1]; let __v_50: G = __r_arr[2]; let __v_51: G = G::from_u64(4); let __v_52: G = G::from_u64(0); - let __ret: [G; OUT_735] = [__v_51, __v_28, __v_29, __v_30, __v_31, __v_32, __v_33, __v_34, __v_35, __v_36, __v_38, __v_39, __v_40, __v_41, __v_42, __v_43, __v_44, __v_45, __v_46, __v_48, __v_49, __v_52, __v_52, __v_52, __v_52, __v_52, __v_52, __v_52, __v_52, __v_52, __v_52, __v_52, __v_52, __v_52, __v_52, __v_52, __v_52, __v_52, __v_52, __v_52, __v_52, __v_52, __v_52, __v_52, __v_52, __v_52, __v_52, __v_52, __v_52, __v_52, __v_52, __v_52, __v_52, __v_52, __v_50]; - if let Some(result) = record.function_queries[735].get_mut(&inp[..]) { debug_assert_eq!(result.output, &__ret[..]); if !unconstrained { *result.multiplicity += G::ONE; } } else { record.function_queries[735].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained)); }; + let __ret: [G; OUT_731] = [__v_51, __v_28, __v_29, __v_30, __v_31, __v_32, __v_33, __v_34, __v_35, __v_36, __v_38, __v_39, __v_40, __v_41, __v_42, __v_43, __v_44, __v_45, __v_46, __v_48, __v_49, __v_52, __v_52, __v_52, __v_52, __v_52, __v_52, __v_52, __v_52, __v_52, __v_52, __v_52, __v_52, __v_52, __v_52, __v_52, __v_52, __v_52, __v_52, __v_52, __v_52, __v_52, __v_52, __v_52, __v_52, __v_52, __v_52, __v_52, __v_52, __v_52, __v_52, __v_52, __v_52, __v_52, __v_50]; + if let Some(result) = record.function_queries[731].get_mut(&inp[..]) { debug_assert_eq!(result.output, &__ret[..]); if !unconstrained { *result.multiplicity += G::ONE; } } else { record.function_queries[731].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained)); }; return Ok(__ret); }, 5u64 => { - let __r_arr: [G; OUT_721] = { let __args: [G; IN_721] = [__v_12, __v_11]; let __cu = unconstrained; if let Some(result) = record.function_queries[721].get_mut(&__args[..]) { if !__cu && *result.multiplicity == G::ZERO { aiur_fn_721(__args, record, io_buffer, false)? } else { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_721] = unsafe { *(result.output.as_ptr() as *const [G; OUT_721]) }; __ret } } else { aiur_fn_721(__args, record, io_buffer, __cu)? } }; + let __r_arr: [G; OUT_717] = { let __args: [G; IN_717] = [__v_12, __v_11]; let __cu = unconstrained; if let Some(result) = record.function_queries[717].get_mut(&__args[..]) { if !__cu && *result.multiplicity == G::ZERO { aiur_fn_717(__args, record, io_buffer, false)? } else { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_717] = unsafe { *(result.output.as_ptr() as *const [G; OUT_717]) }; __ret } } else { aiur_fn_717(__args, record, io_buffer, __cu)? } }; let __v_28: G = __r_arr[0]; let __v_29: G = __r_arr[1]; let __v_30: G = __r_arr[2]; @@ -61795,18 +61523,18 @@ fn aiur_fn_735( let __v_35: G = __r_arr[7]; let __v_36: G = __r_arr[8]; let __v_37: G = __r_arr[9]; - let __r_arr: [G; OUT_722] = { let __args: [G; IN_722] = [__v_13, __v_37]; let __cu = unconstrained; if let Some(result) = record.function_queries[722].get_mut(&__args[..]) { if !__cu && *result.multiplicity == G::ZERO { aiur_fn_722(__args, record, io_buffer, false)? } else { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_722] = unsafe { *(result.output.as_ptr() as *const [G; OUT_722]) }; __ret } } else { aiur_fn_722(__args, record, io_buffer, __cu)? } }; + let __r_arr: [G; OUT_718] = { let __args: [G; IN_718] = [__v_13, __v_37]; let __cu = unconstrained; if let Some(result) = record.function_queries[718].get_mut(&__args[..]) { if !__cu && *result.multiplicity == G::ZERO { aiur_fn_718(__args, record, io_buffer, false)? } else { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_718] = unsafe { *(result.output.as_ptr() as *const [G; OUT_718]) }; __ret } } else { aiur_fn_718(__args, record, io_buffer, __cu)? } }; let __v_38: G = __r_arr[0]; let __v_39: G = __r_arr[1]; let __v_40: G = __r_arr[2]; let __v_41: G = G::from_u64(5); let __v_42: G = G::from_u64(0); - let __ret: [G; OUT_735] = [__v_41, __v_28, __v_29, __v_30, __v_31, __v_32, __v_33, __v_34, __v_35, __v_36, __v_38, __v_39, __v_42, __v_42, __v_42, __v_42, __v_42, __v_42, __v_42, __v_42, __v_42, __v_42, __v_42, __v_42, __v_42, __v_42, __v_42, __v_42, __v_42, __v_42, __v_42, __v_42, __v_42, __v_42, __v_42, __v_42, __v_42, __v_42, __v_42, __v_42, __v_42, __v_42, __v_42, __v_42, __v_42, __v_42, __v_42, __v_42, __v_42, __v_42, __v_42, __v_42, __v_42, __v_42, __v_40]; - if let Some(result) = record.function_queries[735].get_mut(&inp[..]) { debug_assert_eq!(result.output, &__ret[..]); if !unconstrained { *result.multiplicity += G::ONE; } } else { record.function_queries[735].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained)); }; + let __ret: [G; OUT_731] = [__v_41, __v_28, __v_29, __v_30, __v_31, __v_32, __v_33, __v_34, __v_35, __v_36, __v_38, __v_39, __v_42, __v_42, __v_42, __v_42, __v_42, __v_42, __v_42, __v_42, __v_42, __v_42, __v_42, __v_42, __v_42, __v_42, __v_42, __v_42, __v_42, __v_42, __v_42, __v_42, __v_42, __v_42, __v_42, __v_42, __v_42, __v_42, __v_42, __v_42, __v_42, __v_42, __v_42, __v_42, __v_42, __v_42, __v_42, __v_42, __v_42, __v_42, __v_42, __v_42, __v_42, __v_42, __v_40]; + if let Some(result) = record.function_queries[731].get_mut(&inp[..]) { debug_assert_eq!(result.output, &__ret[..]); if !unconstrained { *result.multiplicity += G::ONE; } } else { record.function_queries[731].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained)); }; return Ok(__ret); }, 6u64 => { - let __r_arr: [G; OUT_721] = { let __args: [G; IN_721] = [__v_12, __v_11]; let __cu = unconstrained; if let Some(result) = record.function_queries[721].get_mut(&__args[..]) { if !__cu && *result.multiplicity == G::ZERO { aiur_fn_721(__args, record, io_buffer, false)? } else { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_721] = unsafe { *(result.output.as_ptr() as *const [G; OUT_721]) }; __ret } } else { aiur_fn_721(__args, record, io_buffer, __cu)? } }; + let __r_arr: [G; OUT_717] = { let __args: [G; IN_717] = [__v_12, __v_11]; let __cu = unconstrained; if let Some(result) = record.function_queries[717].get_mut(&__args[..]) { if !__cu && *result.multiplicity == G::ZERO { aiur_fn_717(__args, record, io_buffer, false)? } else { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_717] = unsafe { *(result.output.as_ptr() as *const [G; OUT_717]) }; __ret } } else { aiur_fn_717(__args, record, io_buffer, __cu)? } }; let __v_28: G = __r_arr[0]; let __v_29: G = __r_arr[1]; let __v_30: G = __r_arr[2]; @@ -61817,18 +61545,18 @@ fn aiur_fn_735( let __v_35: G = __r_arr[7]; let __v_36: G = __r_arr[8]; let __v_37: G = __r_arr[9]; - let __r_arr: [G; OUT_722] = { let __args: [G; IN_722] = [__v_13, __v_37]; let __cu = unconstrained; if let Some(result) = record.function_queries[722].get_mut(&__args[..]) { if !__cu && *result.multiplicity == G::ZERO { aiur_fn_722(__args, record, io_buffer, false)? } else { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_722] = unsafe { *(result.output.as_ptr() as *const [G; OUT_722]) }; __ret } } else { aiur_fn_722(__args, record, io_buffer, __cu)? } }; + let __r_arr: [G; OUT_718] = { let __args: [G; IN_718] = [__v_13, __v_37]; let __cu = unconstrained; if let Some(result) = record.function_queries[718].get_mut(&__args[..]) { if !__cu && *result.multiplicity == G::ZERO { aiur_fn_718(__args, record, io_buffer, false)? } else { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_718] = unsafe { *(result.output.as_ptr() as *const [G; OUT_718]) }; __ret } } else { aiur_fn_718(__args, record, io_buffer, __cu)? } }; let __v_38: G = __r_arr[0]; let __v_39: G = __r_arr[1]; let __v_40: G = __r_arr[2]; let __v_41: G = G::from_u64(6); let __v_42: G = G::from_u64(0); - let __ret: [G; OUT_735] = [__v_41, __v_28, __v_29, __v_30, __v_31, __v_32, __v_33, __v_34, __v_35, __v_36, __v_38, __v_39, __v_42, __v_42, __v_42, __v_42, __v_42, __v_42, __v_42, __v_42, __v_42, __v_42, __v_42, __v_42, __v_42, __v_42, __v_42, __v_42, __v_42, __v_42, __v_42, __v_42, __v_42, __v_42, __v_42, __v_42, __v_42, __v_42, __v_42, __v_42, __v_42, __v_42, __v_42, __v_42, __v_42, __v_42, __v_42, __v_42, __v_42, __v_42, __v_42, __v_42, __v_42, __v_42, __v_40]; - if let Some(result) = record.function_queries[735].get_mut(&inp[..]) { debug_assert_eq!(result.output, &__ret[..]); if !unconstrained { *result.multiplicity += G::ONE; } } else { record.function_queries[735].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained)); }; + let __ret: [G; OUT_731] = [__v_41, __v_28, __v_29, __v_30, __v_31, __v_32, __v_33, __v_34, __v_35, __v_36, __v_38, __v_39, __v_42, __v_42, __v_42, __v_42, __v_42, __v_42, __v_42, __v_42, __v_42, __v_42, __v_42, __v_42, __v_42, __v_42, __v_42, __v_42, __v_42, __v_42, __v_42, __v_42, __v_42, __v_42, __v_42, __v_42, __v_42, __v_42, __v_42, __v_42, __v_42, __v_42, __v_42, __v_42, __v_42, __v_42, __v_42, __v_42, __v_42, __v_42, __v_42, __v_42, __v_42, __v_42, __v_40]; + if let Some(result) = record.function_queries[731].get_mut(&inp[..]) { debug_assert_eq!(result.output, &__ret[..]); if !unconstrained { *result.multiplicity += G::ONE; } } else { record.function_queries[731].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained)); }; return Ok(__ret); }, 7u64 => { - let __r_arr: [G; OUT_721] = { let __args: [G; IN_721] = [__v_12, __v_11]; let __cu = unconstrained; if let Some(result) = record.function_queries[721].get_mut(&__args[..]) { if !__cu && *result.multiplicity == G::ZERO { aiur_fn_721(__args, record, io_buffer, false)? } else { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_721] = unsafe { *(result.output.as_ptr() as *const [G; OUT_721]) }; __ret } } else { aiur_fn_721(__args, record, io_buffer, __cu)? } }; + let __r_arr: [G; OUT_717] = { let __args: [G; IN_717] = [__v_12, __v_11]; let __cu = unconstrained; if let Some(result) = record.function_queries[717].get_mut(&__args[..]) { if !__cu && *result.multiplicity == G::ZERO { aiur_fn_717(__args, record, io_buffer, false)? } else { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_717] = unsafe { *(result.output.as_ptr() as *const [G; OUT_717]) }; __ret } } else { aiur_fn_717(__args, record, io_buffer, __cu)? } }; let __v_28: G = __r_arr[0]; let __v_29: G = __r_arr[1]; let __v_30: G = __r_arr[2]; @@ -61839,14 +61567,14 @@ fn aiur_fn_735( let __v_35: G = __r_arr[7]; let __v_36: G = __r_arr[8]; let __v_37: G = __r_arr[9]; - let __r_arr: [G; OUT_722] = { let __args: [G; IN_722] = [__v_13, __v_37]; let __cu = unconstrained; if let Some(result) = record.function_queries[722].get_mut(&__args[..]) { if !__cu && *result.multiplicity == G::ZERO { aiur_fn_722(__args, record, io_buffer, false)? } else { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_722] = unsafe { *(result.output.as_ptr() as *const [G; OUT_722]) }; __ret } } else { aiur_fn_722(__args, record, io_buffer, __cu)? } }; + let __r_arr: [G; OUT_718] = { let __args: [G; IN_718] = [__v_13, __v_37]; let __cu = unconstrained; if let Some(result) = record.function_queries[718].get_mut(&__args[..]) { if !__cu && *result.multiplicity == G::ZERO { aiur_fn_718(__args, record, io_buffer, false)? } else { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_718] = unsafe { *(result.output.as_ptr() as *const [G; OUT_718]) }; __ret } } else { aiur_fn_718(__args, record, io_buffer, __cu)? } }; let __v_38: G = __r_arr[0]; let __v_39: G = __r_arr[1]; let __v_40: G = __r_arr[2]; let __v_41: G = G::from_u64(7); let __v_42: G = G::from_u64(0); - let __ret: [G; OUT_735] = [__v_41, __v_28, __v_29, __v_30, __v_31, __v_32, __v_33, __v_34, __v_35, __v_36, __v_38, __v_39, __v_42, __v_42, __v_42, __v_42, __v_42, __v_42, __v_42, __v_42, __v_42, __v_42, __v_42, __v_42, __v_42, __v_42, __v_42, __v_42, __v_42, __v_42, __v_42, __v_42, __v_42, __v_42, __v_42, __v_42, __v_42, __v_42, __v_42, __v_42, __v_42, __v_42, __v_42, __v_42, __v_42, __v_42, __v_42, __v_42, __v_42, __v_42, __v_42, __v_42, __v_42, __v_42, __v_40]; - if let Some(result) = record.function_queries[735].get_mut(&inp[..]) { debug_assert_eq!(result.output, &__ret[..]); if !unconstrained { *result.multiplicity += G::ONE; } } else { record.function_queries[735].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained)); }; + let __ret: [G; OUT_731] = [__v_41, __v_28, __v_29, __v_30, __v_31, __v_32, __v_33, __v_34, __v_35, __v_36, __v_38, __v_39, __v_42, __v_42, __v_42, __v_42, __v_42, __v_42, __v_42, __v_42, __v_42, __v_42, __v_42, __v_42, __v_42, __v_42, __v_42, __v_42, __v_42, __v_42, __v_42, __v_42, __v_42, __v_42, __v_42, __v_42, __v_42, __v_42, __v_42, __v_42, __v_42, __v_42, __v_42, __v_42, __v_42, __v_42, __v_42, __v_42, __v_42, __v_42, __v_42, __v_42, __v_42, __v_42, __v_40]; + if let Some(result) = record.function_queries[731].get_mut(&inp[..]) { debug_assert_eq!(result.output, &__ret[..]); if !unconstrained { *result.multiplicity += G::ONE; } } else { record.function_queries[731].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained)); }; return Ok(__ret); }, 8u64 => { @@ -61868,7 +61596,7 @@ fn aiur_fn_735( let __v_34: G = __r_arr[6]; let __v_35: G = __r_arr[7]; let __v_36: G = __r_arr[8]; - let __r_arr: [G; OUT_734] = { let __args: [G; IN_734] = [__v_36, __v_28, __v_29, __v_30, __v_31, __v_32, __v_33, __v_34, __v_35]; let __cu = unconstrained; if let Some(result) = record.function_queries[734].get_mut(&__args[..]) { if !__cu && *result.multiplicity == G::ZERO { aiur_fn_734(__args, record, io_buffer, false)? } else { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_734] = unsafe { *(result.output.as_ptr() as *const [G; OUT_734]) }; __ret } } else { aiur_fn_734(__args, record, io_buffer, __cu)? } }; + let __r_arr: [G; OUT_730] = { let __args: [G; IN_730] = [__v_36, __v_28, __v_29, __v_30, __v_31, __v_32, __v_33, __v_34, __v_35]; let __cu = unconstrained; if let Some(result) = record.function_queries[730].get_mut(&__args[..]) { if !__cu && *result.multiplicity == G::ZERO { aiur_fn_730(__args, record, io_buffer, false)? } else { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_730] = unsafe { *(result.output.as_ptr() as *const [G; OUT_730]) }; __ret } } else { aiur_fn_730(__args, record, io_buffer, __cu)? } }; let __v_37: G = __r_arr[0]; let __v_38: G = __r_arr[1]; break '__mc_0 [__v_37, __v_38]; @@ -61882,8 +61610,8 @@ fn aiur_fn_735( let __v_29: G = __mc_out___mc_0[1]; let __v_30: G = G::from_u64(8); let __v_31: G = G::from_u64(0); - let __ret: [G; OUT_735] = [__v_30, __v_28, __v_31, __v_31, __v_31, __v_31, __v_31, __v_31, __v_31, __v_31, __v_31, __v_31, __v_31, __v_31, __v_31, __v_31, __v_31, __v_31, __v_31, __v_31, __v_31, __v_31, __v_31, __v_31, __v_31, __v_31, __v_31, __v_31, __v_31, __v_31, __v_31, __v_31, __v_31, __v_31, __v_31, __v_31, __v_31, __v_31, __v_31, __v_31, __v_31, __v_31, __v_31, __v_31, __v_31, __v_31, __v_31, __v_31, __v_31, __v_31, __v_31, __v_31, __v_31, __v_31, __v_29]; - if let Some(result) = record.function_queries[735].get_mut(&inp[..]) { debug_assert_eq!(result.output, &__ret[..]); if !unconstrained { *result.multiplicity += G::ONE; } } else { record.function_queries[735].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained)); }; + let __ret: [G; OUT_731] = [__v_30, __v_28, __v_31, __v_31, __v_31, __v_31, __v_31, __v_31, __v_31, __v_31, __v_31, __v_31, __v_31, __v_31, __v_31, __v_31, __v_31, __v_31, __v_31, __v_31, __v_31, __v_31, __v_31, __v_31, __v_31, __v_31, __v_31, __v_31, __v_31, __v_31, __v_31, __v_31, __v_31, __v_31, __v_31, __v_31, __v_31, __v_31, __v_31, __v_31, __v_31, __v_31, __v_31, __v_31, __v_31, __v_31, __v_31, __v_31, __v_31, __v_31, __v_31, __v_31, __v_31, __v_31, __v_29]; + if let Some(result) = record.function_queries[731].get_mut(&inp[..]) { debug_assert_eq!(result.output, &__ret[..]); if !unconstrained { *result.multiplicity += G::ONE; } } else { record.function_queries[731].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained)); }; return Ok(__ret); }, _ => { @@ -61893,15 +61621,15 @@ fn aiur_fn_735( }) } -const INPUT_SIZE_736: usize = 1; -const IN_736: usize = 1; -const OUT_736: usize = 1; -fn aiur_fn_736( - inp: [G; IN_736], +const INPUT_SIZE_732: usize = 1; +const IN_732: usize = 1; +const OUT_732: usize = 1; +fn aiur_fn_732( + inp: [G; IN_732], record: &mut QueryRecord, io_buffer: &mut IOBuffer, unconstrained: bool, -) -> Result<[G; OUT_736], ExecError> { +) -> Result<[G; OUT_732], ExecError> { stacker::maybe_grow(64 * 1024, 4 * 1024 * 1024, || { let __v_0: G = inp[0]; let __loaded: [G; 18] = { let __mq = record.memory_queries.get_mut(&18).ok_or(ExecError::InvalidMemorySize(18))?; let __ptr_u64 = __v_0.as_canonical_u64(); let __ptr_usize = usize::try_from(__ptr_u64).ok().ok_or(ExecError::PointerTooLarge(__ptr_u64))?; let (__args, __mult) = __mq.get_index_mut(__ptr_usize).ok_or(ExecError::UnboundPointer { ptr: __ptr_u64, size: 18 })?; if !unconstrained { *__mult += G::ONE; } let __arr: [G; 18] = __args[..18].try_into().unwrap(); __arr }; @@ -61930,40 +61658,40 @@ fn aiur_fn_736( let __v_22: G = __r_arr[0]; let __r_arr: [G; OUT_21] = { let __args: [G; IN_21] = [__v_22]; let __cu = unconstrained; if let Some(result) = record.function_queries[21].get_mut(&__args[..]) { if !__cu && *result.multiplicity == G::ZERO { aiur_fn_21(__args, record, io_buffer, false)? } else { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_21] = unsafe { *(result.output.as_ptr() as *const [G; OUT_21]) }; __ret } } else { aiur_fn_21(__args, record, io_buffer, __cu)? } }; let __v_23: G = __r_arr[0]; - let __ret: [G; OUT_736] = [__v_23]; - if let Some(result) = record.function_queries[736].get_mut(&inp[..]) { debug_assert_eq!(result.output, &__ret[..]); if !unconstrained { *result.multiplicity += G::ONE; } } else { record.function_queries[736].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained)); }; + let __ret: [G; OUT_732] = [__v_23]; + if let Some(result) = record.function_queries[732].get_mut(&inp[..]) { debug_assert_eq!(result.output, &__ret[..]); if !unconstrained { *result.multiplicity += G::ONE; } } else { record.function_queries[732].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained)); }; return Ok(__ret); }) } -const INPUT_SIZE_737: usize = 1; -const IN_737: usize = 1; -const OUT_737: usize = 1; -fn aiur_fn_737( - inp: [G; IN_737], +const INPUT_SIZE_733: usize = 1; +const IN_733: usize = 1; +const OUT_733: usize = 1; +fn aiur_fn_733( + inp: [G; IN_733], record: &mut QueryRecord, io_buffer: &mut IOBuffer, unconstrained: bool, -) -> Result<[G; OUT_737], ExecError> { +) -> Result<[G; OUT_733], ExecError> { stacker::maybe_grow(64 * 1024, 4 * 1024 * 1024, || { let __v_0: G = inp[0]; match __v_0.as_canonical_u64() { 0u64 => { let __v_1: G = G::from_u64(0); - let __ret: [G; OUT_737] = [__v_1]; - if let Some(result) = record.function_queries[737].get_mut(&inp[..]) { debug_assert_eq!(result.output, &__ret[..]); if !unconstrained { *result.multiplicity += G::ONE; } } else { record.function_queries[737].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained)); }; + let __ret: [G; OUT_733] = [__v_1]; + if let Some(result) = record.function_queries[733].get_mut(&inp[..]) { debug_assert_eq!(result.output, &__ret[..]); if !unconstrained { *result.multiplicity += G::ONE; } } else { record.function_queries[733].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained)); }; return Ok(__ret); }, 1u64 => { let __v_1: G = G::from_u64(1); - let __ret: [G; OUT_737] = [__v_1]; - if let Some(result) = record.function_queries[737].get_mut(&inp[..]) { debug_assert_eq!(result.output, &__ret[..]); if !unconstrained { *result.multiplicity += G::ONE; } } else { record.function_queries[737].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained)); }; + let __ret: [G; OUT_733] = [__v_1]; + if let Some(result) = record.function_queries[733].get_mut(&inp[..]) { debug_assert_eq!(result.output, &__ret[..]); if !unconstrained { *result.multiplicity += G::ONE; } } else { record.function_queries[733].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained)); }; return Ok(__ret); }, 2u64 => { let __v_1: G = G::from_u64(2); - let __ret: [G; OUT_737] = [__v_1]; - if let Some(result) = record.function_queries[737].get_mut(&inp[..]) { debug_assert_eq!(result.output, &__ret[..]); if !unconstrained { *result.multiplicity += G::ONE; } } else { record.function_queries[737].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained)); }; + let __ret: [G; OUT_733] = [__v_1]; + if let Some(result) = record.function_queries[733].get_mut(&inp[..]) { debug_assert_eq!(result.output, &__ret[..]); if !unconstrained { *result.multiplicity += G::ONE; } } else { record.function_queries[733].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained)); }; return Ok(__ret); }, _ => { @@ -61973,35 +61701,35 @@ fn aiur_fn_737( }) } -const INPUT_SIZE_738: usize = 3; -const IN_738: usize = 3; -const OUT_738: usize = 0; -fn aiur_fn_738( - inp: [G; IN_738], +const INPUT_SIZE_734: usize = 3; +const IN_734: usize = 3; +const OUT_734: usize = 0; +fn aiur_fn_734( + inp: [G; IN_734], record: &mut QueryRecord, io_buffer: &mut IOBuffer, unconstrained: bool, -) -> Result<[G; OUT_738], ExecError> { +) -> Result<[G; OUT_734], ExecError> { stacker::maybe_grow(64 * 1024, 4 * 1024 * 1024, || { let __v_0: G = inp[0]; let __v_1: G = inp[1]; let __v_2: G = inp[2]; match __v_1.as_canonical_u64() { 1u64 => { - let __ret: [G; OUT_738] = []; - if let Some(result) = record.function_queries[738].get_mut(&inp[..]) { debug_assert_eq!(result.output, &__ret[..]); if !unconstrained { *result.multiplicity += G::ONE; } } else { record.function_queries[738].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained)); }; + let __ret: [G; OUT_734] = []; + if let Some(result) = record.function_queries[734].get_mut(&inp[..]) { debug_assert_eq!(result.output, &__ret[..]); if !unconstrained { *result.multiplicity += G::ONE; } } else { record.function_queries[734].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained)); }; return Ok(__ret); }, 0u64 => { - let __r_arr: [G; OUT_737] = { let __args: [G; IN_737] = [__v_0]; let __cu = unconstrained; if let Some(result) = record.function_queries[737].get_mut(&__args[..]) { if !__cu && *result.multiplicity == G::ZERO { aiur_fn_737(__args, record, io_buffer, false)? } else { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_737] = unsafe { *(result.output.as_ptr() as *const [G; OUT_737]) }; __ret } } else { aiur_fn_737(__args, record, io_buffer, __cu)? } }; + let __r_arr: [G; OUT_733] = { let __args: [G; IN_733] = [__v_0]; let __cu = unconstrained; if let Some(result) = record.function_queries[733].get_mut(&__args[..]) { if !__cu && *result.multiplicity == G::ZERO { aiur_fn_733(__args, record, io_buffer, false)? } else { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_733] = unsafe { *(result.output.as_ptr() as *const [G; OUT_733]) }; __ret } } else { aiur_fn_733(__args, record, io_buffer, __cu)? } }; let __v_3: G = __r_arr[0]; - let __r_arr: [G; OUT_737] = { let __args: [G; IN_737] = [__v_2]; let __cu = unconstrained; if let Some(result) = record.function_queries[737].get_mut(&__args[..]) { if !__cu && *result.multiplicity == G::ZERO { aiur_fn_737(__args, record, io_buffer, false)? } else { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_737] = unsafe { *(result.output.as_ptr() as *const [G; OUT_737]) }; __ret } } else { aiur_fn_737(__args, record, io_buffer, __cu)? } }; + let __r_arr: [G; OUT_733] = { let __args: [G; IN_733] = [__v_2]; let __cu = unconstrained; if let Some(result) = record.function_queries[733].get_mut(&__args[..]) { if !__cu && *result.multiplicity == G::ZERO { aiur_fn_733(__args, record, io_buffer, false)? } else { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_733] = unsafe { *(result.output.as_ptr() as *const [G; OUT_733]) }; __ret } } else { aiur_fn_733(__args, record, io_buffer, __cu)? } }; let __v_4: G = __r_arr[0]; if (__v_3 != __v_4) { return Err(ExecError::AssertEqMismatch { lhs: __v_3.as_canonical_u64(), rhs: __v_4.as_canonical_u64(), msg: Some("Reveal: claimed definition kind != real".to_string()) }); } - let __ret: [G; OUT_738] = []; - if let Some(result) = record.function_queries[738].get_mut(&inp[..]) { debug_assert_eq!(result.output, &__ret[..]); if !unconstrained { *result.multiplicity += G::ONE; } } else { record.function_queries[738].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained)); }; + let __ret: [G; OUT_734] = []; + if let Some(result) = record.function_queries[734].get_mut(&inp[..]) { debug_assert_eq!(result.output, &__ret[..]); if !unconstrained { *result.multiplicity += G::ONE; } } else { record.function_queries[734].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained)); }; return Ok(__ret); }, _ => { @@ -62011,35 +61739,35 @@ fn aiur_fn_738( }) } -const INPUT_SIZE_739: usize = 3; -const IN_739: usize = 3; -const OUT_739: usize = 0; -fn aiur_fn_739( - inp: [G; IN_739], +const INPUT_SIZE_735: usize = 3; +const IN_735: usize = 3; +const OUT_735: usize = 0; +fn aiur_fn_735( + inp: [G; IN_735], record: &mut QueryRecord, io_buffer: &mut IOBuffer, unconstrained: bool, -) -> Result<[G; OUT_739], ExecError> { +) -> Result<[G; OUT_735], ExecError> { stacker::maybe_grow(64 * 1024, 4 * 1024 * 1024, || { let __v_0: G = inp[0]; let __v_1: G = inp[1]; let __v_2: G = inp[2]; match __v_1.as_canonical_u64() { 1u64 => { - let __ret: [G; OUT_739] = []; - if let Some(result) = record.function_queries[739].get_mut(&inp[..]) { debug_assert_eq!(result.output, &__ret[..]); if !unconstrained { *result.multiplicity += G::ONE; } } else { record.function_queries[739].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained)); }; + let __ret: [G; OUT_735] = []; + if let Some(result) = record.function_queries[735].get_mut(&inp[..]) { debug_assert_eq!(result.output, &__ret[..]); if !unconstrained { *result.multiplicity += G::ONE; } } else { record.function_queries[735].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained)); }; return Ok(__ret); }, 0u64 => { - let __r_arr: [G; OUT_737] = { let __args: [G; IN_737] = [__v_0]; let __cu = unconstrained; if let Some(result) = record.function_queries[737].get_mut(&__args[..]) { if !__cu && *result.multiplicity == G::ZERO { aiur_fn_737(__args, record, io_buffer, false)? } else { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_737] = unsafe { *(result.output.as_ptr() as *const [G; OUT_737]) }; __ret } } else { aiur_fn_737(__args, record, io_buffer, __cu)? } }; + let __r_arr: [G; OUT_733] = { let __args: [G; IN_733] = [__v_0]; let __cu = unconstrained; if let Some(result) = record.function_queries[733].get_mut(&__args[..]) { if !__cu && *result.multiplicity == G::ZERO { aiur_fn_733(__args, record, io_buffer, false)? } else { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_733] = unsafe { *(result.output.as_ptr() as *const [G; OUT_733]) }; __ret } } else { aiur_fn_733(__args, record, io_buffer, __cu)? } }; let __v_3: G = __r_arr[0]; - let __r_arr: [G; OUT_737] = { let __args: [G; IN_737] = [__v_2]; let __cu = unconstrained; if let Some(result) = record.function_queries[737].get_mut(&__args[..]) { if !__cu && *result.multiplicity == G::ZERO { aiur_fn_737(__args, record, io_buffer, false)? } else { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_737] = unsafe { *(result.output.as_ptr() as *const [G; OUT_737]) }; __ret } } else { aiur_fn_737(__args, record, io_buffer, __cu)? } }; + let __r_arr: [G; OUT_733] = { let __args: [G; IN_733] = [__v_2]; let __cu = unconstrained; if let Some(result) = record.function_queries[733].get_mut(&__args[..]) { if !__cu && *result.multiplicity == G::ZERO { aiur_fn_733(__args, record, io_buffer, false)? } else { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_733] = unsafe { *(result.output.as_ptr() as *const [G; OUT_733]) }; __ret } } else { aiur_fn_733(__args, record, io_buffer, __cu)? } }; let __v_4: G = __r_arr[0]; if (__v_3 != __v_4) { return Err(ExecError::AssertEqMismatch { lhs: __v_3.as_canonical_u64(), rhs: __v_4.as_canonical_u64(), msg: Some("Reveal: claimed definition safety != real".to_string()) }); } - let __ret: [G; OUT_739] = []; - if let Some(result) = record.function_queries[739].get_mut(&inp[..]) { debug_assert_eq!(result.output, &__ret[..]); if !unconstrained { *result.multiplicity += G::ONE; } } else { record.function_queries[739].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained)); }; + let __ret: [G; OUT_735] = []; + if let Some(result) = record.function_queries[735].get_mut(&inp[..]) { debug_assert_eq!(result.output, &__ret[..]); if !unconstrained { *result.multiplicity += G::ONE; } } else { record.function_queries[735].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained)); }; return Ok(__ret); }, _ => { @@ -62049,23 +61777,23 @@ fn aiur_fn_739( }) } -const INPUT_SIZE_740: usize = 3; -const IN_740: usize = 3; -const OUT_740: usize = 0; -fn aiur_fn_740( - inp: [G; IN_740], +const INPUT_SIZE_736: usize = 3; +const IN_736: usize = 3; +const OUT_736: usize = 0; +fn aiur_fn_736( + inp: [G; IN_736], record: &mut QueryRecord, io_buffer: &mut IOBuffer, unconstrained: bool, -) -> Result<[G; OUT_740], ExecError> { +) -> Result<[G; OUT_736], ExecError> { stacker::maybe_grow(64 * 1024, 4 * 1024 * 1024, || { let __v_0: G = inp[0]; let __v_1: G = inp[1]; let __v_2: G = inp[2]; match __v_1.as_canonical_u64() { 1u64 => { - let __ret: [G; OUT_740] = []; - if let Some(result) = record.function_queries[740].get_mut(&inp[..]) { debug_assert_eq!(result.output, &__ret[..]); if !unconstrained { *result.multiplicity += G::ONE; } } else { record.function_queries[740].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained)); }; + let __ret: [G; OUT_736] = []; + if let Some(result) = record.function_queries[736].get_mut(&inp[..]) { debug_assert_eq!(result.output, &__ret[..]); if !unconstrained { *result.multiplicity += G::ONE; } } else { record.function_queries[736].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained)); }; return Ok(__ret); }, 0u64 => { @@ -62076,8 +61804,8 @@ fn aiur_fn_740( if (__v_3 != __v_4) { return Err(ExecError::AssertEqMismatch { lhs: __v_3.as_canonical_u64(), rhs: __v_4.as_canonical_u64(), msg: Some("Reveal: claimed quotient kind != real".to_string()) }); } - let __ret: [G; OUT_740] = []; - if let Some(result) = record.function_queries[740].get_mut(&inp[..]) { debug_assert_eq!(result.output, &__ret[..]); if !unconstrained { *result.multiplicity += G::ONE; } } else { record.function_queries[740].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained)); }; + let __ret: [G; OUT_736] = []; + if let Some(result) = record.function_queries[736].get_mut(&inp[..]) { debug_assert_eq!(result.output, &__ret[..]); if !unconstrained { *result.multiplicity += G::ONE; } } else { record.function_queries[736].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained)); }; return Ok(__ret); }, _ => { @@ -62087,31 +61815,31 @@ fn aiur_fn_740( }) } -const INPUT_SIZE_741: usize = 3; -const IN_741: usize = 3; -const OUT_741: usize = 0; -fn aiur_fn_741( - inp: [G; IN_741], +const INPUT_SIZE_737: usize = 3; +const IN_737: usize = 3; +const OUT_737: usize = 0; +fn aiur_fn_737( + inp: [G; IN_737], record: &mut QueryRecord, io_buffer: &mut IOBuffer, unconstrained: bool, -) -> Result<[G; OUT_741], ExecError> { +) -> Result<[G; OUT_737], ExecError> { stacker::maybe_grow(64 * 1024, 4 * 1024 * 1024, || { let __v_0: G = inp[0]; let __v_1: G = inp[1]; let __v_2: G = inp[2]; match __v_1.as_canonical_u64() { 1u64 => { - let __ret: [G; OUT_741] = []; - if let Some(result) = record.function_queries[741].get_mut(&inp[..]) { debug_assert_eq!(result.output, &__ret[..]); if !unconstrained { *result.multiplicity += G::ONE; } } else { record.function_queries[741].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained)); }; + let __ret: [G; OUT_737] = []; + if let Some(result) = record.function_queries[737].get_mut(&inp[..]) { debug_assert_eq!(result.output, &__ret[..]); if !unconstrained { *result.multiplicity += G::ONE; } } else { record.function_queries[737].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained)); }; return Ok(__ret); }, 0u64 => { if (__v_0 != __v_2) { return Err(ExecError::AssertEqMismatch { lhs: __v_0.as_canonical_u64(), rhs: __v_2.as_canonical_u64(), msg: Some("Reveal: claimed flag != real".to_string()) }); } - let __ret: [G; OUT_741] = []; - if let Some(result) = record.function_queries[741].get_mut(&inp[..]) { debug_assert_eq!(result.output, &__ret[..]); if !unconstrained { *result.multiplicity += G::ONE; } } else { record.function_queries[741].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained)); }; + let __ret: [G; OUT_737] = []; + if let Some(result) = record.function_queries[737].get_mut(&inp[..]) { debug_assert_eq!(result.output, &__ret[..]); if !unconstrained { *result.multiplicity += G::ONE; } } else { record.function_queries[737].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained)); }; return Ok(__ret); }, _ => { @@ -62121,15 +61849,15 @@ fn aiur_fn_741( }) } -const INPUT_SIZE_742: usize = 17; -const IN_742: usize = 17; -const OUT_742: usize = 0; -fn aiur_fn_742( - inp: [G; IN_742], +const INPUT_SIZE_738: usize = 17; +const IN_738: usize = 17; +const OUT_738: usize = 0; +fn aiur_fn_738( + inp: [G; IN_738], record: &mut QueryRecord, io_buffer: &mut IOBuffer, unconstrained: bool, -) -> Result<[G; OUT_742], ExecError> { +) -> Result<[G; OUT_738], ExecError> { stacker::maybe_grow(64 * 1024, 4 * 1024 * 1024, || { let __v_0: G = inp[0]; let __v_1: G = inp[1]; @@ -62150,8 +61878,8 @@ fn aiur_fn_742( let __v_16: G = inp[16]; match __v_8.as_canonical_u64() { 1u64 => { - let __ret: [G; OUT_742] = []; - if let Some(result) = record.function_queries[742].get_mut(&inp[..]) { debug_assert_eq!(result.output, &__ret[..]); if !unconstrained { *result.multiplicity += G::ONE; } } else { record.function_queries[742].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained)); }; + let __ret: [G; OUT_738] = []; + if let Some(result) = record.function_queries[738].get_mut(&inp[..]) { debug_assert_eq!(result.output, &__ret[..]); if !unconstrained { *result.multiplicity += G::ONE; } } else { record.function_queries[738].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained)); }; return Ok(__ret); }, 0u64 => { @@ -62179,8 +61907,8 @@ fn aiur_fn_742( if (__v_7 != __v_16) { return Err(ExecError::AssertEqMismatch { lhs: __v_7.as_canonical_u64(), rhs: __v_16.as_canonical_u64(), msg: Some("Reveal: claimed numeric field != real".to_string()) }); } - let __ret: [G; OUT_742] = []; - if let Some(result) = record.function_queries[742].get_mut(&inp[..]) { debug_assert_eq!(result.output, &__ret[..]); if !unconstrained { *result.multiplicity += G::ONE; } } else { record.function_queries[742].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained)); }; + let __ret: [G; OUT_738] = []; + if let Some(result) = record.function_queries[738].get_mut(&inp[..]) { debug_assert_eq!(result.output, &__ret[..]); if !unconstrained { *result.multiplicity += G::ONE; } } else { record.function_queries[738].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained)); }; return Ok(__ret); }, _ => { @@ -62190,23 +61918,23 @@ fn aiur_fn_742( }) } -const INPUT_SIZE_743: usize = 3; -const IN_743: usize = 3; -const OUT_743: usize = 0; -fn aiur_fn_743( - inp: [G; IN_743], +const INPUT_SIZE_739: usize = 3; +const IN_739: usize = 3; +const OUT_739: usize = 0; +fn aiur_fn_739( + inp: [G; IN_739], record: &mut QueryRecord, io_buffer: &mut IOBuffer, unconstrained: bool, -) -> Result<[G; OUT_743], ExecError> { +) -> Result<[G; OUT_739], ExecError> { stacker::maybe_grow(64 * 1024, 4 * 1024 * 1024, || { let __v_0: G = inp[0]; let __v_1: G = inp[1]; let __v_2: G = inp[2]; match __v_1.as_canonical_u64() { 1u64 => { - let __ret: [G; OUT_743] = []; - if let Some(result) = record.function_queries[743].get_mut(&inp[..]) { debug_assert_eq!(result.output, &__ret[..]); if !unconstrained { *result.multiplicity += G::ONE; } } else { record.function_queries[743].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained)); }; + let __ret: [G; OUT_739] = []; + if let Some(result) = record.function_queries[739].get_mut(&inp[..]) { debug_assert_eq!(result.output, &__ret[..]); if !unconstrained { *result.multiplicity += G::ONE; } } else { record.function_queries[739].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained)); }; return Ok(__ret); }, 0u64 => { @@ -62372,8 +62100,8 @@ fn aiur_fn_743( if (__v_34 != __v_66) { return Err(ExecError::AssertEqMismatch { lhs: __v_34.as_canonical_u64(), rhs: __v_66.as_canonical_u64(), msg: Some("Reveal: claimed address field != real".to_string()) }); } - let __ret: [G; OUT_743] = []; - if let Some(result) = record.function_queries[743].get_mut(&inp[..]) { debug_assert_eq!(result.output, &__ret[..]); if !unconstrained { *result.multiplicity += G::ONE; } } else { record.function_queries[743].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained)); }; + let __ret: [G; OUT_739] = []; + if let Some(result) = record.function_queries[739].get_mut(&inp[..]) { debug_assert_eq!(result.output, &__ret[..]); if !unconstrained { *result.multiplicity += G::ONE; } } else { record.function_queries[739].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained)); }; return Ok(__ret); }, _ => { @@ -62383,27 +62111,27 @@ fn aiur_fn_743( }) } -const INPUT_SIZE_744: usize = 3; -const IN_744: usize = 3; -const OUT_744: usize = 0; -fn aiur_fn_744( - inp: [G; IN_744], +const INPUT_SIZE_740: usize = 3; +const IN_740: usize = 3; +const OUT_740: usize = 0; +fn aiur_fn_740( + inp: [G; IN_740], record: &mut QueryRecord, io_buffer: &mut IOBuffer, unconstrained: bool, -) -> Result<[G; OUT_744], ExecError> { +) -> Result<[G; OUT_740], ExecError> { stacker::maybe_grow(64 * 1024, 4 * 1024 * 1024, || { let __v_0: G = inp[0]; let __v_1: G = inp[1]; let __v_2: G = inp[2]; match __v_1.as_canonical_u64() { 1u64 => { - let __ret: [G; OUT_744] = []; - if let Some(result) = record.function_queries[744].get_mut(&inp[..]) { debug_assert_eq!(result.output, &__ret[..]); if !unconstrained { *result.multiplicity += G::ONE; } } else { record.function_queries[744].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained)); }; + let __ret: [G; OUT_740] = []; + if let Some(result) = record.function_queries[740].get_mut(&inp[..]) { debug_assert_eq!(result.output, &__ret[..]); if !unconstrained { *result.multiplicity += G::ONE; } } else { record.function_queries[740].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained)); }; return Ok(__ret); }, 0u64 => { - let __r_arr: [G; OUT_736] = { let __args: [G; IN_736] = [__v_0]; let __cu = unconstrained; if let Some(result) = record.function_queries[736].get_mut(&__args[..]) { if !__cu && *result.multiplicity == G::ZERO { aiur_fn_736(__args, record, io_buffer, false)? } else { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_736] = unsafe { *(result.output.as_ptr() as *const [G; OUT_736]) }; __ret } } else { aiur_fn_736(__args, record, io_buffer, __cu)? } }; + let __r_arr: [G; OUT_732] = { let __args: [G; IN_732] = [__v_0]; let __cu = unconstrained; if let Some(result) = record.function_queries[732].get_mut(&__args[..]) { if !__cu && *result.multiplicity == G::ZERO { aiur_fn_732(__args, record, io_buffer, false)? } else { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_732] = unsafe { *(result.output.as_ptr() as *const [G; OUT_732]) }; __ret } } else { aiur_fn_732(__args, record, io_buffer, __cu)? } }; let __v_3: G = __r_arr[0]; let __loaded: [G; 32] = { let __mq = record.memory_queries.get_mut(&32).ok_or(ExecError::InvalidMemorySize(32))?; let __ptr_u64 = __v_3.as_canonical_u64(); let __ptr_usize = usize::try_from(__ptr_u64).ok().ok_or(ExecError::PointerTooLarge(__ptr_u64))?; let (__args, __mult) = __mq.get_index_mut(__ptr_usize).ok_or(ExecError::UnboundPointer { ptr: __ptr_u64, size: 32 })?; if !unconstrained { *__mult += G::ONE; } let __arr: [G; 32] = __args[..32].try_into().unwrap(); __arr }; let __v_4: G = __loaded[0]; @@ -62567,8 +62295,8 @@ fn aiur_fn_744( if (__v_35 != __v_67) { return Err(ExecError::AssertEqMismatch { lhs: __v_35.as_canonical_u64(), rhs: __v_67.as_canonical_u64(), msg: Some("Reveal: claimed expr hash != hash of the real expr".to_string()) }); } - let __ret: [G; OUT_744] = []; - if let Some(result) = record.function_queries[744].get_mut(&inp[..]) { debug_assert_eq!(result.output, &__ret[..]); if !unconstrained { *result.multiplicity += G::ONE; } } else { record.function_queries[744].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained)); }; + let __ret: [G; OUT_740] = []; + if let Some(result) = record.function_queries[740].get_mut(&inp[..]) { debug_assert_eq!(result.output, &__ret[..]); if !unconstrained { *result.multiplicity += G::ONE; } } else { record.function_queries[740].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained)); }; return Ok(__ret); }, _ => { @@ -62578,15 +62306,15 @@ fn aiur_fn_744( }) } -const INPUT_SIZE_745: usize = 10; -const IN_745: usize = 10; -const OUT_745: usize = 0; -fn aiur_fn_745( - inp: [G; IN_745], +const INPUT_SIZE_741: usize = 10; +const IN_741: usize = 10; +const OUT_741: usize = 0; +fn aiur_fn_741( + inp: [G; IN_741], record: &mut QueryRecord, io_buffer: &mut IOBuffer, unconstrained: bool, -) -> Result<[G; OUT_745], ExecError> { +) -> Result<[G; OUT_741], ExecError> { stacker::maybe_grow(64 * 1024, 4 * 1024 * 1024, || { let __v_0: G = inp[0]; let __v_1: G = inp[1]; @@ -62634,8 +62362,8 @@ fn aiur_fn_745( let __v_39: G = __loaded[10]; match __v_29.as_canonical_u64() { 1u64 => { - let __ret: [G; OUT_745] = []; - if let Some(result) = record.function_queries[745].get_mut(&inp[..]) { debug_assert_eq!(result.output, &__ret[..]); if !unconstrained { *result.multiplicity += G::ONE; } } else { record.function_queries[745].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained)); }; + let __ret: [G; OUT_741] = []; + if let Some(result) = record.function_queries[741].get_mut(&inp[..]) { debug_assert_eq!(result.output, &__ret[..]); if !unconstrained { *result.multiplicity += G::ONE; } } else { record.function_queries[741].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained)); }; return Ok(__ret); }, _ => { @@ -62663,7 +62391,7 @@ fn aiur_fn_745( match __v_30.as_canonical_u64() { _ => { let __v_40: G = G::from_u64(0); - let __r_arr: [G; OUT_744] = { let __args: [G; IN_744] = [__v_38, __v_40, __v_27]; let __cu = unconstrained; if let Some(result) = record.function_queries[744].get_mut(&__args[..]) { if !__cu && *result.multiplicity == G::ZERO { aiur_fn_744(__args, record, io_buffer, false)? } else { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_744] = unsafe { *(result.output.as_ptr() as *const [G; OUT_744]) }; __ret } } else { aiur_fn_744(__args, record, io_buffer, __cu)? } }; + let __r_arr: [G; OUT_740] = { let __args: [G; IN_740] = [__v_38, __v_40, __v_27]; let __cu = unconstrained; if let Some(result) = record.function_queries[740].get_mut(&__args[..]) { if !__cu && *result.multiplicity == G::ZERO { aiur_fn_740(__args, record, io_buffer, false)? } else { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_740] = unsafe { *(result.output.as_ptr() as *const [G; OUT_740]) }; __ret } } else { aiur_fn_740(__args, record, io_buffer, __cu)? } }; if (__v_11 != __v_2) { return Err(ExecError::AssertEqMismatch { lhs: __v_11.as_canonical_u64(), rhs: __v_2.as_canonical_u64(), msg: Some("Reveal: claimed recursor rule index != its position".to_string()) }); } @@ -62721,9 +62449,9 @@ fn aiur_fn_745( let __v_46: G = __r_arr[5]; let __v_47: G = __r_arr[6]; let __v_48: G = __r_arr[7]; - let __r_arr: [G; OUT_745] = { let __args: [G; IN_745] = [__v_39, __v_28, __v_41, __v_42, __v_43, __v_44, __v_45, __v_46, __v_47, __v_48]; let __cu = unconstrained; if let Some(result) = record.function_queries[745].get_mut(&__args[..]) { if !__cu && *result.multiplicity == G::ZERO { aiur_fn_745(__args, record, io_buffer, false)? } else { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_745] = unsafe { *(result.output.as_ptr() as *const [G; OUT_745]) }; __ret } } else { aiur_fn_745(__args, record, io_buffer, __cu)? } }; - let __ret: [G; OUT_745] = []; - if let Some(result) = record.function_queries[745].get_mut(&inp[..]) { debug_assert_eq!(result.output, &__ret[..]); if !unconstrained { *result.multiplicity += G::ONE; } } else { record.function_queries[745].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained)); }; + let __r_arr: [G; OUT_741] = { let __args: [G; IN_741] = [__v_39, __v_28, __v_41, __v_42, __v_43, __v_44, __v_45, __v_46, __v_47, __v_48]; let __cu = unconstrained; if let Some(result) = record.function_queries[741].get_mut(&__args[..]) { if !__cu && *result.multiplicity == G::ZERO { aiur_fn_741(__args, record, io_buffer, false)? } else { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_741] = unsafe { *(result.output.as_ptr() as *const [G; OUT_741]) }; __ret } } else { aiur_fn_741(__args, record, io_buffer, __cu)? } }; + let __ret: [G; OUT_741] = []; + if let Some(result) = record.function_queries[741].get_mut(&inp[..]) { debug_assert_eq!(result.output, &__ret[..]); if !unconstrained { *result.multiplicity += G::ONE; } } else { record.function_queries[741].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained)); }; return Ok(__ret); }, } @@ -62742,23 +62470,23 @@ fn aiur_fn_745( }) } -const INPUT_SIZE_746: usize = 3; -const IN_746: usize = 3; -const OUT_746: usize = 0; -fn aiur_fn_746( - inp: [G; IN_746], +const INPUT_SIZE_742: usize = 3; +const IN_742: usize = 3; +const OUT_742: usize = 0; +fn aiur_fn_742( + inp: [G; IN_742], record: &mut QueryRecord, io_buffer: &mut IOBuffer, unconstrained: bool, -) -> Result<[G; OUT_746], ExecError> { +) -> Result<[G; OUT_742], ExecError> { stacker::maybe_grow(64 * 1024, 4 * 1024 * 1024, || { let __v_0: G = inp[0]; let __v_1: G = inp[1]; let __v_2: G = inp[2]; match __v_1.as_canonical_u64() { 1u64 => { - let __ret: [G; OUT_746] = []; - if let Some(result) = record.function_queries[746].get_mut(&inp[..]) { debug_assert_eq!(result.output, &__ret[..]); if !unconstrained { *result.multiplicity += G::ONE; } } else { record.function_queries[746].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained)); }; + let __ret: [G; OUT_742] = []; + if let Some(result) = record.function_queries[742].get_mut(&inp[..]) { debug_assert_eq!(result.output, &__ret[..]); if !unconstrained { *result.multiplicity += G::ONE; } } else { record.function_queries[742].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained)); }; return Ok(__ret); }, 0u64 => { @@ -62770,9 +62498,9 @@ fn aiur_fn_746( let __v_8: G = G::from_u64(0); let __v_9: G = G::from_u64(0); let __v_10: G = G::from_u64(0); - let __r_arr: [G; OUT_745] = { let __args: [G; IN_745] = [__v_0, __v_2, __v_3, __v_4, __v_5, __v_6, __v_7, __v_8, __v_9, __v_10]; let __cu = unconstrained; if let Some(result) = record.function_queries[745].get_mut(&__args[..]) { if !__cu && *result.multiplicity == G::ZERO { aiur_fn_745(__args, record, io_buffer, false)? } else { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_745] = unsafe { *(result.output.as_ptr() as *const [G; OUT_745]) }; __ret } } else { aiur_fn_745(__args, record, io_buffer, __cu)? } }; - let __ret: [G; OUT_746] = []; - if let Some(result) = record.function_queries[746].get_mut(&inp[..]) { debug_assert_eq!(result.output, &__ret[..]); if !unconstrained { *result.multiplicity += G::ONE; } } else { record.function_queries[746].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained)); }; + let __r_arr: [G; OUT_741] = { let __args: [G; IN_741] = [__v_0, __v_2, __v_3, __v_4, __v_5, __v_6, __v_7, __v_8, __v_9, __v_10]; let __cu = unconstrained; if let Some(result) = record.function_queries[741].get_mut(&__args[..]) { if !__cu && *result.multiplicity == G::ZERO { aiur_fn_741(__args, record, io_buffer, false)? } else { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_741] = unsafe { *(result.output.as_ptr() as *const [G; OUT_741]) }; __ret } } else { aiur_fn_741(__args, record, io_buffer, __cu)? } }; + let __ret: [G; OUT_742] = []; + if let Some(result) = record.function_queries[742].get_mut(&inp[..]) { debug_assert_eq!(result.output, &__ret[..]); if !unconstrained { *result.multiplicity += G::ONE; } } else { record.function_queries[742].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained)); }; return Ok(__ret); }, _ => { @@ -62782,15 +62510,15 @@ fn aiur_fn_746( }) } -const INPUT_SIZE_747: usize = 49; -const IN_747: usize = 49; -const OUT_747: usize = 0; -fn aiur_fn_747( - inp: [G; IN_747], +const INPUT_SIZE_743: usize = 49; +const IN_743: usize = 49; +const OUT_743: usize = 0; +fn aiur_fn_743( + inp: [G; IN_743], record: &mut QueryRecord, io_buffer: &mut IOBuffer, unconstrained: bool, -) -> Result<[G; OUT_747], ExecError> { +) -> Result<[G; OUT_743], ExecError> { stacker::maybe_grow(64 * 1024, 4 * 1024 * 1024, || { let __v_0: G = inp[0]; let __v_1: G = inp[1]; @@ -62841,7 +62569,7 @@ fn aiur_fn_747( let __v_46: G = inp[46]; let __v_47: G = inp[47]; let __v_48: G = inp[48]; - let __r_arr: [G; OUT_771] = { let __args: [G; IN_771] = [__v_0, __v_1, __v_2, __v_3, __v_4, __v_5, __v_6, __v_7, __v_8]; let __cu = unconstrained; if let Some(result) = record.function_queries[771].get_mut(&__args[..]) { if !__cu && *result.multiplicity == G::ZERO { aiur_fn_771(__args, record, io_buffer, false)? } else { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_771] = unsafe { *(result.output.as_ptr() as *const [G; OUT_771]) }; __ret } } else { aiur_fn_771(__args, record, io_buffer, __cu)? } }; + let __r_arr: [G; OUT_767] = { let __args: [G; IN_767] = [__v_0, __v_1, __v_2, __v_3, __v_4, __v_5, __v_6, __v_7, __v_8]; let __cu = unconstrained; if let Some(result) = record.function_queries[767].get_mut(&__args[..]) { if !__cu && *result.multiplicity == G::ZERO { aiur_fn_767(__args, record, io_buffer, false)? } else { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_767] = unsafe { *(result.output.as_ptr() as *const [G; OUT_767]) }; __ret } } else { aiur_fn_767(__args, record, io_buffer, __cu)? } }; let __v_49: G = __r_arr[0]; let __v_50: G = __r_arr[1]; let __v_51: G = __r_arr[2]; @@ -62880,14 +62608,14 @@ fn aiur_fn_747( _ => { match __v_49.as_canonical_u64() { _ => { - let __r_arr: [G; OUT_741] = { let __args: [G; IN_741] = [__v_49, __v_9, __v_10]; let __cu = unconstrained; if let Some(result) = record.function_queries[741].get_mut(&__args[..]) { if !__cu && *result.multiplicity == G::ZERO { aiur_fn_741(__args, record, io_buffer, false)? } else { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_741] = unsafe { *(result.output.as_ptr() as *const [G; OUT_741]) }; __ret } } else { aiur_fn_741(__args, record, io_buffer, __cu)? } }; - let __r_arr: [G; OUT_742] = { let __args: [G; IN_742] = [__v_50, __v_51, __v_52, __v_53, __v_54, __v_55, __v_56, __v_57, __v_11, __v_12, __v_13, __v_14, __v_15, __v_16, __v_17, __v_18, __v_19]; let __cu = unconstrained; if let Some(result) = record.function_queries[742].get_mut(&__args[..]) { if !__cu && *result.multiplicity == G::ZERO { aiur_fn_742(__args, record, io_buffer, false)? } else { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_742] = unsafe { *(result.output.as_ptr() as *const [G; OUT_742]) }; __ret } } else { aiur_fn_742(__args, record, io_buffer, __cu)? } }; - let __r_arr: [G; OUT_742] = { let __args: [G; IN_742] = [__v_58, __v_59, __v_60, __v_61, __v_62, __v_63, __v_64, __v_65, __v_20, __v_21, __v_22, __v_23, __v_24, __v_25, __v_26, __v_27, __v_28]; let __cu = unconstrained; if let Some(result) = record.function_queries[742].get_mut(&__args[..]) { if !__cu && *result.multiplicity == G::ZERO { aiur_fn_742(__args, record, io_buffer, false)? } else { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_742] = unsafe { *(result.output.as_ptr() as *const [G; OUT_742]) }; __ret } } else { aiur_fn_742(__args, record, io_buffer, __cu)? } }; - let __r_arr: [G; OUT_742] = { let __args: [G; IN_742] = [__v_66, __v_67, __v_68, __v_69, __v_70, __v_71, __v_72, __v_73, __v_29, __v_30, __v_31, __v_32, __v_33, __v_34, __v_35, __v_36, __v_37]; let __cu = unconstrained; if let Some(result) = record.function_queries[742].get_mut(&__args[..]) { if !__cu && *result.multiplicity == G::ZERO { aiur_fn_742(__args, record, io_buffer, false)? } else { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_742] = unsafe { *(result.output.as_ptr() as *const [G; OUT_742]) }; __ret } } else { aiur_fn_742(__args, record, io_buffer, __cu)? } }; - let __r_arr: [G; OUT_742] = { let __args: [G; IN_742] = [__v_74, __v_75, __v_76, __v_77, __v_78, __v_79, __v_80, __v_81, __v_38, __v_39, __v_40, __v_41, __v_42, __v_43, __v_44, __v_45, __v_46]; let __cu = unconstrained; if let Some(result) = record.function_queries[742].get_mut(&__args[..]) { if !__cu && *result.multiplicity == G::ZERO { aiur_fn_742(__args, record, io_buffer, false)? } else { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_742] = unsafe { *(result.output.as_ptr() as *const [G; OUT_742]) }; __ret } } else { aiur_fn_742(__args, record, io_buffer, __cu)? } }; - let __r_arr: [G; OUT_744] = { let __args: [G; IN_744] = [__v_82, __v_47, __v_48]; let __cu = unconstrained; if let Some(result) = record.function_queries[744].get_mut(&__args[..]) { if !__cu && *result.multiplicity == G::ZERO { aiur_fn_744(__args, record, io_buffer, false)? } else { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_744] = unsafe { *(result.output.as_ptr() as *const [G; OUT_744]) }; __ret } } else { aiur_fn_744(__args, record, io_buffer, __cu)? } }; - let __ret: [G; OUT_747] = []; - if let Some(result) = record.function_queries[747].get_mut(&inp[..]) { debug_assert_eq!(result.output, &__ret[..]); if !unconstrained { *result.multiplicity += G::ONE; } } else { record.function_queries[747].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained)); }; + let __r_arr: [G; OUT_737] = { let __args: [G; IN_737] = [__v_49, __v_9, __v_10]; let __cu = unconstrained; if let Some(result) = record.function_queries[737].get_mut(&__args[..]) { if !__cu && *result.multiplicity == G::ZERO { aiur_fn_737(__args, record, io_buffer, false)? } else { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_737] = unsafe { *(result.output.as_ptr() as *const [G; OUT_737]) }; __ret } } else { aiur_fn_737(__args, record, io_buffer, __cu)? } }; + let __r_arr: [G; OUT_738] = { let __args: [G; IN_738] = [__v_50, __v_51, __v_52, __v_53, __v_54, __v_55, __v_56, __v_57, __v_11, __v_12, __v_13, __v_14, __v_15, __v_16, __v_17, __v_18, __v_19]; let __cu = unconstrained; if let Some(result) = record.function_queries[738].get_mut(&__args[..]) { if !__cu && *result.multiplicity == G::ZERO { aiur_fn_738(__args, record, io_buffer, false)? } else { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_738] = unsafe { *(result.output.as_ptr() as *const [G; OUT_738]) }; __ret } } else { aiur_fn_738(__args, record, io_buffer, __cu)? } }; + let __r_arr: [G; OUT_738] = { let __args: [G; IN_738] = [__v_58, __v_59, __v_60, __v_61, __v_62, __v_63, __v_64, __v_65, __v_20, __v_21, __v_22, __v_23, __v_24, __v_25, __v_26, __v_27, __v_28]; let __cu = unconstrained; if let Some(result) = record.function_queries[738].get_mut(&__args[..]) { if !__cu && *result.multiplicity == G::ZERO { aiur_fn_738(__args, record, io_buffer, false)? } else { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_738] = unsafe { *(result.output.as_ptr() as *const [G; OUT_738]) }; __ret } } else { aiur_fn_738(__args, record, io_buffer, __cu)? } }; + let __r_arr: [G; OUT_738] = { let __args: [G; IN_738] = [__v_66, __v_67, __v_68, __v_69, __v_70, __v_71, __v_72, __v_73, __v_29, __v_30, __v_31, __v_32, __v_33, __v_34, __v_35, __v_36, __v_37]; let __cu = unconstrained; if let Some(result) = record.function_queries[738].get_mut(&__args[..]) { if !__cu && *result.multiplicity == G::ZERO { aiur_fn_738(__args, record, io_buffer, false)? } else { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_738] = unsafe { *(result.output.as_ptr() as *const [G; OUT_738]) }; __ret } } else { aiur_fn_738(__args, record, io_buffer, __cu)? } }; + let __r_arr: [G; OUT_738] = { let __args: [G; IN_738] = [__v_74, __v_75, __v_76, __v_77, __v_78, __v_79, __v_80, __v_81, __v_38, __v_39, __v_40, __v_41, __v_42, __v_43, __v_44, __v_45, __v_46]; let __cu = unconstrained; if let Some(result) = record.function_queries[738].get_mut(&__args[..]) { if !__cu && *result.multiplicity == G::ZERO { aiur_fn_738(__args, record, io_buffer, false)? } else { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_738] = unsafe { *(result.output.as_ptr() as *const [G; OUT_738]) }; __ret } } else { aiur_fn_738(__args, record, io_buffer, __cu)? } }; + let __r_arr: [G; OUT_740] = { let __args: [G; IN_740] = [__v_82, __v_47, __v_48]; let __cu = unconstrained; if let Some(result) = record.function_queries[740].get_mut(&__args[..]) { if !__cu && *result.multiplicity == G::ZERO { aiur_fn_740(__args, record, io_buffer, false)? } else { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_740] = unsafe { *(result.output.as_ptr() as *const [G; OUT_740]) }; __ret } } else { aiur_fn_740(__args, record, io_buffer, __cu)? } }; + let __ret: [G; OUT_743] = []; + if let Some(result) = record.function_queries[743].get_mut(&inp[..]) { debug_assert_eq!(result.output, &__ret[..]); if !unconstrained { *result.multiplicity += G::ONE; } } else { record.function_queries[743].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained)); }; return Ok(__ret); }, } @@ -62896,15 +62624,15 @@ fn aiur_fn_747( }) } -const INPUT_SIZE_748: usize = 2; -const IN_748: usize = 2; -const OUT_748: usize = 0; -fn aiur_fn_748( - inp: [G; IN_748], +const INPUT_SIZE_744: usize = 2; +const IN_744: usize = 2; +const OUT_744: usize = 0; +fn aiur_fn_744( + inp: [G; IN_744], record: &mut QueryRecord, io_buffer: &mut IOBuffer, unconstrained: bool, -) -> Result<[G; OUT_748], ExecError> { +) -> Result<[G; OUT_744], ExecError> { stacker::maybe_grow(64 * 1024, 4 * 1024 * 1024, || { let __v_0: G = inp[0]; let __v_1: G = inp[1]; @@ -62961,15 +62689,15 @@ fn aiur_fn_748( let __v_51: G = __loaded[49]; match __v_2.as_canonical_u64() { 1u64 => { - let __ret: [G; OUT_748] = []; - if let Some(result) = record.function_queries[748].get_mut(&inp[..]) { debug_assert_eq!(result.output, &__ret[..]); if !unconstrained { *result.multiplicity += G::ONE; } } else { record.function_queries[748].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained)); }; + let __ret: [G; OUT_744] = []; + if let Some(result) = record.function_queries[744].get_mut(&inp[..]) { debug_assert_eq!(result.output, &__ret[..]); if !unconstrained { *result.multiplicity += G::ONE; } } else { record.function_queries[744].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained)); }; return Ok(__ret); }, 0u64 => { - let __r_arr: [G; OUT_747] = { let __args: [G; IN_747] = [__v_0, __v_3, __v_4, __v_5, __v_6, __v_7, __v_8, __v_9, __v_10, __v_11, __v_12, __v_13, __v_14, __v_15, __v_16, __v_17, __v_18, __v_19, __v_20, __v_21, __v_22, __v_23, __v_24, __v_25, __v_26, __v_27, __v_28, __v_29, __v_30, __v_31, __v_32, __v_33, __v_34, __v_35, __v_36, __v_37, __v_38, __v_39, __v_40, __v_41, __v_42, __v_43, __v_44, __v_45, __v_46, __v_47, __v_48, __v_49, __v_50]; let __cu = unconstrained; if let Some(result) = record.function_queries[747].get_mut(&__args[..]) { if !__cu && *result.multiplicity == G::ZERO { aiur_fn_747(__args, record, io_buffer, false)? } else { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_747] = unsafe { *(result.output.as_ptr() as *const [G; OUT_747]) }; __ret } } else { aiur_fn_747(__args, record, io_buffer, __cu)? } }; - let __r_arr: [G; OUT_748] = { let __args: [G; IN_748] = [__v_0, __v_51]; let __cu = unconstrained; if let Some(result) = record.function_queries[748].get_mut(&__args[..]) { if !__cu && *result.multiplicity == G::ZERO { aiur_fn_748(__args, record, io_buffer, false)? } else { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_748] = unsafe { *(result.output.as_ptr() as *const [G; OUT_748]) }; __ret } } else { aiur_fn_748(__args, record, io_buffer, __cu)? } }; - let __ret: [G; OUT_748] = []; - if let Some(result) = record.function_queries[748].get_mut(&inp[..]) { debug_assert_eq!(result.output, &__ret[..]); if !unconstrained { *result.multiplicity += G::ONE; } } else { record.function_queries[748].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained)); }; + let __r_arr: [G; OUT_743] = { let __args: [G; IN_743] = [__v_0, __v_3, __v_4, __v_5, __v_6, __v_7, __v_8, __v_9, __v_10, __v_11, __v_12, __v_13, __v_14, __v_15, __v_16, __v_17, __v_18, __v_19, __v_20, __v_21, __v_22, __v_23, __v_24, __v_25, __v_26, __v_27, __v_28, __v_29, __v_30, __v_31, __v_32, __v_33, __v_34, __v_35, __v_36, __v_37, __v_38, __v_39, __v_40, __v_41, __v_42, __v_43, __v_44, __v_45, __v_46, __v_47, __v_48, __v_49, __v_50]; let __cu = unconstrained; if let Some(result) = record.function_queries[743].get_mut(&__args[..]) { if !__cu && *result.multiplicity == G::ZERO { aiur_fn_743(__args, record, io_buffer, false)? } else { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_743] = unsafe { *(result.output.as_ptr() as *const [G; OUT_743]) }; __ret } } else { aiur_fn_743(__args, record, io_buffer, __cu)? } }; + let __r_arr: [G; OUT_744] = { let __args: [G; IN_744] = [__v_0, __v_51]; let __cu = unconstrained; if let Some(result) = record.function_queries[744].get_mut(&__args[..]) { if !__cu && *result.multiplicity == G::ZERO { aiur_fn_744(__args, record, io_buffer, false)? } else { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_744] = unsafe { *(result.output.as_ptr() as *const [G; OUT_744]) }; __ret } } else { aiur_fn_744(__args, record, io_buffer, __cu)? } }; + let __ret: [G; OUT_744] = []; + if let Some(result) = record.function_queries[744].get_mut(&inp[..]) { debug_assert_eq!(result.output, &__ret[..]); if !unconstrained { *result.multiplicity += G::ONE; } } else { record.function_queries[744].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained)); }; return Ok(__ret); }, _ => { @@ -62979,29 +62707,29 @@ fn aiur_fn_748( }) } -const INPUT_SIZE_749: usize = 3; -const IN_749: usize = 3; -const OUT_749: usize = 0; -fn aiur_fn_749( - inp: [G; IN_749], +const INPUT_SIZE_745: usize = 3; +const IN_745: usize = 3; +const OUT_745: usize = 0; +fn aiur_fn_745( + inp: [G; IN_745], record: &mut QueryRecord, io_buffer: &mut IOBuffer, unconstrained: bool, -) -> Result<[G; OUT_749], ExecError> { +) -> Result<[G; OUT_745], ExecError> { stacker::maybe_grow(64 * 1024, 4 * 1024 * 1024, || { let __v_0: G = inp[0]; let __v_1: G = inp[1]; let __v_2: G = inp[2]; match __v_1.as_canonical_u64() { 1u64 => { - let __ret: [G; OUT_749] = []; - if let Some(result) = record.function_queries[749].get_mut(&inp[..]) { debug_assert_eq!(result.output, &__ret[..]); if !unconstrained { *result.multiplicity += G::ONE; } } else { record.function_queries[749].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained)); }; + let __ret: [G; OUT_745] = []; + if let Some(result) = record.function_queries[745].get_mut(&inp[..]) { debug_assert_eq!(result.output, &__ret[..]); if !unconstrained { *result.multiplicity += G::ONE; } } else { record.function_queries[745].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained)); }; return Ok(__ret); }, 0u64 => { - let __r_arr: [G; OUT_748] = { let __args: [G; IN_748] = [__v_0, __v_2]; let __cu = unconstrained; if let Some(result) = record.function_queries[748].get_mut(&__args[..]) { if !__cu && *result.multiplicity == G::ZERO { aiur_fn_748(__args, record, io_buffer, false)? } else { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_748] = unsafe { *(result.output.as_ptr() as *const [G; OUT_748]) }; __ret } } else { aiur_fn_748(__args, record, io_buffer, __cu)? } }; - let __ret: [G; OUT_749] = []; - if let Some(result) = record.function_queries[749].get_mut(&inp[..]) { debug_assert_eq!(result.output, &__ret[..]); if !unconstrained { *result.multiplicity += G::ONE; } } else { record.function_queries[749].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained)); }; + let __r_arr: [G; OUT_744] = { let __args: [G; IN_744] = [__v_0, __v_2]; let __cu = unconstrained; if let Some(result) = record.function_queries[744].get_mut(&__args[..]) { if !__cu && *result.multiplicity == G::ZERO { aiur_fn_744(__args, record, io_buffer, false)? } else { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_744] = unsafe { *(result.output.as_ptr() as *const [G; OUT_744]) }; __ret } } else { aiur_fn_744(__args, record, io_buffer, __cu)? } }; + let __ret: [G; OUT_745] = []; + if let Some(result) = record.function_queries[745].get_mut(&inp[..]) { debug_assert_eq!(result.output, &__ret[..]); if !unconstrained { *result.multiplicity += G::ONE; } } else { record.function_queries[745].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained)); }; return Ok(__ret); }, _ => { @@ -63011,15 +62739,15 @@ fn aiur_fn_749( }) } -const INPUT_SIZE_750: usize = 99; -const IN_750: usize = 99; -const OUT_750: usize = 0; -fn aiur_fn_750( - inp: [G; IN_750], +const INPUT_SIZE_746: usize = 99; +const IN_746: usize = 99; +const OUT_746: usize = 0; +fn aiur_fn_746( + inp: [G; IN_746], record: &mut QueryRecord, io_buffer: &mut IOBuffer, unconstrained: bool, -) -> Result<[G; OUT_750], ExecError> { +) -> Result<[G; OUT_746], ExecError> { stacker::maybe_grow(64 * 1024, 4 * 1024 * 1024, || { let __v_0: G = inp[0]; let __v_1: G = inp[1]; @@ -63126,13 +62854,13 @@ fn aiur_fn_750( 0u64 => { match __v_1.as_canonical_u64() { _ => { - let __r_arr: [G; OUT_738] = { let __args: [G; IN_738] = [__v_1, __v_46, __v_47]; let __cu = unconstrained; if let Some(result) = record.function_queries[738].get_mut(&__args[..]) { if !__cu && *result.multiplicity == G::ZERO { aiur_fn_738(__args, record, io_buffer, false)? } else { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_738] = unsafe { *(result.output.as_ptr() as *const [G; OUT_738]) }; __ret } } else { aiur_fn_738(__args, record, io_buffer, __cu)? } }; - let __r_arr: [G; OUT_739] = { let __args: [G; IN_739] = [__v_2, __v_48, __v_49]; let __cu = unconstrained; if let Some(result) = record.function_queries[739].get_mut(&__args[..]) { if !__cu && *result.multiplicity == G::ZERO { aiur_fn_739(__args, record, io_buffer, false)? } else { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_739] = unsafe { *(result.output.as_ptr() as *const [G; OUT_739]) }; __ret } } else { aiur_fn_739(__args, record, io_buffer, __cu)? } }; - let __r_arr: [G; OUT_742] = { let __args: [G; IN_742] = [__v_3, __v_4, __v_5, __v_6, __v_7, __v_8, __v_9, __v_10, __v_50, __v_51, __v_52, __v_53, __v_54, __v_55, __v_56, __v_57, __v_58]; let __cu = unconstrained; if let Some(result) = record.function_queries[742].get_mut(&__args[..]) { if !__cu && *result.multiplicity == G::ZERO { aiur_fn_742(__args, record, io_buffer, false)? } else { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_742] = unsafe { *(result.output.as_ptr() as *const [G; OUT_742]) }; __ret } } else { aiur_fn_742(__args, record, io_buffer, __cu)? } }; - let __r_arr: [G; OUT_744] = { let __args: [G; IN_744] = [__v_11, __v_59, __v_60]; let __cu = unconstrained; if let Some(result) = record.function_queries[744].get_mut(&__args[..]) { if !__cu && *result.multiplicity == G::ZERO { aiur_fn_744(__args, record, io_buffer, false)? } else { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_744] = unsafe { *(result.output.as_ptr() as *const [G; OUT_744]) }; __ret } } else { aiur_fn_744(__args, record, io_buffer, __cu)? } }; - let __r_arr: [G; OUT_744] = { let __args: [G; IN_744] = [__v_12, __v_61, __v_62]; let __cu = unconstrained; if let Some(result) = record.function_queries[744].get_mut(&__args[..]) { if !__cu && *result.multiplicity == G::ZERO { aiur_fn_744(__args, record, io_buffer, false)? } else { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_744] = unsafe { *(result.output.as_ptr() as *const [G; OUT_744]) }; __ret } } else { aiur_fn_744(__args, record, io_buffer, __cu)? } }; - let __ret: [G; OUT_750] = []; - if let Some(result) = record.function_queries[750].get_mut(&inp[..]) { debug_assert_eq!(result.output, &__ret[..]); if !unconstrained { *result.multiplicity += G::ONE; } } else { record.function_queries[750].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained)); }; + let __r_arr: [G; OUT_734] = { let __args: [G; IN_734] = [__v_1, __v_46, __v_47]; let __cu = unconstrained; if let Some(result) = record.function_queries[734].get_mut(&__args[..]) { if !__cu && *result.multiplicity == G::ZERO { aiur_fn_734(__args, record, io_buffer, false)? } else { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_734] = unsafe { *(result.output.as_ptr() as *const [G; OUT_734]) }; __ret } } else { aiur_fn_734(__args, record, io_buffer, __cu)? } }; + let __r_arr: [G; OUT_735] = { let __args: [G; IN_735] = [__v_2, __v_48, __v_49]; let __cu = unconstrained; if let Some(result) = record.function_queries[735].get_mut(&__args[..]) { if !__cu && *result.multiplicity == G::ZERO { aiur_fn_735(__args, record, io_buffer, false)? } else { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_735] = unsafe { *(result.output.as_ptr() as *const [G; OUT_735]) }; __ret } } else { aiur_fn_735(__args, record, io_buffer, __cu)? } }; + let __r_arr: [G; OUT_738] = { let __args: [G; IN_738] = [__v_3, __v_4, __v_5, __v_6, __v_7, __v_8, __v_9, __v_10, __v_50, __v_51, __v_52, __v_53, __v_54, __v_55, __v_56, __v_57, __v_58]; let __cu = unconstrained; if let Some(result) = record.function_queries[738].get_mut(&__args[..]) { if !__cu && *result.multiplicity == G::ZERO { aiur_fn_738(__args, record, io_buffer, false)? } else { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_738] = unsafe { *(result.output.as_ptr() as *const [G; OUT_738]) }; __ret } } else { aiur_fn_738(__args, record, io_buffer, __cu)? } }; + let __r_arr: [G; OUT_740] = { let __args: [G; IN_740] = [__v_11, __v_59, __v_60]; let __cu = unconstrained; if let Some(result) = record.function_queries[740].get_mut(&__args[..]) { if !__cu && *result.multiplicity == G::ZERO { aiur_fn_740(__args, record, io_buffer, false)? } else { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_740] = unsafe { *(result.output.as_ptr() as *const [G; OUT_740]) }; __ret } } else { aiur_fn_740(__args, record, io_buffer, __cu)? } }; + let __r_arr: [G; OUT_740] = { let __args: [G; IN_740] = [__v_12, __v_61, __v_62]; let __cu = unconstrained; if let Some(result) = record.function_queries[740].get_mut(&__args[..]) { if !__cu && *result.multiplicity == G::ZERO { aiur_fn_740(__args, record, io_buffer, false)? } else { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_740] = unsafe { *(result.output.as_ptr() as *const [G; OUT_740]) }; __ret } } else { aiur_fn_740(__args, record, io_buffer, __cu)? } }; + let __ret: [G; OUT_746] = []; + if let Some(result) = record.function_queries[746].get_mut(&inp[..]) { debug_assert_eq!(result.output, &__ret[..]); if !unconstrained { *result.multiplicity += G::ONE; } } else { record.function_queries[746].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained)); }; return Ok(__ret); }, } @@ -63147,14 +62875,14 @@ fn aiur_fn_750( 1u64 => { match __v_1.as_canonical_u64() { _ => { - let __r_arr: [G; OUT_741] = { let __args: [G; IN_741] = [__v_1, __v_46, __v_47]; let __cu = unconstrained; if let Some(result) = record.function_queries[741].get_mut(&__args[..]) { if !__cu && *result.multiplicity == G::ZERO { aiur_fn_741(__args, record, io_buffer, false)? } else { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_741] = unsafe { *(result.output.as_ptr() as *const [G; OUT_741]) }; __ret } } else { aiur_fn_741(__args, record, io_buffer, __cu)? } }; - let __r_arr: [G; OUT_742] = { let __args: [G; IN_742] = [__v_2, __v_3, __v_4, __v_5, __v_6, __v_7, __v_8, __v_9, __v_48, __v_49, __v_50, __v_51, __v_52, __v_53, __v_54, __v_55, __v_56]; let __cu = unconstrained; if let Some(result) = record.function_queries[742].get_mut(&__args[..]) { if !__cu && *result.multiplicity == G::ZERO { aiur_fn_742(__args, record, io_buffer, false)? } else { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_742] = unsafe { *(result.output.as_ptr() as *const [G; OUT_742]) }; __ret } } else { aiur_fn_742(__args, record, io_buffer, __cu)? } }; - let __r_arr: [G; OUT_742] = { let __args: [G; IN_742] = [__v_10, __v_11, __v_12, __v_13, __v_14, __v_15, __v_16, __v_17, __v_57, __v_58, __v_59, __v_60, __v_61, __v_62, __v_63, __v_64, __v_65]; let __cu = unconstrained; if let Some(result) = record.function_queries[742].get_mut(&__args[..]) { if !__cu && *result.multiplicity == G::ZERO { aiur_fn_742(__args, record, io_buffer, false)? } else { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_742] = unsafe { *(result.output.as_ptr() as *const [G; OUT_742]) }; __ret } } else { aiur_fn_742(__args, record, io_buffer, __cu)? } }; - let __r_arr: [G; OUT_742] = { let __args: [G; IN_742] = [__v_18, __v_19, __v_20, __v_21, __v_22, __v_23, __v_24, __v_25, __v_66, __v_67, __v_68, __v_69, __v_70, __v_71, __v_72, __v_73, __v_74]; let __cu = unconstrained; if let Some(result) = record.function_queries[742].get_mut(&__args[..]) { if !__cu && *result.multiplicity == G::ZERO { aiur_fn_742(__args, record, io_buffer, false)? } else { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_742] = unsafe { *(result.output.as_ptr() as *const [G; OUT_742]) }; __ret } } else { aiur_fn_742(__args, record, io_buffer, __cu)? } }; - let __r_arr: [G; OUT_744] = { let __args: [G; IN_744] = [__v_26, __v_75, __v_76]; let __cu = unconstrained; if let Some(result) = record.function_queries[744].get_mut(&__args[..]) { if !__cu && *result.multiplicity == G::ZERO { aiur_fn_744(__args, record, io_buffer, false)? } else { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_744] = unsafe { *(result.output.as_ptr() as *const [G; OUT_744]) }; __ret } } else { aiur_fn_744(__args, record, io_buffer, __cu)? } }; - let __r_arr: [G; OUT_749] = { let __args: [G; IN_749] = [__v_27, __v_77, __v_78]; let __cu = unconstrained; if let Some(result) = record.function_queries[749].get_mut(&__args[..]) { if !__cu && *result.multiplicity == G::ZERO { aiur_fn_749(__args, record, io_buffer, false)? } else { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_749] = unsafe { *(result.output.as_ptr() as *const [G; OUT_749]) }; __ret } } else { aiur_fn_749(__args, record, io_buffer, __cu)? } }; - let __ret: [G; OUT_750] = []; - if let Some(result) = record.function_queries[750].get_mut(&inp[..]) { debug_assert_eq!(result.output, &__ret[..]); if !unconstrained { *result.multiplicity += G::ONE; } } else { record.function_queries[750].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained)); }; + let __r_arr: [G; OUT_737] = { let __args: [G; IN_737] = [__v_1, __v_46, __v_47]; let __cu = unconstrained; if let Some(result) = record.function_queries[737].get_mut(&__args[..]) { if !__cu && *result.multiplicity == G::ZERO { aiur_fn_737(__args, record, io_buffer, false)? } else { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_737] = unsafe { *(result.output.as_ptr() as *const [G; OUT_737]) }; __ret } } else { aiur_fn_737(__args, record, io_buffer, __cu)? } }; + let __r_arr: [G; OUT_738] = { let __args: [G; IN_738] = [__v_2, __v_3, __v_4, __v_5, __v_6, __v_7, __v_8, __v_9, __v_48, __v_49, __v_50, __v_51, __v_52, __v_53, __v_54, __v_55, __v_56]; let __cu = unconstrained; if let Some(result) = record.function_queries[738].get_mut(&__args[..]) { if !__cu && *result.multiplicity == G::ZERO { aiur_fn_738(__args, record, io_buffer, false)? } else { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_738] = unsafe { *(result.output.as_ptr() as *const [G; OUT_738]) }; __ret } } else { aiur_fn_738(__args, record, io_buffer, __cu)? } }; + let __r_arr: [G; OUT_738] = { let __args: [G; IN_738] = [__v_10, __v_11, __v_12, __v_13, __v_14, __v_15, __v_16, __v_17, __v_57, __v_58, __v_59, __v_60, __v_61, __v_62, __v_63, __v_64, __v_65]; let __cu = unconstrained; if let Some(result) = record.function_queries[738].get_mut(&__args[..]) { if !__cu && *result.multiplicity == G::ZERO { aiur_fn_738(__args, record, io_buffer, false)? } else { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_738] = unsafe { *(result.output.as_ptr() as *const [G; OUT_738]) }; __ret } } else { aiur_fn_738(__args, record, io_buffer, __cu)? } }; + let __r_arr: [G; OUT_738] = { let __args: [G; IN_738] = [__v_18, __v_19, __v_20, __v_21, __v_22, __v_23, __v_24, __v_25, __v_66, __v_67, __v_68, __v_69, __v_70, __v_71, __v_72, __v_73, __v_74]; let __cu = unconstrained; if let Some(result) = record.function_queries[738].get_mut(&__args[..]) { if !__cu && *result.multiplicity == G::ZERO { aiur_fn_738(__args, record, io_buffer, false)? } else { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_738] = unsafe { *(result.output.as_ptr() as *const [G; OUT_738]) }; __ret } } else { aiur_fn_738(__args, record, io_buffer, __cu)? } }; + let __r_arr: [G; OUT_740] = { let __args: [G; IN_740] = [__v_26, __v_75, __v_76]; let __cu = unconstrained; if let Some(result) = record.function_queries[740].get_mut(&__args[..]) { if !__cu && *result.multiplicity == G::ZERO { aiur_fn_740(__args, record, io_buffer, false)? } else { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_740] = unsafe { *(result.output.as_ptr() as *const [G; OUT_740]) }; __ret } } else { aiur_fn_740(__args, record, io_buffer, __cu)? } }; + let __r_arr: [G; OUT_745] = { let __args: [G; IN_745] = [__v_27, __v_77, __v_78]; let __cu = unconstrained; if let Some(result) = record.function_queries[745].get_mut(&__args[..]) { if !__cu && *result.multiplicity == G::ZERO { aiur_fn_745(__args, record, io_buffer, false)? } else { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_745] = unsafe { *(result.output.as_ptr() as *const [G; OUT_745]) }; __ret } } else { aiur_fn_745(__args, record, io_buffer, __cu)? } }; + let __ret: [G; OUT_746] = []; + if let Some(result) = record.function_queries[746].get_mut(&inp[..]) { debug_assert_eq!(result.output, &__ret[..]); if !unconstrained { *result.multiplicity += G::ONE; } } else { record.function_queries[746].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained)); }; return Ok(__ret); }, } @@ -63169,17 +62897,17 @@ fn aiur_fn_750( 2u64 => { match __v_1.as_canonical_u64() { _ => { - let __r_arr: [G; OUT_741] = { let __args: [G; IN_741] = [__v_1, __v_46, __v_47]; let __cu = unconstrained; if let Some(result) = record.function_queries[741].get_mut(&__args[..]) { if !__cu && *result.multiplicity == G::ZERO { aiur_fn_741(__args, record, io_buffer, false)? } else { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_741] = unsafe { *(result.output.as_ptr() as *const [G; OUT_741]) }; __ret } } else { aiur_fn_741(__args, record, io_buffer, __cu)? } }; - let __r_arr: [G; OUT_741] = { let __args: [G; IN_741] = [__v_2, __v_48, __v_49]; let __cu = unconstrained; if let Some(result) = record.function_queries[741].get_mut(&__args[..]) { if !__cu && *result.multiplicity == G::ZERO { aiur_fn_741(__args, record, io_buffer, false)? } else { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_741] = unsafe { *(result.output.as_ptr() as *const [G; OUT_741]) }; __ret } } else { aiur_fn_741(__args, record, io_buffer, __cu)? } }; - let __r_arr: [G; OUT_742] = { let __args: [G; IN_742] = [__v_3, __v_4, __v_5, __v_6, __v_7, __v_8, __v_9, __v_10, __v_50, __v_51, __v_52, __v_53, __v_54, __v_55, __v_56, __v_57, __v_58]; let __cu = unconstrained; if let Some(result) = record.function_queries[742].get_mut(&__args[..]) { if !__cu && *result.multiplicity == G::ZERO { aiur_fn_742(__args, record, io_buffer, false)? } else { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_742] = unsafe { *(result.output.as_ptr() as *const [G; OUT_742]) }; __ret } } else { aiur_fn_742(__args, record, io_buffer, __cu)? } }; - let __r_arr: [G; OUT_742] = { let __args: [G; IN_742] = [__v_11, __v_12, __v_13, __v_14, __v_15, __v_16, __v_17, __v_18, __v_59, __v_60, __v_61, __v_62, __v_63, __v_64, __v_65, __v_66, __v_67]; let __cu = unconstrained; if let Some(result) = record.function_queries[742].get_mut(&__args[..]) { if !__cu && *result.multiplicity == G::ZERO { aiur_fn_742(__args, record, io_buffer, false)? } else { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_742] = unsafe { *(result.output.as_ptr() as *const [G; OUT_742]) }; __ret } } else { aiur_fn_742(__args, record, io_buffer, __cu)? } }; - let __r_arr: [G; OUT_742] = { let __args: [G; IN_742] = [__v_19, __v_20, __v_21, __v_22, __v_23, __v_24, __v_25, __v_26, __v_68, __v_69, __v_70, __v_71, __v_72, __v_73, __v_74, __v_75, __v_76]; let __cu = unconstrained; if let Some(result) = record.function_queries[742].get_mut(&__args[..]) { if !__cu && *result.multiplicity == G::ZERO { aiur_fn_742(__args, record, io_buffer, false)? } else { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_742] = unsafe { *(result.output.as_ptr() as *const [G; OUT_742]) }; __ret } } else { aiur_fn_742(__args, record, io_buffer, __cu)? } }; - let __r_arr: [G; OUT_742] = { let __args: [G; IN_742] = [__v_27, __v_28, __v_29, __v_30, __v_31, __v_32, __v_33, __v_34, __v_77, __v_78, __v_79, __v_80, __v_81, __v_82, __v_83, __v_84, __v_85]; let __cu = unconstrained; if let Some(result) = record.function_queries[742].get_mut(&__args[..]) { if !__cu && *result.multiplicity == G::ZERO { aiur_fn_742(__args, record, io_buffer, false)? } else { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_742] = unsafe { *(result.output.as_ptr() as *const [G; OUT_742]) }; __ret } } else { aiur_fn_742(__args, record, io_buffer, __cu)? } }; - let __r_arr: [G; OUT_742] = { let __args: [G; IN_742] = [__v_35, __v_36, __v_37, __v_38, __v_39, __v_40, __v_41, __v_42, __v_86, __v_87, __v_88, __v_89, __v_90, __v_91, __v_92, __v_93, __v_94]; let __cu = unconstrained; if let Some(result) = record.function_queries[742].get_mut(&__args[..]) { if !__cu && *result.multiplicity == G::ZERO { aiur_fn_742(__args, record, io_buffer, false)? } else { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_742] = unsafe { *(result.output.as_ptr() as *const [G; OUT_742]) }; __ret } } else { aiur_fn_742(__args, record, io_buffer, __cu)? } }; - let __r_arr: [G; OUT_744] = { let __args: [G; IN_744] = [__v_43, __v_95, __v_96]; let __cu = unconstrained; if let Some(result) = record.function_queries[744].get_mut(&__args[..]) { if !__cu && *result.multiplicity == G::ZERO { aiur_fn_744(__args, record, io_buffer, false)? } else { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_744] = unsafe { *(result.output.as_ptr() as *const [G; OUT_744]) }; __ret } } else { aiur_fn_744(__args, record, io_buffer, __cu)? } }; - let __r_arr: [G; OUT_746] = { let __args: [G; IN_746] = [__v_44, __v_97, __v_98]; let __cu = unconstrained; if let Some(result) = record.function_queries[746].get_mut(&__args[..]) { if !__cu && *result.multiplicity == G::ZERO { aiur_fn_746(__args, record, io_buffer, false)? } else { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_746] = unsafe { *(result.output.as_ptr() as *const [G; OUT_746]) }; __ret } } else { aiur_fn_746(__args, record, io_buffer, __cu)? } }; - let __ret: [G; OUT_750] = []; - if let Some(result) = record.function_queries[750].get_mut(&inp[..]) { debug_assert_eq!(result.output, &__ret[..]); if !unconstrained { *result.multiplicity += G::ONE; } } else { record.function_queries[750].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained)); }; + let __r_arr: [G; OUT_737] = { let __args: [G; IN_737] = [__v_1, __v_46, __v_47]; let __cu = unconstrained; if let Some(result) = record.function_queries[737].get_mut(&__args[..]) { if !__cu && *result.multiplicity == G::ZERO { aiur_fn_737(__args, record, io_buffer, false)? } else { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_737] = unsafe { *(result.output.as_ptr() as *const [G; OUT_737]) }; __ret } } else { aiur_fn_737(__args, record, io_buffer, __cu)? } }; + let __r_arr: [G; OUT_737] = { let __args: [G; IN_737] = [__v_2, __v_48, __v_49]; let __cu = unconstrained; if let Some(result) = record.function_queries[737].get_mut(&__args[..]) { if !__cu && *result.multiplicity == G::ZERO { aiur_fn_737(__args, record, io_buffer, false)? } else { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_737] = unsafe { *(result.output.as_ptr() as *const [G; OUT_737]) }; __ret } } else { aiur_fn_737(__args, record, io_buffer, __cu)? } }; + let __r_arr: [G; OUT_738] = { let __args: [G; IN_738] = [__v_3, __v_4, __v_5, __v_6, __v_7, __v_8, __v_9, __v_10, __v_50, __v_51, __v_52, __v_53, __v_54, __v_55, __v_56, __v_57, __v_58]; let __cu = unconstrained; if let Some(result) = record.function_queries[738].get_mut(&__args[..]) { if !__cu && *result.multiplicity == G::ZERO { aiur_fn_738(__args, record, io_buffer, false)? } else { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_738] = unsafe { *(result.output.as_ptr() as *const [G; OUT_738]) }; __ret } } else { aiur_fn_738(__args, record, io_buffer, __cu)? } }; + let __r_arr: [G; OUT_738] = { let __args: [G; IN_738] = [__v_11, __v_12, __v_13, __v_14, __v_15, __v_16, __v_17, __v_18, __v_59, __v_60, __v_61, __v_62, __v_63, __v_64, __v_65, __v_66, __v_67]; let __cu = unconstrained; if let Some(result) = record.function_queries[738].get_mut(&__args[..]) { if !__cu && *result.multiplicity == G::ZERO { aiur_fn_738(__args, record, io_buffer, false)? } else { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_738] = unsafe { *(result.output.as_ptr() as *const [G; OUT_738]) }; __ret } } else { aiur_fn_738(__args, record, io_buffer, __cu)? } }; + let __r_arr: [G; OUT_738] = { let __args: [G; IN_738] = [__v_19, __v_20, __v_21, __v_22, __v_23, __v_24, __v_25, __v_26, __v_68, __v_69, __v_70, __v_71, __v_72, __v_73, __v_74, __v_75, __v_76]; let __cu = unconstrained; if let Some(result) = record.function_queries[738].get_mut(&__args[..]) { if !__cu && *result.multiplicity == G::ZERO { aiur_fn_738(__args, record, io_buffer, false)? } else { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_738] = unsafe { *(result.output.as_ptr() as *const [G; OUT_738]) }; __ret } } else { aiur_fn_738(__args, record, io_buffer, __cu)? } }; + let __r_arr: [G; OUT_738] = { let __args: [G; IN_738] = [__v_27, __v_28, __v_29, __v_30, __v_31, __v_32, __v_33, __v_34, __v_77, __v_78, __v_79, __v_80, __v_81, __v_82, __v_83, __v_84, __v_85]; let __cu = unconstrained; if let Some(result) = record.function_queries[738].get_mut(&__args[..]) { if !__cu && *result.multiplicity == G::ZERO { aiur_fn_738(__args, record, io_buffer, false)? } else { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_738] = unsafe { *(result.output.as_ptr() as *const [G; OUT_738]) }; __ret } } else { aiur_fn_738(__args, record, io_buffer, __cu)? } }; + let __r_arr: [G; OUT_738] = { let __args: [G; IN_738] = [__v_35, __v_36, __v_37, __v_38, __v_39, __v_40, __v_41, __v_42, __v_86, __v_87, __v_88, __v_89, __v_90, __v_91, __v_92, __v_93, __v_94]; let __cu = unconstrained; if let Some(result) = record.function_queries[738].get_mut(&__args[..]) { if !__cu && *result.multiplicity == G::ZERO { aiur_fn_738(__args, record, io_buffer, false)? } else { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_738] = unsafe { *(result.output.as_ptr() as *const [G; OUT_738]) }; __ret } } else { aiur_fn_738(__args, record, io_buffer, __cu)? } }; + let __r_arr: [G; OUT_740] = { let __args: [G; IN_740] = [__v_43, __v_95, __v_96]; let __cu = unconstrained; if let Some(result) = record.function_queries[740].get_mut(&__args[..]) { if !__cu && *result.multiplicity == G::ZERO { aiur_fn_740(__args, record, io_buffer, false)? } else { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_740] = unsafe { *(result.output.as_ptr() as *const [G; OUT_740]) }; __ret } } else { aiur_fn_740(__args, record, io_buffer, __cu)? } }; + let __r_arr: [G; OUT_742] = { let __args: [G; IN_742] = [__v_44, __v_97, __v_98]; let __cu = unconstrained; if let Some(result) = record.function_queries[742].get_mut(&__args[..]) { if !__cu && *result.multiplicity == G::ZERO { aiur_fn_742(__args, record, io_buffer, false)? } else { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_742] = unsafe { *(result.output.as_ptr() as *const [G; OUT_742]) }; __ret } } else { aiur_fn_742(__args, record, io_buffer, __cu)? } }; + let __ret: [G; OUT_746] = []; + if let Some(result) = record.function_queries[746].get_mut(&inp[..]) { debug_assert_eq!(result.output, &__ret[..]); if !unconstrained { *result.multiplicity += G::ONE; } } else { record.function_queries[746].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained)); }; return Ok(__ret); }, } @@ -63196,15 +62924,15 @@ fn aiur_fn_750( }) } -const INPUT_SIZE_751: usize = 2; -const IN_751: usize = 2; -const OUT_751: usize = 0; -fn aiur_fn_751( - inp: [G; IN_751], +const INPUT_SIZE_747: usize = 2; +const IN_747: usize = 2; +const OUT_747: usize = 0; +fn aiur_fn_747( + inp: [G; IN_747], record: &mut QueryRecord, io_buffer: &mut IOBuffer, unconstrained: bool, -) -> Result<[G; OUT_751], ExecError> { +) -> Result<[G; OUT_747], ExecError> { stacker::maybe_grow(64 * 1024, 4 * 1024 * 1024, || { let __v_0: G = inp[0]; let __v_1: G = inp[1]; @@ -63275,12 +63003,12 @@ fn aiur_fn_751( let __v_65: G = __loaded[63]; match __v_2.as_canonical_u64() { 1u64 => { - let __ret: [G; OUT_751] = []; - if let Some(result) = record.function_queries[751].get_mut(&inp[..]) { debug_assert_eq!(result.output, &__ret[..]); if !unconstrained { *result.multiplicity += G::ONE; } } else { record.function_queries[751].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained)); }; + let __ret: [G; OUT_747] = []; + if let Some(result) = record.function_queries[747].get_mut(&inp[..]) { debug_assert_eq!(result.output, &__ret[..]); if !unconstrained { *result.multiplicity += G::ONE; } } else { record.function_queries[747].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained)); }; return Ok(__ret); }, 0u64 => { - let __r_arr: [G; OUT_768] = { let __args: [G; IN_768] = [__v_0, __v_3, __v_4, __v_5, __v_6, __v_7, __v_8, __v_9, __v_10]; let __cu = unconstrained; if let Some(result) = record.function_queries[768].get_mut(&__args[..]) { if !__cu && *result.multiplicity == G::ZERO { aiur_fn_768(__args, record, io_buffer, false)? } else { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_768] = unsafe { *(result.output.as_ptr() as *const [G; OUT_768]) }; __ret } } else { aiur_fn_768(__args, record, io_buffer, __cu)? } }; + let __r_arr: [G; OUT_764] = { let __args: [G; IN_764] = [__v_0, __v_3, __v_4, __v_5, __v_6, __v_7, __v_8, __v_9, __v_10]; let __cu = unconstrained; if let Some(result) = record.function_queries[764].get_mut(&__args[..]) { if !__cu && *result.multiplicity == G::ZERO { aiur_fn_764(__args, record, io_buffer, false)? } else { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_764] = unsafe { *(result.output.as_ptr() as *const [G; OUT_764]) }; __ret } } else { aiur_fn_764(__args, record, io_buffer, __cu)? } }; let __v_66: G = __r_arr[0]; let __v_67: G = __r_arr[1]; let __v_68: G = __r_arr[2]; @@ -63326,10 +63054,10 @@ fn aiur_fn_751( let __v_108: G = __r_arr[42]; let __v_109: G = __r_arr[43]; let __v_110: G = __r_arr[44]; - let __r_arr: [G; OUT_750] = { let __args: [G; IN_750] = [__v_66, __v_67, __v_68, __v_69, __v_70, __v_71, __v_72, __v_73, __v_74, __v_75, __v_76, __v_77, __v_78, __v_79, __v_80, __v_81, __v_82, __v_83, __v_84, __v_85, __v_86, __v_87, __v_88, __v_89, __v_90, __v_91, __v_92, __v_93, __v_94, __v_95, __v_96, __v_97, __v_98, __v_99, __v_100, __v_101, __v_102, __v_103, __v_104, __v_105, __v_106, __v_107, __v_108, __v_109, __v_110, __v_11, __v_12, __v_13, __v_14, __v_15, __v_16, __v_17, __v_18, __v_19, __v_20, __v_21, __v_22, __v_23, __v_24, __v_25, __v_26, __v_27, __v_28, __v_29, __v_30, __v_31, __v_32, __v_33, __v_34, __v_35, __v_36, __v_37, __v_38, __v_39, __v_40, __v_41, __v_42, __v_43, __v_44, __v_45, __v_46, __v_47, __v_48, __v_49, __v_50, __v_51, __v_52, __v_53, __v_54, __v_55, __v_56, __v_57, __v_58, __v_59, __v_60, __v_61, __v_62, __v_63, __v_64]; let __cu = unconstrained; if let Some(result) = record.function_queries[750].get_mut(&__args[..]) { if !__cu && *result.multiplicity == G::ZERO { aiur_fn_750(__args, record, io_buffer, false)? } else { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_750] = unsafe { *(result.output.as_ptr() as *const [G; OUT_750]) }; __ret } } else { aiur_fn_750(__args, record, io_buffer, __cu)? } }; - let __r_arr: [G; OUT_751] = { let __args: [G; IN_751] = [__v_0, __v_65]; let __cu = unconstrained; if let Some(result) = record.function_queries[751].get_mut(&__args[..]) { if !__cu && *result.multiplicity == G::ZERO { aiur_fn_751(__args, record, io_buffer, false)? } else { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_751] = unsafe { *(result.output.as_ptr() as *const [G; OUT_751]) }; __ret } } else { aiur_fn_751(__args, record, io_buffer, __cu)? } }; - let __ret: [G; OUT_751] = []; - if let Some(result) = record.function_queries[751].get_mut(&inp[..]) { debug_assert_eq!(result.output, &__ret[..]); if !unconstrained { *result.multiplicity += G::ONE; } } else { record.function_queries[751].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained)); }; + let __r_arr: [G; OUT_746] = { let __args: [G; IN_746] = [__v_66, __v_67, __v_68, __v_69, __v_70, __v_71, __v_72, __v_73, __v_74, __v_75, __v_76, __v_77, __v_78, __v_79, __v_80, __v_81, __v_82, __v_83, __v_84, __v_85, __v_86, __v_87, __v_88, __v_89, __v_90, __v_91, __v_92, __v_93, __v_94, __v_95, __v_96, __v_97, __v_98, __v_99, __v_100, __v_101, __v_102, __v_103, __v_104, __v_105, __v_106, __v_107, __v_108, __v_109, __v_110, __v_11, __v_12, __v_13, __v_14, __v_15, __v_16, __v_17, __v_18, __v_19, __v_20, __v_21, __v_22, __v_23, __v_24, __v_25, __v_26, __v_27, __v_28, __v_29, __v_30, __v_31, __v_32, __v_33, __v_34, __v_35, __v_36, __v_37, __v_38, __v_39, __v_40, __v_41, __v_42, __v_43, __v_44, __v_45, __v_46, __v_47, __v_48, __v_49, __v_50, __v_51, __v_52, __v_53, __v_54, __v_55, __v_56, __v_57, __v_58, __v_59, __v_60, __v_61, __v_62, __v_63, __v_64]; let __cu = unconstrained; if let Some(result) = record.function_queries[746].get_mut(&__args[..]) { if !__cu && *result.multiplicity == G::ZERO { aiur_fn_746(__args, record, io_buffer, false)? } else { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_746] = unsafe { *(result.output.as_ptr() as *const [G; OUT_746]) }; __ret } } else { aiur_fn_746(__args, record, io_buffer, __cu)? } }; + let __r_arr: [G; OUT_747] = { let __args: [G; IN_747] = [__v_0, __v_65]; let __cu = unconstrained; if let Some(result) = record.function_queries[747].get_mut(&__args[..]) { if !__cu && *result.multiplicity == G::ZERO { aiur_fn_747(__args, record, io_buffer, false)? } else { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_747] = unsafe { *(result.output.as_ptr() as *const [G; OUT_747]) }; __ret } } else { aiur_fn_747(__args, record, io_buffer, __cu)? } }; + let __ret: [G; OUT_747] = []; + if let Some(result) = record.function_queries[747].get_mut(&inp[..]) { debug_assert_eq!(result.output, &__ret[..]); if !unconstrained { *result.multiplicity += G::ONE; } } else { record.function_queries[747].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained)); }; return Ok(__ret); }, _ => { @@ -63339,15 +63067,15 @@ fn aiur_fn_751( }) } -const INPUT_SIZE_752: usize = 55; -const IN_752: usize = 55; -const OUT_752: usize = 0; -fn aiur_fn_752( - inp: [G; IN_752], +const INPUT_SIZE_748: usize = 55; +const IN_748: usize = 55; +const OUT_748: usize = 0; +fn aiur_fn_748( + inp: [G; IN_748], record: &mut QueryRecord, io_buffer: &mut IOBuffer, unconstrained: bool, -) -> Result<[G; OUT_752], ExecError> { +) -> Result<[G; OUT_748], ExecError> { stacker::maybe_grow(64 * 1024, 4 * 1024 * 1024, || { let __v_0: G = inp[0]; let __v_1: G = inp[1]; @@ -63404,7 +63132,7 @@ fn aiur_fn_752( let __v_52: G = inp[52]; let __v_53: G = inp[53]; let __v_54: G = inp[54]; - let __r_arr: [G; OUT_282] = { let __args: [G; IN_282] = [__v_0]; let __cu = unconstrained; if let Some(result) = record.function_queries[282].get_mut(&__args[..]) { if !__cu && *result.multiplicity == G::ZERO { aiur_fn_282(__args, record, io_buffer, false)? } else { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_282] = unsafe { *(result.output.as_ptr() as *const [G; OUT_282]) }; __ret } } else { aiur_fn_282(__args, record, io_buffer, __cu)? } }; + let __r_arr: [G; OUT_278] = { let __args: [G; IN_278] = [__v_0]; let __cu = unconstrained; if let Some(result) = record.function_queries[278].get_mut(&__args[..]) { if !__cu && *result.multiplicity == G::ZERO { aiur_fn_278(__args, record, io_buffer, false)? } else { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_278] = unsafe { *(result.output.as_ptr() as *const [G; OUT_278]) }; __ret } } else { aiur_fn_278(__args, record, io_buffer, __cu)? } }; let __v_55: G = __r_arr[0]; let __v_56: G = __r_arr[1]; let __v_57: G = __r_arr[2]; @@ -63461,13 +63189,13 @@ fn aiur_fn_752( 0u64 => { match __v_56.as_canonical_u64() { _ => { - let __r_arr: [G; OUT_738] = { let __args: [G; IN_738] = [__v_56, __v_2, __v_3]; let __cu = unconstrained; if let Some(result) = record.function_queries[738].get_mut(&__args[..]) { if !__cu && *result.multiplicity == G::ZERO { aiur_fn_738(__args, record, io_buffer, false)? } else { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_738] = unsafe { *(result.output.as_ptr() as *const [G; OUT_738]) }; __ret } } else { aiur_fn_738(__args, record, io_buffer, __cu)? } }; - let __r_arr: [G; OUT_739] = { let __args: [G; IN_739] = [__v_57, __v_4, __v_5]; let __cu = unconstrained; if let Some(result) = record.function_queries[739].get_mut(&__args[..]) { if !__cu && *result.multiplicity == G::ZERO { aiur_fn_739(__args, record, io_buffer, false)? } else { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_739] = unsafe { *(result.output.as_ptr() as *const [G; OUT_739]) }; __ret } } else { aiur_fn_739(__args, record, io_buffer, __cu)? } }; - let __r_arr: [G; OUT_742] = { let __args: [G; IN_742] = [__v_58, __v_59, __v_60, __v_61, __v_62, __v_63, __v_64, __v_65, __v_6, __v_7, __v_8, __v_9, __v_10, __v_11, __v_12, __v_13, __v_14]; let __cu = unconstrained; if let Some(result) = record.function_queries[742].get_mut(&__args[..]) { if !__cu && *result.multiplicity == G::ZERO { aiur_fn_742(__args, record, io_buffer, false)? } else { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_742] = unsafe { *(result.output.as_ptr() as *const [G; OUT_742]) }; __ret } } else { aiur_fn_742(__args, record, io_buffer, __cu)? } }; - let __r_arr: [G; OUT_744] = { let __args: [G; IN_744] = [__v_66, __v_15, __v_16]; let __cu = unconstrained; if let Some(result) = record.function_queries[744].get_mut(&__args[..]) { if !__cu && *result.multiplicity == G::ZERO { aiur_fn_744(__args, record, io_buffer, false)? } else { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_744] = unsafe { *(result.output.as_ptr() as *const [G; OUT_744]) }; __ret } } else { aiur_fn_744(__args, record, io_buffer, __cu)? } }; - let __r_arr: [G; OUT_744] = { let __args: [G; IN_744] = [__v_67, __v_17, __v_18]; let __cu = unconstrained; if let Some(result) = record.function_queries[744].get_mut(&__args[..]) { if !__cu && *result.multiplicity == G::ZERO { aiur_fn_744(__args, record, io_buffer, false)? } else { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_744] = unsafe { *(result.output.as_ptr() as *const [G; OUT_744]) }; __ret } } else { aiur_fn_744(__args, record, io_buffer, __cu)? } }; - let __ret: [G; OUT_752] = []; - if let Some(result) = record.function_queries[752].get_mut(&inp[..]) { debug_assert_eq!(result.output, &__ret[..]); if !unconstrained { *result.multiplicity += G::ONE; } } else { record.function_queries[752].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained)); }; + let __r_arr: [G; OUT_734] = { let __args: [G; IN_734] = [__v_56, __v_2, __v_3]; let __cu = unconstrained; if let Some(result) = record.function_queries[734].get_mut(&__args[..]) { if !__cu && *result.multiplicity == G::ZERO { aiur_fn_734(__args, record, io_buffer, false)? } else { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_734] = unsafe { *(result.output.as_ptr() as *const [G; OUT_734]) }; __ret } } else { aiur_fn_734(__args, record, io_buffer, __cu)? } }; + let __r_arr: [G; OUT_735] = { let __args: [G; IN_735] = [__v_57, __v_4, __v_5]; let __cu = unconstrained; if let Some(result) = record.function_queries[735].get_mut(&__args[..]) { if !__cu && *result.multiplicity == G::ZERO { aiur_fn_735(__args, record, io_buffer, false)? } else { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_735] = unsafe { *(result.output.as_ptr() as *const [G; OUT_735]) }; __ret } } else { aiur_fn_735(__args, record, io_buffer, __cu)? } }; + let __r_arr: [G; OUT_738] = { let __args: [G; IN_738] = [__v_58, __v_59, __v_60, __v_61, __v_62, __v_63, __v_64, __v_65, __v_6, __v_7, __v_8, __v_9, __v_10, __v_11, __v_12, __v_13, __v_14]; let __cu = unconstrained; if let Some(result) = record.function_queries[738].get_mut(&__args[..]) { if !__cu && *result.multiplicity == G::ZERO { aiur_fn_738(__args, record, io_buffer, false)? } else { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_738] = unsafe { *(result.output.as_ptr() as *const [G; OUT_738]) }; __ret } } else { aiur_fn_738(__args, record, io_buffer, __cu)? } }; + let __r_arr: [G; OUT_740] = { let __args: [G; IN_740] = [__v_66, __v_15, __v_16]; let __cu = unconstrained; if let Some(result) = record.function_queries[740].get_mut(&__args[..]) { if !__cu && *result.multiplicity == G::ZERO { aiur_fn_740(__args, record, io_buffer, false)? } else { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_740] = unsafe { *(result.output.as_ptr() as *const [G; OUT_740]) }; __ret } } else { aiur_fn_740(__args, record, io_buffer, __cu)? } }; + let __r_arr: [G; OUT_740] = { let __args: [G; IN_740] = [__v_67, __v_17, __v_18]; let __cu = unconstrained; if let Some(result) = record.function_queries[740].get_mut(&__args[..]) { if !__cu && *result.multiplicity == G::ZERO { aiur_fn_740(__args, record, io_buffer, false)? } else { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_740] = unsafe { *(result.output.as_ptr() as *const [G; OUT_740]) }; __ret } } else { aiur_fn_740(__args, record, io_buffer, __cu)? } }; + let __ret: [G; OUT_748] = []; + if let Some(result) = record.function_queries[748].get_mut(&inp[..]) { debug_assert_eq!(result.output, &__ret[..]); if !unconstrained { *result.multiplicity += G::ONE; } } else { record.function_queries[748].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained)); }; return Ok(__ret); }, } @@ -63482,17 +63210,17 @@ fn aiur_fn_752( 1u64 => { match __v_56.as_canonical_u64() { _ => { - let __r_arr: [G; OUT_741] = { let __args: [G; IN_741] = [__v_56, __v_2, __v_3]; let __cu = unconstrained; if let Some(result) = record.function_queries[741].get_mut(&__args[..]) { if !__cu && *result.multiplicity == G::ZERO { aiur_fn_741(__args, record, io_buffer, false)? } else { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_741] = unsafe { *(result.output.as_ptr() as *const [G; OUT_741]) }; __ret } } else { aiur_fn_741(__args, record, io_buffer, __cu)? } }; - let __r_arr: [G; OUT_741] = { let __args: [G; IN_741] = [__v_57, __v_4, __v_5]; let __cu = unconstrained; if let Some(result) = record.function_queries[741].get_mut(&__args[..]) { if !__cu && *result.multiplicity == G::ZERO { aiur_fn_741(__args, record, io_buffer, false)? } else { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_741] = unsafe { *(result.output.as_ptr() as *const [G; OUT_741]) }; __ret } } else { aiur_fn_741(__args, record, io_buffer, __cu)? } }; - let __r_arr: [G; OUT_742] = { let __args: [G; IN_742] = [__v_58, __v_59, __v_60, __v_61, __v_62, __v_63, __v_64, __v_65, __v_6, __v_7, __v_8, __v_9, __v_10, __v_11, __v_12, __v_13, __v_14]; let __cu = unconstrained; if let Some(result) = record.function_queries[742].get_mut(&__args[..]) { if !__cu && *result.multiplicity == G::ZERO { aiur_fn_742(__args, record, io_buffer, false)? } else { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_742] = unsafe { *(result.output.as_ptr() as *const [G; OUT_742]) }; __ret } } else { aiur_fn_742(__args, record, io_buffer, __cu)? } }; - let __r_arr: [G; OUT_742] = { let __args: [G; IN_742] = [__v_66, __v_67, __v_68, __v_69, __v_70, __v_71, __v_72, __v_73, __v_15, __v_16, __v_17, __v_18, __v_19, __v_20, __v_21, __v_22, __v_23]; let __cu = unconstrained; if let Some(result) = record.function_queries[742].get_mut(&__args[..]) { if !__cu && *result.multiplicity == G::ZERO { aiur_fn_742(__args, record, io_buffer, false)? } else { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_742] = unsafe { *(result.output.as_ptr() as *const [G; OUT_742]) }; __ret } } else { aiur_fn_742(__args, record, io_buffer, __cu)? } }; - let __r_arr: [G; OUT_742] = { let __args: [G; IN_742] = [__v_74, __v_75, __v_76, __v_77, __v_78, __v_79, __v_80, __v_81, __v_24, __v_25, __v_26, __v_27, __v_28, __v_29, __v_30, __v_31, __v_32]; let __cu = unconstrained; if let Some(result) = record.function_queries[742].get_mut(&__args[..]) { if !__cu && *result.multiplicity == G::ZERO { aiur_fn_742(__args, record, io_buffer, false)? } else { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_742] = unsafe { *(result.output.as_ptr() as *const [G; OUT_742]) }; __ret } } else { aiur_fn_742(__args, record, io_buffer, __cu)? } }; - let __r_arr: [G; OUT_742] = { let __args: [G; IN_742] = [__v_82, __v_83, __v_84, __v_85, __v_86, __v_87, __v_88, __v_89, __v_33, __v_34, __v_35, __v_36, __v_37, __v_38, __v_39, __v_40, __v_41]; let __cu = unconstrained; if let Some(result) = record.function_queries[742].get_mut(&__args[..]) { if !__cu && *result.multiplicity == G::ZERO { aiur_fn_742(__args, record, io_buffer, false)? } else { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_742] = unsafe { *(result.output.as_ptr() as *const [G; OUT_742]) }; __ret } } else { aiur_fn_742(__args, record, io_buffer, __cu)? } }; - let __r_arr: [G; OUT_742] = { let __args: [G; IN_742] = [__v_90, __v_91, __v_92, __v_93, __v_94, __v_95, __v_96, __v_97, __v_42, __v_43, __v_44, __v_45, __v_46, __v_47, __v_48, __v_49, __v_50]; let __cu = unconstrained; if let Some(result) = record.function_queries[742].get_mut(&__args[..]) { if !__cu && *result.multiplicity == G::ZERO { aiur_fn_742(__args, record, io_buffer, false)? } else { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_742] = unsafe { *(result.output.as_ptr() as *const [G; OUT_742]) }; __ret } } else { aiur_fn_742(__args, record, io_buffer, __cu)? } }; - let __r_arr: [G; OUT_744] = { let __args: [G; IN_744] = [__v_98, __v_51, __v_52]; let __cu = unconstrained; if let Some(result) = record.function_queries[744].get_mut(&__args[..]) { if !__cu && *result.multiplicity == G::ZERO { aiur_fn_744(__args, record, io_buffer, false)? } else { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_744] = unsafe { *(result.output.as_ptr() as *const [G; OUT_744]) }; __ret } } else { aiur_fn_744(__args, record, io_buffer, __cu)? } }; - let __r_arr: [G; OUT_746] = { let __args: [G; IN_746] = [__v_99, __v_53, __v_54]; let __cu = unconstrained; if let Some(result) = record.function_queries[746].get_mut(&__args[..]) { if !__cu && *result.multiplicity == G::ZERO { aiur_fn_746(__args, record, io_buffer, false)? } else { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_746] = unsafe { *(result.output.as_ptr() as *const [G; OUT_746]) }; __ret } } else { aiur_fn_746(__args, record, io_buffer, __cu)? } }; - let __ret: [G; OUT_752] = []; - if let Some(result) = record.function_queries[752].get_mut(&inp[..]) { debug_assert_eq!(result.output, &__ret[..]); if !unconstrained { *result.multiplicity += G::ONE; } } else { record.function_queries[752].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained)); }; + let __r_arr: [G; OUT_737] = { let __args: [G; IN_737] = [__v_56, __v_2, __v_3]; let __cu = unconstrained; if let Some(result) = record.function_queries[737].get_mut(&__args[..]) { if !__cu && *result.multiplicity == G::ZERO { aiur_fn_737(__args, record, io_buffer, false)? } else { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_737] = unsafe { *(result.output.as_ptr() as *const [G; OUT_737]) }; __ret } } else { aiur_fn_737(__args, record, io_buffer, __cu)? } }; + let __r_arr: [G; OUT_737] = { let __args: [G; IN_737] = [__v_57, __v_4, __v_5]; let __cu = unconstrained; if let Some(result) = record.function_queries[737].get_mut(&__args[..]) { if !__cu && *result.multiplicity == G::ZERO { aiur_fn_737(__args, record, io_buffer, false)? } else { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_737] = unsafe { *(result.output.as_ptr() as *const [G; OUT_737]) }; __ret } } else { aiur_fn_737(__args, record, io_buffer, __cu)? } }; + let __r_arr: [G; OUT_738] = { let __args: [G; IN_738] = [__v_58, __v_59, __v_60, __v_61, __v_62, __v_63, __v_64, __v_65, __v_6, __v_7, __v_8, __v_9, __v_10, __v_11, __v_12, __v_13, __v_14]; let __cu = unconstrained; if let Some(result) = record.function_queries[738].get_mut(&__args[..]) { if !__cu && *result.multiplicity == G::ZERO { aiur_fn_738(__args, record, io_buffer, false)? } else { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_738] = unsafe { *(result.output.as_ptr() as *const [G; OUT_738]) }; __ret } } else { aiur_fn_738(__args, record, io_buffer, __cu)? } }; + let __r_arr: [G; OUT_738] = { let __args: [G; IN_738] = [__v_66, __v_67, __v_68, __v_69, __v_70, __v_71, __v_72, __v_73, __v_15, __v_16, __v_17, __v_18, __v_19, __v_20, __v_21, __v_22, __v_23]; let __cu = unconstrained; if let Some(result) = record.function_queries[738].get_mut(&__args[..]) { if !__cu && *result.multiplicity == G::ZERO { aiur_fn_738(__args, record, io_buffer, false)? } else { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_738] = unsafe { *(result.output.as_ptr() as *const [G; OUT_738]) }; __ret } } else { aiur_fn_738(__args, record, io_buffer, __cu)? } }; + let __r_arr: [G; OUT_738] = { let __args: [G; IN_738] = [__v_74, __v_75, __v_76, __v_77, __v_78, __v_79, __v_80, __v_81, __v_24, __v_25, __v_26, __v_27, __v_28, __v_29, __v_30, __v_31, __v_32]; let __cu = unconstrained; if let Some(result) = record.function_queries[738].get_mut(&__args[..]) { if !__cu && *result.multiplicity == G::ZERO { aiur_fn_738(__args, record, io_buffer, false)? } else { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_738] = unsafe { *(result.output.as_ptr() as *const [G; OUT_738]) }; __ret } } else { aiur_fn_738(__args, record, io_buffer, __cu)? } }; + let __r_arr: [G; OUT_738] = { let __args: [G; IN_738] = [__v_82, __v_83, __v_84, __v_85, __v_86, __v_87, __v_88, __v_89, __v_33, __v_34, __v_35, __v_36, __v_37, __v_38, __v_39, __v_40, __v_41]; let __cu = unconstrained; if let Some(result) = record.function_queries[738].get_mut(&__args[..]) { if !__cu && *result.multiplicity == G::ZERO { aiur_fn_738(__args, record, io_buffer, false)? } else { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_738] = unsafe { *(result.output.as_ptr() as *const [G; OUT_738]) }; __ret } } else { aiur_fn_738(__args, record, io_buffer, __cu)? } }; + let __r_arr: [G; OUT_738] = { let __args: [G; IN_738] = [__v_90, __v_91, __v_92, __v_93, __v_94, __v_95, __v_96, __v_97, __v_42, __v_43, __v_44, __v_45, __v_46, __v_47, __v_48, __v_49, __v_50]; let __cu = unconstrained; if let Some(result) = record.function_queries[738].get_mut(&__args[..]) { if !__cu && *result.multiplicity == G::ZERO { aiur_fn_738(__args, record, io_buffer, false)? } else { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_738] = unsafe { *(result.output.as_ptr() as *const [G; OUT_738]) }; __ret } } else { aiur_fn_738(__args, record, io_buffer, __cu)? } }; + let __r_arr: [G; OUT_740] = { let __args: [G; IN_740] = [__v_98, __v_51, __v_52]; let __cu = unconstrained; if let Some(result) = record.function_queries[740].get_mut(&__args[..]) { if !__cu && *result.multiplicity == G::ZERO { aiur_fn_740(__args, record, io_buffer, false)? } else { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_740] = unsafe { *(result.output.as_ptr() as *const [G; OUT_740]) }; __ret } } else { aiur_fn_740(__args, record, io_buffer, __cu)? } }; + let __r_arr: [G; OUT_742] = { let __args: [G; IN_742] = [__v_99, __v_53, __v_54]; let __cu = unconstrained; if let Some(result) = record.function_queries[742].get_mut(&__args[..]) { if !__cu && *result.multiplicity == G::ZERO { aiur_fn_742(__args, record, io_buffer, false)? } else { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_742] = unsafe { *(result.output.as_ptr() as *const [G; OUT_742]) }; __ret } } else { aiur_fn_742(__args, record, io_buffer, __cu)? } }; + let __ret: [G; OUT_748] = []; + if let Some(result) = record.function_queries[748].get_mut(&inp[..]) { debug_assert_eq!(result.output, &__ret[..]); if !unconstrained { *result.multiplicity += G::ONE; } } else { record.function_queries[748].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained)); }; return Ok(__ret); }, } @@ -63507,11 +63235,11 @@ fn aiur_fn_752( 2u64 => { match __v_56.as_canonical_u64() { _ => { - let __r_arr: [G; OUT_741] = { let __args: [G; IN_741] = [__v_56, __v_2, __v_3]; let __cu = unconstrained; if let Some(result) = record.function_queries[741].get_mut(&__args[..]) { if !__cu && *result.multiplicity == G::ZERO { aiur_fn_741(__args, record, io_buffer, false)? } else { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_741] = unsafe { *(result.output.as_ptr() as *const [G; OUT_741]) }; __ret } } else { aiur_fn_741(__args, record, io_buffer, __cu)? } }; - let __r_arr: [G; OUT_742] = { let __args: [G; IN_742] = [__v_57, __v_58, __v_59, __v_60, __v_61, __v_62, __v_63, __v_64, __v_4, __v_5, __v_6, __v_7, __v_8, __v_9, __v_10, __v_11, __v_12]; let __cu = unconstrained; if let Some(result) = record.function_queries[742].get_mut(&__args[..]) { if !__cu && *result.multiplicity == G::ZERO { aiur_fn_742(__args, record, io_buffer, false)? } else { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_742] = unsafe { *(result.output.as_ptr() as *const [G; OUT_742]) }; __ret } } else { aiur_fn_742(__args, record, io_buffer, __cu)? } }; - let __r_arr: [G; OUT_744] = { let __args: [G; IN_744] = [__v_65, __v_13, __v_14]; let __cu = unconstrained; if let Some(result) = record.function_queries[744].get_mut(&__args[..]) { if !__cu && *result.multiplicity == G::ZERO { aiur_fn_744(__args, record, io_buffer, false)? } else { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_744] = unsafe { *(result.output.as_ptr() as *const [G; OUT_744]) }; __ret } } else { aiur_fn_744(__args, record, io_buffer, __cu)? } }; - let __ret: [G; OUT_752] = []; - if let Some(result) = record.function_queries[752].get_mut(&inp[..]) { debug_assert_eq!(result.output, &__ret[..]); if !unconstrained { *result.multiplicity += G::ONE; } } else { record.function_queries[752].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained)); }; + let __r_arr: [G; OUT_737] = { let __args: [G; IN_737] = [__v_56, __v_2, __v_3]; let __cu = unconstrained; if let Some(result) = record.function_queries[737].get_mut(&__args[..]) { if !__cu && *result.multiplicity == G::ZERO { aiur_fn_737(__args, record, io_buffer, false)? } else { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_737] = unsafe { *(result.output.as_ptr() as *const [G; OUT_737]) }; __ret } } else { aiur_fn_737(__args, record, io_buffer, __cu)? } }; + let __r_arr: [G; OUT_738] = { let __args: [G; IN_738] = [__v_57, __v_58, __v_59, __v_60, __v_61, __v_62, __v_63, __v_64, __v_4, __v_5, __v_6, __v_7, __v_8, __v_9, __v_10, __v_11, __v_12]; let __cu = unconstrained; if let Some(result) = record.function_queries[738].get_mut(&__args[..]) { if !__cu && *result.multiplicity == G::ZERO { aiur_fn_738(__args, record, io_buffer, false)? } else { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_738] = unsafe { *(result.output.as_ptr() as *const [G; OUT_738]) }; __ret } } else { aiur_fn_738(__args, record, io_buffer, __cu)? } }; + let __r_arr: [G; OUT_740] = { let __args: [G; IN_740] = [__v_65, __v_13, __v_14]; let __cu = unconstrained; if let Some(result) = record.function_queries[740].get_mut(&__args[..]) { if !__cu && *result.multiplicity == G::ZERO { aiur_fn_740(__args, record, io_buffer, false)? } else { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_740] = unsafe { *(result.output.as_ptr() as *const [G; OUT_740]) }; __ret } } else { aiur_fn_740(__args, record, io_buffer, __cu)? } }; + let __ret: [G; OUT_748] = []; + if let Some(result) = record.function_queries[748].get_mut(&inp[..]) { debug_assert_eq!(result.output, &__ret[..]); if !unconstrained { *result.multiplicity += G::ONE; } } else { record.function_queries[748].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained)); }; return Ok(__ret); }, } @@ -63526,11 +63254,11 @@ fn aiur_fn_752( 3u64 => { match __v_56.as_canonical_u64() { _ => { - let __r_arr: [G; OUT_740] = { let __args: [G; IN_740] = [__v_56, __v_2, __v_3]; let __cu = unconstrained; if let Some(result) = record.function_queries[740].get_mut(&__args[..]) { if !__cu && *result.multiplicity == G::ZERO { aiur_fn_740(__args, record, io_buffer, false)? } else { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_740] = unsafe { *(result.output.as_ptr() as *const [G; OUT_740]) }; __ret } } else { aiur_fn_740(__args, record, io_buffer, __cu)? } }; - let __r_arr: [G; OUT_742] = { let __args: [G; IN_742] = [__v_57, __v_58, __v_59, __v_60, __v_61, __v_62, __v_63, __v_64, __v_4, __v_5, __v_6, __v_7, __v_8, __v_9, __v_10, __v_11, __v_12]; let __cu = unconstrained; if let Some(result) = record.function_queries[742].get_mut(&__args[..]) { if !__cu && *result.multiplicity == G::ZERO { aiur_fn_742(__args, record, io_buffer, false)? } else { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_742] = unsafe { *(result.output.as_ptr() as *const [G; OUT_742]) }; __ret } } else { aiur_fn_742(__args, record, io_buffer, __cu)? } }; - let __r_arr: [G; OUT_744] = { let __args: [G; IN_744] = [__v_65, __v_13, __v_14]; let __cu = unconstrained; if let Some(result) = record.function_queries[744].get_mut(&__args[..]) { if !__cu && *result.multiplicity == G::ZERO { aiur_fn_744(__args, record, io_buffer, false)? } else { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_744] = unsafe { *(result.output.as_ptr() as *const [G; OUT_744]) }; __ret } } else { aiur_fn_744(__args, record, io_buffer, __cu)? } }; - let __ret: [G; OUT_752] = []; - if let Some(result) = record.function_queries[752].get_mut(&inp[..]) { debug_assert_eq!(result.output, &__ret[..]); if !unconstrained { *result.multiplicity += G::ONE; } } else { record.function_queries[752].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained)); }; + let __r_arr: [G; OUT_736] = { let __args: [G; IN_736] = [__v_56, __v_2, __v_3]; let __cu = unconstrained; if let Some(result) = record.function_queries[736].get_mut(&__args[..]) { if !__cu && *result.multiplicity == G::ZERO { aiur_fn_736(__args, record, io_buffer, false)? } else { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_736] = unsafe { *(result.output.as_ptr() as *const [G; OUT_736]) }; __ret } } else { aiur_fn_736(__args, record, io_buffer, __cu)? } }; + let __r_arr: [G; OUT_738] = { let __args: [G; IN_738] = [__v_57, __v_58, __v_59, __v_60, __v_61, __v_62, __v_63, __v_64, __v_4, __v_5, __v_6, __v_7, __v_8, __v_9, __v_10, __v_11, __v_12]; let __cu = unconstrained; if let Some(result) = record.function_queries[738].get_mut(&__args[..]) { if !__cu && *result.multiplicity == G::ZERO { aiur_fn_738(__args, record, io_buffer, false)? } else { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_738] = unsafe { *(result.output.as_ptr() as *const [G; OUT_738]) }; __ret } } else { aiur_fn_738(__args, record, io_buffer, __cu)? } }; + let __r_arr: [G; OUT_740] = { let __args: [G; IN_740] = [__v_65, __v_13, __v_14]; let __cu = unconstrained; if let Some(result) = record.function_queries[740].get_mut(&__args[..]) { if !__cu && *result.multiplicity == G::ZERO { aiur_fn_740(__args, record, io_buffer, false)? } else { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_740] = unsafe { *(result.output.as_ptr() as *const [G; OUT_740]) }; __ret } } else { aiur_fn_740(__args, record, io_buffer, __cu)? } }; + let __ret: [G; OUT_748] = []; + if let Some(result) = record.function_queries[748].get_mut(&inp[..]) { debug_assert_eq!(result.output, &__ret[..]); if !unconstrained { *result.multiplicity += G::ONE; } } else { record.function_queries[748].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained)); }; return Ok(__ret); }, } @@ -63545,11 +63273,11 @@ fn aiur_fn_752( 4u64 => { match __v_56.as_canonical_u64() { _ => { - let __r_arr: [G; OUT_742] = { let __args: [G; IN_742] = [__v_56, __v_57, __v_58, __v_59, __v_60, __v_61, __v_62, __v_63, __v_2, __v_3, __v_4, __v_5, __v_6, __v_7, __v_8, __v_9, __v_10]; let __cu = unconstrained; if let Some(result) = record.function_queries[742].get_mut(&__args[..]) { if !__cu && *result.multiplicity == G::ZERO { aiur_fn_742(__args, record, io_buffer, false)? } else { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_742] = unsafe { *(result.output.as_ptr() as *const [G; OUT_742]) }; __ret } } else { aiur_fn_742(__args, record, io_buffer, __cu)? } }; - let __r_arr: [G; OUT_742] = { let __args: [G; IN_742] = [__v_64, __v_65, __v_66, __v_67, __v_68, __v_69, __v_70, __v_71, __v_11, __v_12, __v_13, __v_14, __v_15, __v_16, __v_17, __v_18, __v_19]; let __cu = unconstrained; if let Some(result) = record.function_queries[742].get_mut(&__args[..]) { if !__cu && *result.multiplicity == G::ZERO { aiur_fn_742(__args, record, io_buffer, false)? } else { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_742] = unsafe { *(result.output.as_ptr() as *const [G; OUT_742]) }; __ret } } else { aiur_fn_742(__args, record, io_buffer, __cu)? } }; - let __r_arr: [G; OUT_743] = { let __args: [G; IN_743] = [__v_72, __v_20, __v_21]; let __cu = unconstrained; if let Some(result) = record.function_queries[743].get_mut(&__args[..]) { if !__cu && *result.multiplicity == G::ZERO { aiur_fn_743(__args, record, io_buffer, false)? } else { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_743] = unsafe { *(result.output.as_ptr() as *const [G; OUT_743]) }; __ret } } else { aiur_fn_743(__args, record, io_buffer, __cu)? } }; - let __ret: [G; OUT_752] = []; - if let Some(result) = record.function_queries[752].get_mut(&inp[..]) { debug_assert_eq!(result.output, &__ret[..]); if !unconstrained { *result.multiplicity += G::ONE; } } else { record.function_queries[752].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained)); }; + let __r_arr: [G; OUT_738] = { let __args: [G; IN_738] = [__v_56, __v_57, __v_58, __v_59, __v_60, __v_61, __v_62, __v_63, __v_2, __v_3, __v_4, __v_5, __v_6, __v_7, __v_8, __v_9, __v_10]; let __cu = unconstrained; if let Some(result) = record.function_queries[738].get_mut(&__args[..]) { if !__cu && *result.multiplicity == G::ZERO { aiur_fn_738(__args, record, io_buffer, false)? } else { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_738] = unsafe { *(result.output.as_ptr() as *const [G; OUT_738]) }; __ret } } else { aiur_fn_738(__args, record, io_buffer, __cu)? } }; + let __r_arr: [G; OUT_738] = { let __args: [G; IN_738] = [__v_64, __v_65, __v_66, __v_67, __v_68, __v_69, __v_70, __v_71, __v_11, __v_12, __v_13, __v_14, __v_15, __v_16, __v_17, __v_18, __v_19]; let __cu = unconstrained; if let Some(result) = record.function_queries[738].get_mut(&__args[..]) { if !__cu && *result.multiplicity == G::ZERO { aiur_fn_738(__args, record, io_buffer, false)? } else { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_738] = unsafe { *(result.output.as_ptr() as *const [G; OUT_738]) }; __ret } } else { aiur_fn_738(__args, record, io_buffer, __cu)? } }; + let __r_arr: [G; OUT_739] = { let __args: [G; IN_739] = [__v_72, __v_20, __v_21]; let __cu = unconstrained; if let Some(result) = record.function_queries[739].get_mut(&__args[..]) { if !__cu && *result.multiplicity == G::ZERO { aiur_fn_739(__args, record, io_buffer, false)? } else { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_739] = unsafe { *(result.output.as_ptr() as *const [G; OUT_739]) }; __ret } } else { aiur_fn_739(__args, record, io_buffer, __cu)? } }; + let __ret: [G; OUT_748] = []; + if let Some(result) = record.function_queries[748].get_mut(&inp[..]) { debug_assert_eq!(result.output, &__ret[..]); if !unconstrained { *result.multiplicity += G::ONE; } } else { record.function_queries[748].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained)); }; return Ok(__ret); }, } @@ -63564,10 +63292,10 @@ fn aiur_fn_752( 5u64 => { match __v_56.as_canonical_u64() { _ => { - let __r_arr: [G; OUT_742] = { let __args: [G; IN_742] = [__v_56, __v_57, __v_58, __v_59, __v_60, __v_61, __v_62, __v_63, __v_2, __v_3, __v_4, __v_5, __v_6, __v_7, __v_8, __v_9, __v_10]; let __cu = unconstrained; if let Some(result) = record.function_queries[742].get_mut(&__args[..]) { if !__cu && *result.multiplicity == G::ZERO { aiur_fn_742(__args, record, io_buffer, false)? } else { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_742] = unsafe { *(result.output.as_ptr() as *const [G; OUT_742]) }; __ret } } else { aiur_fn_742(__args, record, io_buffer, __cu)? } }; - let __r_arr: [G; OUT_743] = { let __args: [G; IN_743] = [__v_64, __v_11, __v_12]; let __cu = unconstrained; if let Some(result) = record.function_queries[743].get_mut(&__args[..]) { if !__cu && *result.multiplicity == G::ZERO { aiur_fn_743(__args, record, io_buffer, false)? } else { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_743] = unsafe { *(result.output.as_ptr() as *const [G; OUT_743]) }; __ret } } else { aiur_fn_743(__args, record, io_buffer, __cu)? } }; - let __ret: [G; OUT_752] = []; - if let Some(result) = record.function_queries[752].get_mut(&inp[..]) { debug_assert_eq!(result.output, &__ret[..]); if !unconstrained { *result.multiplicity += G::ONE; } } else { record.function_queries[752].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained)); }; + let __r_arr: [G; OUT_738] = { let __args: [G; IN_738] = [__v_56, __v_57, __v_58, __v_59, __v_60, __v_61, __v_62, __v_63, __v_2, __v_3, __v_4, __v_5, __v_6, __v_7, __v_8, __v_9, __v_10]; let __cu = unconstrained; if let Some(result) = record.function_queries[738].get_mut(&__args[..]) { if !__cu && *result.multiplicity == G::ZERO { aiur_fn_738(__args, record, io_buffer, false)? } else { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_738] = unsafe { *(result.output.as_ptr() as *const [G; OUT_738]) }; __ret } } else { aiur_fn_738(__args, record, io_buffer, __cu)? } }; + let __r_arr: [G; OUT_739] = { let __args: [G; IN_739] = [__v_64, __v_11, __v_12]; let __cu = unconstrained; if let Some(result) = record.function_queries[739].get_mut(&__args[..]) { if !__cu && *result.multiplicity == G::ZERO { aiur_fn_739(__args, record, io_buffer, false)? } else { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_739] = unsafe { *(result.output.as_ptr() as *const [G; OUT_739]) }; __ret } } else { aiur_fn_739(__args, record, io_buffer, __cu)? } }; + let __ret: [G; OUT_748] = []; + if let Some(result) = record.function_queries[748].get_mut(&inp[..]) { debug_assert_eq!(result.output, &__ret[..]); if !unconstrained { *result.multiplicity += G::ONE; } } else { record.function_queries[748].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained)); }; return Ok(__ret); }, } @@ -63582,10 +63310,10 @@ fn aiur_fn_752( 6u64 => { match __v_56.as_canonical_u64() { _ => { - let __r_arr: [G; OUT_742] = { let __args: [G; IN_742] = [__v_56, __v_57, __v_58, __v_59, __v_60, __v_61, __v_62, __v_63, __v_2, __v_3, __v_4, __v_5, __v_6, __v_7, __v_8, __v_9, __v_10]; let __cu = unconstrained; if let Some(result) = record.function_queries[742].get_mut(&__args[..]) { if !__cu && *result.multiplicity == G::ZERO { aiur_fn_742(__args, record, io_buffer, false)? } else { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_742] = unsafe { *(result.output.as_ptr() as *const [G; OUT_742]) }; __ret } } else { aiur_fn_742(__args, record, io_buffer, __cu)? } }; - let __r_arr: [G; OUT_743] = { let __args: [G; IN_743] = [__v_64, __v_11, __v_12]; let __cu = unconstrained; if let Some(result) = record.function_queries[743].get_mut(&__args[..]) { if !__cu && *result.multiplicity == G::ZERO { aiur_fn_743(__args, record, io_buffer, false)? } else { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_743] = unsafe { *(result.output.as_ptr() as *const [G; OUT_743]) }; __ret } } else { aiur_fn_743(__args, record, io_buffer, __cu)? } }; - let __ret: [G; OUT_752] = []; - if let Some(result) = record.function_queries[752].get_mut(&inp[..]) { debug_assert_eq!(result.output, &__ret[..]); if !unconstrained { *result.multiplicity += G::ONE; } } else { record.function_queries[752].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained)); }; + let __r_arr: [G; OUT_738] = { let __args: [G; IN_738] = [__v_56, __v_57, __v_58, __v_59, __v_60, __v_61, __v_62, __v_63, __v_2, __v_3, __v_4, __v_5, __v_6, __v_7, __v_8, __v_9, __v_10]; let __cu = unconstrained; if let Some(result) = record.function_queries[738].get_mut(&__args[..]) { if !__cu && *result.multiplicity == G::ZERO { aiur_fn_738(__args, record, io_buffer, false)? } else { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_738] = unsafe { *(result.output.as_ptr() as *const [G; OUT_738]) }; __ret } } else { aiur_fn_738(__args, record, io_buffer, __cu)? } }; + let __r_arr: [G; OUT_739] = { let __args: [G; IN_739] = [__v_64, __v_11, __v_12]; let __cu = unconstrained; if let Some(result) = record.function_queries[739].get_mut(&__args[..]) { if !__cu && *result.multiplicity == G::ZERO { aiur_fn_739(__args, record, io_buffer, false)? } else { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_739] = unsafe { *(result.output.as_ptr() as *const [G; OUT_739]) }; __ret } } else { aiur_fn_739(__args, record, io_buffer, __cu)? } }; + let __ret: [G; OUT_748] = []; + if let Some(result) = record.function_queries[748].get_mut(&inp[..]) { debug_assert_eq!(result.output, &__ret[..]); if !unconstrained { *result.multiplicity += G::ONE; } } else { record.function_queries[748].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained)); }; return Ok(__ret); }, } @@ -63600,10 +63328,10 @@ fn aiur_fn_752( 7u64 => { match __v_56.as_canonical_u64() { _ => { - let __r_arr: [G; OUT_742] = { let __args: [G; IN_742] = [__v_56, __v_57, __v_58, __v_59, __v_60, __v_61, __v_62, __v_63, __v_2, __v_3, __v_4, __v_5, __v_6, __v_7, __v_8, __v_9, __v_10]; let __cu = unconstrained; if let Some(result) = record.function_queries[742].get_mut(&__args[..]) { if !__cu && *result.multiplicity == G::ZERO { aiur_fn_742(__args, record, io_buffer, false)? } else { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_742] = unsafe { *(result.output.as_ptr() as *const [G; OUT_742]) }; __ret } } else { aiur_fn_742(__args, record, io_buffer, __cu)? } }; - let __r_arr: [G; OUT_743] = { let __args: [G; IN_743] = [__v_64, __v_11, __v_12]; let __cu = unconstrained; if let Some(result) = record.function_queries[743].get_mut(&__args[..]) { if !__cu && *result.multiplicity == G::ZERO { aiur_fn_743(__args, record, io_buffer, false)? } else { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_743] = unsafe { *(result.output.as_ptr() as *const [G; OUT_743]) }; __ret } } else { aiur_fn_743(__args, record, io_buffer, __cu)? } }; - let __ret: [G; OUT_752] = []; - if let Some(result) = record.function_queries[752].get_mut(&inp[..]) { debug_assert_eq!(result.output, &__ret[..]); if !unconstrained { *result.multiplicity += G::ONE; } } else { record.function_queries[752].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained)); }; + let __r_arr: [G; OUT_738] = { let __args: [G; IN_738] = [__v_56, __v_57, __v_58, __v_59, __v_60, __v_61, __v_62, __v_63, __v_2, __v_3, __v_4, __v_5, __v_6, __v_7, __v_8, __v_9, __v_10]; let __cu = unconstrained; if let Some(result) = record.function_queries[738].get_mut(&__args[..]) { if !__cu && *result.multiplicity == G::ZERO { aiur_fn_738(__args, record, io_buffer, false)? } else { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_738] = unsafe { *(result.output.as_ptr() as *const [G; OUT_738]) }; __ret } } else { aiur_fn_738(__args, record, io_buffer, __cu)? } }; + let __r_arr: [G; OUT_739] = { let __args: [G; IN_739] = [__v_64, __v_11, __v_12]; let __cu = unconstrained; if let Some(result) = record.function_queries[739].get_mut(&__args[..]) { if !__cu && *result.multiplicity == G::ZERO { aiur_fn_739(__args, record, io_buffer, false)? } else { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_739] = unsafe { *(result.output.as_ptr() as *const [G; OUT_739]) }; __ret } } else { aiur_fn_739(__args, record, io_buffer, __cu)? } }; + let __ret: [G; OUT_748] = []; + if let Some(result) = record.function_queries[748].get_mut(&inp[..]) { debug_assert_eq!(result.output, &__ret[..]); if !unconstrained { *result.multiplicity += G::ONE; } } else { record.function_queries[748].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained)); }; return Ok(__ret); }, } @@ -63616,9 +63344,9 @@ fn aiur_fn_752( 8u64 => { match __v_1.as_canonical_u64() { 8u64 => { - let __r_arr: [G; OUT_751] = { let __args: [G; IN_751] = [__v_56, __v_2]; let __cu = unconstrained; if let Some(result) = record.function_queries[751].get_mut(&__args[..]) { if !__cu && *result.multiplicity == G::ZERO { aiur_fn_751(__args, record, io_buffer, false)? } else { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_751] = unsafe { *(result.output.as_ptr() as *const [G; OUT_751]) }; __ret } } else { aiur_fn_751(__args, record, io_buffer, __cu)? } }; - let __ret: [G; OUT_752] = []; - if let Some(result) = record.function_queries[752].get_mut(&inp[..]) { debug_assert_eq!(result.output, &__ret[..]); if !unconstrained { *result.multiplicity += G::ONE; } } else { record.function_queries[752].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained)); }; + let __r_arr: [G; OUT_747] = { let __args: [G; IN_747] = [__v_56, __v_2]; let __cu = unconstrained; if let Some(result) = record.function_queries[747].get_mut(&__args[..]) { if !__cu && *result.multiplicity == G::ZERO { aiur_fn_747(__args, record, io_buffer, false)? } else { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_747] = unsafe { *(result.output.as_ptr() as *const [G; OUT_747]) }; __ret } } else { aiur_fn_747(__args, record, io_buffer, __cu)? } }; + let __ret: [G; OUT_748] = []; + if let Some(result) = record.function_queries[748].get_mut(&inp[..]) { debug_assert_eq!(result.output, &__ret[..]); if !unconstrained { *result.multiplicity += G::ONE; } } else { record.function_queries[748].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained)); }; return Ok(__ret); }, _ => { @@ -63635,41 +63363,41 @@ fn aiur_fn_752( }) } -const INPUT_SIZE_753: usize = 2; -const IN_753: usize = 2; -const OUT_753: usize = 0; -fn aiur_fn_753( - inp: [G; IN_753], +const INPUT_SIZE_749: usize = 2; +const IN_749: usize = 2; +const OUT_749: usize = 0; +fn aiur_fn_749( + inp: [G; IN_749], record: &mut QueryRecord, io_buffer: &mut IOBuffer, unconstrained: bool, -) -> Result<[G; OUT_753], ExecError> { +) -> Result<[G; OUT_749], ExecError> { stacker::maybe_grow(64 * 1024, 4 * 1024 * 1024, || { let __v_0: G = inp[0]; let __v_1: G = inp[1]; - let __r_arr: [G; OUT_713] = { let __args: [G; IN_713] = [__v_0]; let __cu = unconstrained; if let Some(result) = record.function_queries[713].get_mut(&__args[..]) { if !__cu && *result.multiplicity == G::ZERO { aiur_fn_713(__args, record, io_buffer, false)? } else { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_713] = unsafe { *(result.output.as_ptr() as *const [G; OUT_713]) }; __ret } } else { aiur_fn_713(__args, record, io_buffer, __cu)? } }; + let __r_arr: [G; OUT_709] = { let __args: [G; IN_709] = [__v_0]; let __cu = unconstrained; if let Some(result) = record.function_queries[709].get_mut(&__args[..]) { if !__cu && *result.multiplicity == G::ZERO { aiur_fn_709(__args, record, io_buffer, false)? } else { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_709] = unsafe { *(result.output.as_ptr() as *const [G; OUT_709]) }; __ret } } else { aiur_fn_709(__args, record, io_buffer, __cu)? } }; let __v_2: G = __r_arr[0]; - let __r_arr: [G; OUT_417] = { let __args: [G; IN_417] = [__v_1, __v_2]; let __cu = unconstrained; if let Some(result) = record.function_queries[417].get_mut(&__args[..]) { if !__cu && *result.multiplicity == G::ZERO { aiur_fn_417(__args, record, io_buffer, false)? } else { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_417] = unsafe { *(result.output.as_ptr() as *const [G; OUT_417]) }; __ret } } else { aiur_fn_417(__args, record, io_buffer, __cu)? } }; + let __r_arr: [G; OUT_413] = { let __args: [G; IN_413] = [__v_1, __v_2]; let __cu = unconstrained; if let Some(result) = record.function_queries[413].get_mut(&__args[..]) { if !__cu && *result.multiplicity == G::ZERO { aiur_fn_413(__args, record, io_buffer, false)? } else { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_413] = unsafe { *(result.output.as_ptr() as *const [G; OUT_413]) }; __ret } } else { aiur_fn_413(__args, record, io_buffer, __cu)? } }; let __v_3: G = __r_arr[0]; let __v_4: G = G::from_u64(1); if (__v_3 != __v_4) { return Err(ExecError::AssertEqMismatch { lhs: __v_3.as_canonical_u64(), rhs: __v_4.as_canonical_u64(), msg: Some("Contains: target is not a leaf of the claimed tree".to_string()) }); } - let __ret: [G; OUT_753] = []; - if let Some(result) = record.function_queries[753].get_mut(&inp[..]) { debug_assert_eq!(result.output, &__ret[..]); if !unconstrained { *result.multiplicity += G::ONE; } } else { record.function_queries[753].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained)); }; + let __ret: [G; OUT_749] = []; + if let Some(result) = record.function_queries[749].get_mut(&inp[..]) { debug_assert_eq!(result.output, &__ret[..]); if !unconstrained { *result.multiplicity += G::ONE; } } else { record.function_queries[749].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained)); }; return Ok(__ret); }) } -const INPUT_SIZE_754: usize = 8; -const IN_754: usize = 8; -const OUT_754: usize = 0; -fn aiur_fn_754( - inp: [G; IN_754], +const INPUT_SIZE_750: usize = 8; +const IN_750: usize = 8; +const OUT_750: usize = 0; +fn aiur_fn_750( + inp: [G; IN_750], record: &mut QueryRecord, io_buffer: &mut IOBuffer, unconstrained: bool, -) -> Result<[G; OUT_754], ExecError> { +) -> Result<[G; OUT_750], ExecError> { stacker::maybe_grow(64 * 1024, 4 * 1024 * 1024, || { let __v_0: G = inp[0]; let __v_1: G = inp[1]; @@ -63897,23 +63625,23 @@ fn aiur_fn_754( let __r_arr: [G; OUT_85] = { let __args: [G; IN_85] = [__v_105]; let __cu = unconstrained; if let Some(result) = record.function_queries[85].get_mut(&__args[..]) { if !__cu && *result.multiplicity == G::ZERO { aiur_fn_85(__args, record, io_buffer, false)? } else { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_85] = unsafe { *(result.output.as_ptr() as *const [G; OUT_85]) }; __ret } } else { aiur_fn_85(__args, record, io_buffer, __cu)? } }; let __v_186: G = __r_arr[0]; let __v_187: G = __r_arr[1]; - let __r_arr: [G; OUT_720] = { let __args: [G; IN_720] = [__v_187]; let __cu = unconstrained; if let Some(result) = record.function_queries[720].get_mut(&__args[..]) { if !__cu && *result.multiplicity == G::ZERO { aiur_fn_720(__args, record, io_buffer, false)? } else { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_720] = unsafe { *(result.output.as_ptr() as *const [G; OUT_720]) }; __ret } } else { aiur_fn_720(__args, record, io_buffer, __cu)? } }; + let __r_arr: [G; OUT_716] = { let __args: [G; IN_716] = [__v_187]; let __cu = unconstrained; if let Some(result) = record.function_queries[716].get_mut(&__args[..]) { if !__cu && *result.multiplicity == G::ZERO { aiur_fn_716(__args, record, io_buffer, false)? } else { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_716] = unsafe { *(result.output.as_ptr() as *const [G; OUT_716]) }; __ret } } else { aiur_fn_716(__args, record, io_buffer, __cu)? } }; let __v_188: G = __r_arr[0]; let __v_189: G = __r_arr[1]; let __v_190: G = __r_arr[2]; match __v_188.as_canonical_u64() { 1u64 => { - let __r_arr: [G; OUT_706] = { let __args: [G; IN_706] = [__v_186]; let __cu = unconstrained; if let Some(result) = record.function_queries[706].get_mut(&__args[..]) { if !__cu && *result.multiplicity == G::ZERO { aiur_fn_706(__args, record, io_buffer, false)? } else { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_706] = unsafe { *(result.output.as_ptr() as *const [G; OUT_706]) }; __ret } } else { aiur_fn_706(__args, record, io_buffer, __cu)? } }; - let __ret: [G; OUT_754] = []; - if let Some(result) = record.function_queries[754].get_mut(&inp[..]) { debug_assert_eq!(result.output, &__ret[..]); if !unconstrained { *result.multiplicity += G::ONE; } } else { record.function_queries[754].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained)); }; + let __r_arr: [G; OUT_702] = { let __args: [G; IN_702] = [__v_186]; let __cu = unconstrained; if let Some(result) = record.function_queries[702].get_mut(&__args[..]) { if !__cu && *result.multiplicity == G::ZERO { aiur_fn_702(__args, record, io_buffer, false)? } else { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_702] = unsafe { *(result.output.as_ptr() as *const [G; OUT_702]) }; __ret } } else { aiur_fn_702(__args, record, io_buffer, __cu)? } }; + let __ret: [G; OUT_750] = []; + if let Some(result) = record.function_queries[750].get_mut(&inp[..]) { debug_assert_eq!(result.output, &__ret[..]); if !unconstrained { *result.multiplicity += G::ONE; } } else { record.function_queries[750].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained)); }; return Ok(__ret); }, 0u64 => { - let __r_arr: [G; OUT_713] = { let __args: [G; IN_713] = [__v_189]; let __cu = unconstrained; if let Some(result) = record.function_queries[713].get_mut(&__args[..]) { if !__cu && *result.multiplicity == G::ZERO { aiur_fn_713(__args, record, io_buffer, false)? } else { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_713] = unsafe { *(result.output.as_ptr() as *const [G; OUT_713]) }; __ret } } else { aiur_fn_713(__args, record, io_buffer, __cu)? } }; + let __r_arr: [G; OUT_709] = { let __args: [G; IN_709] = [__v_189]; let __cu = unconstrained; if let Some(result) = record.function_queries[709].get_mut(&__args[..]) { if !__cu && *result.multiplicity == G::ZERO { aiur_fn_709(__args, record, io_buffer, false)? } else { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_709] = unsafe { *(result.output.as_ptr() as *const [G; OUT_709]) }; __ret } } else { aiur_fn_709(__args, record, io_buffer, __cu)? } }; let __v_191: G = __r_arr[0]; let __v_192: G = G::from_u64(1); let __v_193: G = G::from_u64(1); - let __r_arr: [G; OUT_714] = { let __args: [G; IN_714] = [__v_191, __v_192, __v_193, __v_193, __v_193, __v_193, __v_193]; let __cu = unconstrained; if let Some(result) = record.function_queries[714].get_mut(&__args[..]) { if !__cu && *result.multiplicity == G::ZERO { aiur_fn_714(__args, record, io_buffer, false)? } else { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_714] = unsafe { *(result.output.as_ptr() as *const [G; OUT_714]) }; __ret } } else { aiur_fn_714(__args, record, io_buffer, __cu)? } }; + let __r_arr: [G; OUT_710] = { let __args: [G; IN_710] = [__v_191, __v_192, __v_193, __v_193, __v_193, __v_193, __v_193]; let __cu = unconstrained; if let Some(result) = record.function_queries[710].get_mut(&__args[..]) { if !__cu && *result.multiplicity == G::ZERO { aiur_fn_710(__args, record, io_buffer, false)? } else { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_710] = unsafe { *(result.output.as_ptr() as *const [G; OUT_710]) }; __ret } } else { aiur_fn_710(__args, record, io_buffer, __cu)? } }; let __v_194: G = __r_arr[0]; let __v_195: G = __r_arr[1]; let __v_196: G = __r_arr[2]; @@ -63923,9 +63651,9 @@ fn aiur_fn_754( let __v_200: G = G::from_u64(1); let __v_201: G = G::from_u64(1); let __v_202: G = G::from_u64(0); - let __r_arr: [G; OUT_716] = { let __args: [G; IN_716] = [__v_186, __v_200, __v_201, __v_201, __v_201, __v_201, __v_201, __v_194, __v_195, __v_196, __v_197, __v_198, __v_199, __v_202]; let __cu = unconstrained; if let Some(result) = record.function_queries[716].get_mut(&__args[..]) { if !__cu && *result.multiplicity == G::ZERO { aiur_fn_716(__args, record, io_buffer, false)? } else { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_716] = unsafe { *(result.output.as_ptr() as *const [G; OUT_716]) }; __ret } } else { aiur_fn_716(__args, record, io_buffer, __cu)? } }; - let __ret: [G; OUT_754] = []; - if let Some(result) = record.function_queries[754].get_mut(&inp[..]) { debug_assert_eq!(result.output, &__ret[..]); if !unconstrained { *result.multiplicity += G::ONE; } } else { record.function_queries[754].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained)); }; + let __r_arr: [G; OUT_712] = { let __args: [G; IN_712] = [__v_186, __v_200, __v_201, __v_201, __v_201, __v_201, __v_201, __v_194, __v_195, __v_196, __v_197, __v_198, __v_199, __v_202]; let __cu = unconstrained; if let Some(result) = record.function_queries[712].get_mut(&__args[..]) { if !__cu && *result.multiplicity == G::ZERO { aiur_fn_712(__args, record, io_buffer, false)? } else { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_712] = unsafe { *(result.output.as_ptr() as *const [G; OUT_712]) }; __ret } } else { aiur_fn_712(__args, record, io_buffer, __cu)? } }; + let __ret: [G; OUT_750] = []; + if let Some(result) = record.function_queries[750].get_mut(&inp[..]) { debug_assert_eq!(result.output, &__ret[..]); if !unconstrained { *result.multiplicity += G::ONE; } } else { record.function_queries[750].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained)); }; return Ok(__ret); }, _ => { @@ -63937,20 +63665,20 @@ fn aiur_fn_754( let __r_arr: [G; OUT_85] = { let __args: [G; IN_85] = [__v_105]; let __cu = unconstrained; if let Some(result) = record.function_queries[85].get_mut(&__args[..]) { if !__cu && *result.multiplicity == G::ZERO { aiur_fn_85(__args, record, io_buffer, false)? } else { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_85] = unsafe { *(result.output.as_ptr() as *const [G; OUT_85]) }; __ret } } else { aiur_fn_85(__args, record, io_buffer, __cu)? } }; let __v_186: G = __r_arr[0]; let __v_187: G = __r_arr[1]; - let __r_arr: [G; OUT_720] = { let __args: [G; IN_720] = [__v_187]; let __cu = unconstrained; if let Some(result) = record.function_queries[720].get_mut(&__args[..]) { if !__cu && *result.multiplicity == G::ZERO { aiur_fn_720(__args, record, io_buffer, false)? } else { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_720] = unsafe { *(result.output.as_ptr() as *const [G; OUT_720]) }; __ret } } else { aiur_fn_720(__args, record, io_buffer, __cu)? } }; + let __r_arr: [G; OUT_716] = { let __args: [G; IN_716] = [__v_187]; let __cu = unconstrained; if let Some(result) = record.function_queries[716].get_mut(&__args[..]) { if !__cu && *result.multiplicity == G::ZERO { aiur_fn_716(__args, record, io_buffer, false)? } else { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_716] = unsafe { *(result.output.as_ptr() as *const [G; OUT_716]) }; __ret } } else { aiur_fn_716(__args, record, io_buffer, __cu)? } }; let __v_188: G = __r_arr[0]; let __v_189: G = __r_arr[1]; let __v_190: G = __r_arr[2]; - let __r_arr: [G; OUT_719] = { let __args: [G; IN_719] = [__v_186, __v_188, __v_189]; let __cu = unconstrained; if let Some(result) = record.function_queries[719].get_mut(&__args[..]) { if !__cu && *result.multiplicity == G::ZERO { aiur_fn_719(__args, record, io_buffer, false)? } else { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_719] = unsafe { *(result.output.as_ptr() as *const [G; OUT_719]) }; __ret } } else { aiur_fn_719(__args, record, io_buffer, __cu)? } }; - let __ret: [G; OUT_754] = []; - if let Some(result) = record.function_queries[754].get_mut(&inp[..]) { debug_assert_eq!(result.output, &__ret[..]); if !unconstrained { *result.multiplicity += G::ONE; } } else { record.function_queries[754].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained)); }; + let __r_arr: [G; OUT_715] = { let __args: [G; IN_715] = [__v_186, __v_188, __v_189]; let __cu = unconstrained; if let Some(result) = record.function_queries[715].get_mut(&__args[..]) { if !__cu && *result.multiplicity == G::ZERO { aiur_fn_715(__args, record, io_buffer, false)? } else { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_715] = unsafe { *(result.output.as_ptr() as *const [G; OUT_715]) }; __ret } } else { aiur_fn_715(__args, record, io_buffer, __cu)? } }; + let __ret: [G; OUT_750] = []; + if let Some(result) = record.function_queries[750].get_mut(&inp[..]) { debug_assert_eq!(result.output, &__ret[..]); if !unconstrained { *result.multiplicity += G::ONE; } } else { record.function_queries[750].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained)); }; return Ok(__ret); }, 6u64 => { let __r_arr: [G; OUT_85] = { let __args: [G; IN_85] = [__v_105]; let __cu = unconstrained; if let Some(result) = record.function_queries[85].get_mut(&__args[..]) { if !__cu && *result.multiplicity == G::ZERO { aiur_fn_85(__args, record, io_buffer, false)? } else { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_85] = unsafe { *(result.output.as_ptr() as *const [G; OUT_85]) }; __ret } } else { aiur_fn_85(__args, record, io_buffer, __cu)? } }; let __v_186: G = __r_arr[0]; let __v_187: G = __r_arr[1]; - let __r_arr: [G; OUT_735] = { let __args: [G; IN_735] = [__v_187]; let __cu = unconstrained; if let Some(result) = record.function_queries[735].get_mut(&__args[..]) { if !__cu && *result.multiplicity == G::ZERO { aiur_fn_735(__args, record, io_buffer, false)? } else { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_735] = unsafe { *(result.output.as_ptr() as *const [G; OUT_735]) }; __ret } } else { aiur_fn_735(__args, record, io_buffer, __cu)? } }; + let __r_arr: [G; OUT_731] = { let __args: [G; IN_731] = [__v_187]; let __cu = unconstrained; if let Some(result) = record.function_queries[731].get_mut(&__args[..]) { if !__cu && *result.multiplicity == G::ZERO { aiur_fn_731(__args, record, io_buffer, false)? } else { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_731] = unsafe { *(result.output.as_ptr() as *const [G; OUT_731]) }; __ret } } else { aiur_fn_731(__args, record, io_buffer, __cu)? } }; let __v_188: G = __r_arr[0]; let __v_189: G = __r_arr[1]; let __v_190: G = __r_arr[2]; @@ -64006,9 +63734,9 @@ fn aiur_fn_754( let __v_240: G = __r_arr[52]; let __v_241: G = __r_arr[53]; let __v_242: G = __r_arr[54]; - let __r_arr: [G; OUT_752] = { let __args: [G; IN_752] = [__v_186, __v_188, __v_189, __v_190, __v_191, __v_192, __v_193, __v_194, __v_195, __v_196, __v_197, __v_198, __v_199, __v_200, __v_201, __v_202, __v_203, __v_204, __v_205, __v_206, __v_207, __v_208, __v_209, __v_210, __v_211, __v_212, __v_213, __v_214, __v_215, __v_216, __v_217, __v_218, __v_219, __v_220, __v_221, __v_222, __v_223, __v_224, __v_225, __v_226, __v_227, __v_228, __v_229, __v_230, __v_231, __v_232, __v_233, __v_234, __v_235, __v_236, __v_237, __v_238, __v_239, __v_240, __v_241]; let __cu = unconstrained; if let Some(result) = record.function_queries[752].get_mut(&__args[..]) { if !__cu && *result.multiplicity == G::ZERO { aiur_fn_752(__args, record, io_buffer, false)? } else { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_752] = unsafe { *(result.output.as_ptr() as *const [G; OUT_752]) }; __ret } } else { aiur_fn_752(__args, record, io_buffer, __cu)? } }; - let __ret: [G; OUT_754] = []; - if let Some(result) = record.function_queries[754].get_mut(&inp[..]) { debug_assert_eq!(result.output, &__ret[..]); if !unconstrained { *result.multiplicity += G::ONE; } } else { record.function_queries[754].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained)); }; + let __r_arr: [G; OUT_748] = { let __args: [G; IN_748] = [__v_186, __v_188, __v_189, __v_190, __v_191, __v_192, __v_193, __v_194, __v_195, __v_196, __v_197, __v_198, __v_199, __v_200, __v_201, __v_202, __v_203, __v_204, __v_205, __v_206, __v_207, __v_208, __v_209, __v_210, __v_211, __v_212, __v_213, __v_214, __v_215, __v_216, __v_217, __v_218, __v_219, __v_220, __v_221, __v_222, __v_223, __v_224, __v_225, __v_226, __v_227, __v_228, __v_229, __v_230, __v_231, __v_232, __v_233, __v_234, __v_235, __v_236, __v_237, __v_238, __v_239, __v_240, __v_241]; let __cu = unconstrained; if let Some(result) = record.function_queries[748].get_mut(&__args[..]) { if !__cu && *result.multiplicity == G::ZERO { aiur_fn_748(__args, record, io_buffer, false)? } else { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_748] = unsafe { *(result.output.as_ptr() as *const [G; OUT_748]) }; __ret } } else { aiur_fn_748(__args, record, io_buffer, __cu)? } }; + let __ret: [G; OUT_750] = []; + if let Some(result) = record.function_queries[750].get_mut(&inp[..]) { debug_assert_eq!(result.output, &__ret[..]); if !unconstrained { *result.multiplicity += G::ONE; } } else { record.function_queries[750].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained)); }; return Ok(__ret); }, 7u64 => { @@ -64018,9 +63746,9 @@ fn aiur_fn_754( let __r_arr: [G; OUT_85] = { let __args: [G; IN_85] = [__v_187]; let __cu = unconstrained; if let Some(result) = record.function_queries[85].get_mut(&__args[..]) { if !__cu && *result.multiplicity == G::ZERO { aiur_fn_85(__args, record, io_buffer, false)? } else { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_85] = unsafe { *(result.output.as_ptr() as *const [G; OUT_85]) }; __ret } } else { aiur_fn_85(__args, record, io_buffer, __cu)? } }; let __v_188: G = __r_arr[0]; let __v_189: G = __r_arr[1]; - let __r_arr: [G; OUT_753] = { let __args: [G; IN_753] = [__v_186, __v_188]; let __cu = unconstrained; if let Some(result) = record.function_queries[753].get_mut(&__args[..]) { if !__cu && *result.multiplicity == G::ZERO { aiur_fn_753(__args, record, io_buffer, false)? } else { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_753] = unsafe { *(result.output.as_ptr() as *const [G; OUT_753]) }; __ret } } else { aiur_fn_753(__args, record, io_buffer, __cu)? } }; - let __ret: [G; OUT_754] = []; - if let Some(result) = record.function_queries[754].get_mut(&inp[..]) { debug_assert_eq!(result.output, &__ret[..]); if !unconstrained { *result.multiplicity += G::ONE; } } else { record.function_queries[754].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained)); }; + let __r_arr: [G; OUT_749] = { let __args: [G; IN_749] = [__v_186, __v_188]; let __cu = unconstrained; if let Some(result) = record.function_queries[749].get_mut(&__args[..]) { if !__cu && *result.multiplicity == G::ZERO { aiur_fn_749(__args, record, io_buffer, false)? } else { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_749] = unsafe { *(result.output.as_ptr() as *const [G; OUT_749]) }; __ret } } else { aiur_fn_749(__args, record, io_buffer, __cu)? } }; + let __ret: [G; OUT_750] = []; + if let Some(result) = record.function_queries[750].get_mut(&inp[..]) { debug_assert_eq!(result.output, &__ret[..]); if !unconstrained { *result.multiplicity += G::ONE; } } else { record.function_queries[750].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained)); }; return Ok(__ret); }, _ => { @@ -64030,15 +63758,15 @@ fn aiur_fn_754( }) } -const INPUT_SIZE_755: usize = 8; -const IN_755: usize = 8; -const OUT_755: usize = 0; -fn aiur_fn_755( - inp: [G; IN_755], +const INPUT_SIZE_751: usize = 8; +const IN_751: usize = 8; +const OUT_751: usize = 0; +fn aiur_fn_751( + inp: [G; IN_751], record: &mut QueryRecord, io_buffer: &mut IOBuffer, unconstrained: bool, -) -> Result<[G; OUT_755], ExecError> { +) -> Result<[G; OUT_751], ExecError> { stacker::maybe_grow(64 * 1024, 4 * 1024 * 1024, || { let __v_0: G = inp[0]; let __v_1: G = inp[1]; @@ -64048,27 +63776,27 @@ fn aiur_fn_755( let __v_5: G = inp[5]; let __v_6: G = inp[6]; let __v_7: G = inp[7]; - let __r_arr: [G; OUT_754] = { let __args: [G; IN_754] = [__v_0, __v_1, __v_2, __v_3, __v_4, __v_5, __v_6, __v_7]; let __cu = unconstrained; if let Some(result) = record.function_queries[754].get_mut(&__args[..]) { if !__cu && *result.multiplicity == G::ZERO { aiur_fn_754(__args, record, io_buffer, false)? } else { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_754] = unsafe { *(result.output.as_ptr() as *const [G; OUT_754]) }; __ret } } else { aiur_fn_754(__args, record, io_buffer, __cu)? } }; - let __ret: [G; OUT_755] = []; - if let Some(result) = record.function_queries[755].get_mut(&inp[..]) { debug_assert_eq!(result.output, &__ret[..]); if !unconstrained { *result.multiplicity += G::ONE; } } else { record.function_queries[755].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained)); }; + let __r_arr: [G; OUT_750] = { let __args: [G; IN_750] = [__v_0, __v_1, __v_2, __v_3, __v_4, __v_5, __v_6, __v_7]; let __cu = unconstrained; if let Some(result) = record.function_queries[750].get_mut(&__args[..]) { if !__cu && *result.multiplicity == G::ZERO { aiur_fn_750(__args, record, io_buffer, false)? } else { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_750] = unsafe { *(result.output.as_ptr() as *const [G; OUT_750]) }; __ret } } else { aiur_fn_750(__args, record, io_buffer, __cu)? } }; + let __ret: [G; OUT_751] = []; + if let Some(result) = record.function_queries[751].get_mut(&inp[..]) { debug_assert_eq!(result.output, &__ret[..]); if !unconstrained { *result.multiplicity += G::ONE; } } else { record.function_queries[751].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained)); }; return Ok(__ret); }) } -const INPUT_SIZE_756: usize = 3; -const IN_756: usize = 3; -const OUT_756: usize = 1; -fn aiur_fn_756( - inp: [G; IN_756], +const INPUT_SIZE_752: usize = 3; +const IN_752: usize = 3; +const OUT_752: usize = 1; +fn aiur_fn_752( + inp: [G; IN_752], record: &mut QueryRecord, io_buffer: &mut IOBuffer, unconstrained: bool, -) -> Result<[G; OUT_756], ExecError> { +) -> Result<[G; OUT_752], ExecError> { stacker::maybe_grow(64 * 1024, 4 * 1024 * 1024, || { let __v_0: G = inp[0]; let __v_1: G = inp[1]; let __v_2: G = inp[2]; - let __r_arr: [G; OUT_775] = { let __args: [G; IN_775] = [__v_0, __v_1]; let __cu = unconstrained; if let Some(result) = record.function_queries[775].get_mut(&__args[..]) { if !__cu && *result.multiplicity == G::ZERO { aiur_fn_775(__args, record, io_buffer, false)? } else { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_775] = unsafe { *(result.output.as_ptr() as *const [G; OUT_775]) }; __ret } } else { aiur_fn_775(__args, record, io_buffer, __cu)? } }; + let __r_arr: [G; OUT_771] = { let __args: [G; IN_771] = [__v_0, __v_1]; let __cu = unconstrained; if let Some(result) = record.function_queries[771].get_mut(&__args[..]) { if !__cu && *result.multiplicity == G::ZERO { aiur_fn_771(__args, record, io_buffer, false)? } else { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_771] = unsafe { *(result.output.as_ptr() as *const [G; OUT_771]) }; __ret } } else { aiur_fn_771(__args, record, io_buffer, __cu)? } }; let __v_3: G = __r_arr[0]; let __loaded: [G; 3] = { let __mq = record.memory_queries.get_mut(&3).ok_or(ExecError::InvalidMemorySize(3))?; let __ptr_u64 = __v_3.as_canonical_u64(); let __ptr_usize = usize::try_from(__ptr_u64).ok().ok_or(ExecError::PointerTooLarge(__ptr_u64))?; let (__args, __mult) = __mq.get_index_mut(__ptr_usize).ok_or(ExecError::UnboundPointer { ptr: __ptr_u64, size: 3 })?; if !unconstrained { *__mult += G::ONE; } let __arr: [G; 3] = __args[..3].try_into().unwrap(); __arr }; let __v_4: G = __loaded[0]; @@ -64076,13 +63804,13 @@ fn aiur_fn_756( let __v_6: G = __loaded[2]; match __v_4.as_canonical_u64() { 1u64 => { - let __ret: [G; OUT_756] = [__v_2]; - if let Some(result) = record.function_queries[756].get_mut(&inp[..]) { debug_assert_eq!(result.output, &__ret[..]); if !unconstrained { *result.multiplicity += G::ONE; } } else { record.function_queries[756].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained)); }; + let __ret: [G; OUT_752] = [__v_2]; + if let Some(result) = record.function_queries[752].get_mut(&inp[..]) { debug_assert_eq!(result.output, &__ret[..]); if !unconstrained { *result.multiplicity += G::ONE; } } else { record.function_queries[752].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained)); }; return Ok(__ret); }, 0u64 => { - let __ret: [G; OUT_756] = [__v_5]; - if let Some(result) = record.function_queries[756].get_mut(&inp[..]) { debug_assert_eq!(result.output, &__ret[..]); if !unconstrained { *result.multiplicity += G::ONE; } } else { record.function_queries[756].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained)); }; + let __ret: [G; OUT_752] = [__v_5]; + if let Some(result) = record.function_queries[752].get_mut(&inp[..]) { debug_assert_eq!(result.output, &__ret[..]); if !unconstrained { *result.multiplicity += G::ONE; } } else { record.function_queries[752].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained)); }; return Ok(__ret); }, _ => { @@ -64092,15 +63820,15 @@ fn aiur_fn_756( }) } -const INPUT_SIZE_757: usize = 2; -const IN_757: usize = 2; -const OUT_757: usize = 1; -fn aiur_fn_757( - inp: [G; IN_757], +const INPUT_SIZE_753: usize = 2; +const IN_753: usize = 2; +const OUT_753: usize = 1; +fn aiur_fn_753( + inp: [G; IN_753], record: &mut QueryRecord, io_buffer: &mut IOBuffer, unconstrained: bool, -) -> Result<[G; OUT_757], ExecError> { +) -> Result<[G; OUT_753], ExecError> { stacker::maybe_grow(64 * 1024, 4 * 1024 * 1024, || { let __v_0: G = inp[0]; let __v_1: G = inp[1]; @@ -64115,17 +63843,17 @@ fn aiur_fn_757( let __v_7: G = G::from_u64(1); let __v_8: G = { let __values: [G; 3] = [__v_6, __v_7, __v_7]; let __mq = record.memory_queries.get_mut(&3).ok_or(ExecError::InvalidMemorySize(3))?; if let Some(result) = __mq.get_mut(&__values[..]) { if !unconstrained { *result.multiplicity += G::ONE; } result.output[0] } else { let __ptr = G::from_usize(__mq.len()); __mq.insert(&__values[..], &[__ptr], G::from_bool(!unconstrained)); __ptr } }; let __v_9: G = { let __values: [G; 3] = [__v_5, __v_1, __v_8]; let __mq = record.memory_queries.get_mut(&3).ok_or(ExecError::InvalidMemorySize(3))?; if let Some(result) = __mq.get_mut(&__values[..]) { if !unconstrained { *result.multiplicity += G::ONE; } result.output[0] } else { let __ptr = G::from_usize(__mq.len()); __mq.insert(&__values[..], &[__ptr], G::from_bool(!unconstrained)); __ptr } }; - let __ret: [G; OUT_757] = [__v_9]; - if let Some(result) = record.function_queries[757].get_mut(&inp[..]) { debug_assert_eq!(result.output, &__ret[..]); if !unconstrained { *result.multiplicity += G::ONE; } } else { record.function_queries[757].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained)); }; + let __ret: [G; OUT_753] = [__v_9]; + if let Some(result) = record.function_queries[753].get_mut(&inp[..]) { debug_assert_eq!(result.output, &__ret[..]); if !unconstrained { *result.multiplicity += G::ONE; } } else { record.function_queries[753].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained)); }; return Ok(__ret); }, 0u64 => { let __v_5: G = G::from_u64(0); - let __r_arr: [G; OUT_757] = { let __args: [G; IN_757] = [__v_4, __v_1]; let __cu = unconstrained; if let Some(result) = record.function_queries[757].get_mut(&__args[..]) { if !__cu && *result.multiplicity == G::ZERO { aiur_fn_757(__args, record, io_buffer, false)? } else { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_757] = unsafe { *(result.output.as_ptr() as *const [G; OUT_757]) }; __ret } } else { aiur_fn_757(__args, record, io_buffer, __cu)? } }; + let __r_arr: [G; OUT_753] = { let __args: [G; IN_753] = [__v_4, __v_1]; let __cu = unconstrained; if let Some(result) = record.function_queries[753].get_mut(&__args[..]) { if !__cu && *result.multiplicity == G::ZERO { aiur_fn_753(__args, record, io_buffer, false)? } else { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_753] = unsafe { *(result.output.as_ptr() as *const [G; OUT_753]) }; __ret } } else { aiur_fn_753(__args, record, io_buffer, __cu)? } }; let __v_6: G = __r_arr[0]; let __v_7: G = { let __values: [G; 3] = [__v_5, __v_3, __v_6]; let __mq = record.memory_queries.get_mut(&3).ok_or(ExecError::InvalidMemorySize(3))?; if let Some(result) = __mq.get_mut(&__values[..]) { if !unconstrained { *result.multiplicity += G::ONE; } result.output[0] } else { let __ptr = G::from_usize(__mq.len()); __mq.insert(&__values[..], &[__ptr], G::from_bool(!unconstrained)); __ptr } }; - let __ret: [G; OUT_757] = [__v_7]; - if let Some(result) = record.function_queries[757].get_mut(&inp[..]) { debug_assert_eq!(result.output, &__ret[..]); if !unconstrained { *result.multiplicity += G::ONE; } } else { record.function_queries[757].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained)); }; + let __ret: [G; OUT_753] = [__v_7]; + if let Some(result) = record.function_queries[753].get_mut(&inp[..]) { debug_assert_eq!(result.output, &__ret[..]); if !unconstrained { *result.multiplicity += G::ONE; } } else { record.function_queries[753].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained)); }; return Ok(__ret); }, _ => { @@ -64135,15 +63863,15 @@ fn aiur_fn_757( }) } -const INPUT_SIZE_758: usize = 1; -const IN_758: usize = 1; -const OUT_758: usize = 8; -fn aiur_fn_758( - inp: [G; IN_758], +const INPUT_SIZE_754: usize = 1; +const IN_754: usize = 1; +const OUT_754: usize = 8; +fn aiur_fn_754( + inp: [G; IN_754], record: &mut QueryRecord, io_buffer: &mut IOBuffer, unconstrained: bool, -) -> Result<[G; OUT_758], ExecError> { +) -> Result<[G; OUT_754], ExecError> { stacker::maybe_grow(64 * 1024, 4 * 1024 * 1024, || { let __v_0: G = inp[0]; let __loaded: [G; 10] = { let __mq = record.memory_queries.get_mut(&10).ok_or(ExecError::InvalidMemorySize(10))?; let __ptr_u64 = __v_0.as_canonical_u64(); let __ptr_usize = usize::try_from(__ptr_u64).ok().ok_or(ExecError::PointerTooLarge(__ptr_u64))?; let (__args, __mult) = __mq.get_index_mut(__ptr_usize).ok_or(ExecError::UnboundPointer { ptr: __ptr_u64, size: 10 })?; if !unconstrained { *__mult += G::ONE; } let __arr: [G; 10] = __args[..10].try_into().unwrap(); __arr }; @@ -64167,12 +63895,12 @@ fn aiur_fn_758( let __v_16: G = G::from_u64(0); let __v_17: G = G::from_u64(0); let __v_18: G = G::from_u64(0); - let __ret: [G; OUT_758] = [__v_11, __v_12, __v_13, __v_14, __v_15, __v_16, __v_17, __v_18]; - if let Some(result) = record.function_queries[758].get_mut(&inp[..]) { debug_assert_eq!(result.output, &__ret[..]); if !unconstrained { *result.multiplicity += G::ONE; } } else { record.function_queries[758].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained)); }; + let __ret: [G; OUT_754] = [__v_11, __v_12, __v_13, __v_14, __v_15, __v_16, __v_17, __v_18]; + if let Some(result) = record.function_queries[754].get_mut(&inp[..]) { debug_assert_eq!(result.output, &__ret[..]); if !unconstrained { *result.multiplicity += G::ONE; } } else { record.function_queries[754].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained)); }; return Ok(__ret); }, 0u64 => { - let __r_arr: [G; OUT_758] = { let __args: [G; IN_758] = [__v_10]; let __cu = unconstrained; if let Some(result) = record.function_queries[758].get_mut(&__args[..]) { if !__cu && *result.multiplicity == G::ZERO { aiur_fn_758(__args, record, io_buffer, false)? } else { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_758] = unsafe { *(result.output.as_ptr() as *const [G; OUT_758]) }; __ret } } else { aiur_fn_758(__args, record, io_buffer, __cu)? } }; + let __r_arr: [G; OUT_754] = { let __args: [G; IN_754] = [__v_10]; let __cu = unconstrained; if let Some(result) = record.function_queries[754].get_mut(&__args[..]) { if !__cu && *result.multiplicity == G::ZERO { aiur_fn_754(__args, record, io_buffer, false)? } else { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_754] = unsafe { *(result.output.as_ptr() as *const [G; OUT_754]) }; __ret } } else { aiur_fn_754(__args, record, io_buffer, __cu)? } }; let __v_11: G = __r_arr[0]; let __v_12: G = __r_arr[1]; let __v_13: G = __r_arr[2]; @@ -64190,8 +63918,8 @@ fn aiur_fn_758( let __v_24: G = __r_arr[5]; let __v_25: G = __r_arr[6]; let __v_26: G = __r_arr[7]; - let __ret: [G; OUT_758] = [__v_19, __v_20, __v_21, __v_22, __v_23, __v_24, __v_25, __v_26]; - if let Some(result) = record.function_queries[758].get_mut(&inp[..]) { debug_assert_eq!(result.output, &__ret[..]); if !unconstrained { *result.multiplicity += G::ONE; } } else { record.function_queries[758].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained)); }; + let __ret: [G; OUT_754] = [__v_19, __v_20, __v_21, __v_22, __v_23, __v_24, __v_25, __v_26]; + if let Some(result) = record.function_queries[754].get_mut(&inp[..]) { debug_assert_eq!(result.output, &__ret[..]); if !unconstrained { *result.multiplicity += G::ONE; } } else { record.function_queries[754].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained)); }; return Ok(__ret); }, _ => { @@ -64201,15 +63929,15 @@ fn aiur_fn_758( }) } -const INPUT_SIZE_759: usize = 2; -const IN_759: usize = 2; -const OUT_759: usize = 1; -fn aiur_fn_759( - inp: [G; IN_759], +const INPUT_SIZE_755: usize = 2; +const IN_755: usize = 2; +const OUT_755: usize = 1; +fn aiur_fn_755( + inp: [G; IN_755], record: &mut QueryRecord, io_buffer: &mut IOBuffer, unconstrained: bool, -) -> Result<[G; OUT_759], ExecError> { +) -> Result<[G; OUT_755], ExecError> { stacker::maybe_grow(64 * 1024, 4 * 1024 * 1024, || { let __v_0: G = inp[0]; let __v_1: G = inp[1]; @@ -64220,17 +63948,17 @@ fn aiur_fn_759( let __v_5: G = __loaded[3]; match __v_2.as_canonical_u64() { 1u64 => { - let __ret: [G; OUT_759] = [__v_1]; - if let Some(result) = record.function_queries[759].get_mut(&inp[..]) { debug_assert_eq!(result.output, &__ret[..]); if !unconstrained { *result.multiplicity += G::ONE; } } else { record.function_queries[759].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained)); }; + let __ret: [G; OUT_755] = [__v_1]; + if let Some(result) = record.function_queries[755].get_mut(&inp[..]) { debug_assert_eq!(result.output, &__ret[..]); if !unconstrained { *result.multiplicity += G::ONE; } } else { record.function_queries[755].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained)); }; return Ok(__ret); }, 0u64 => { let __v_6: G = G::from_u64(0); - let __r_arr: [G; OUT_759] = { let __args: [G; IN_759] = [__v_5, __v_1]; let __cu = unconstrained; if let Some(result) = record.function_queries[759].get_mut(&__args[..]) { if !__cu && *result.multiplicity == G::ZERO { aiur_fn_759(__args, record, io_buffer, false)? } else { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_759] = unsafe { *(result.output.as_ptr() as *const [G; OUT_759]) }; __ret } } else { aiur_fn_759(__args, record, io_buffer, __cu)? } }; + let __r_arr: [G; OUT_755] = { let __args: [G; IN_755] = [__v_5, __v_1]; let __cu = unconstrained; if let Some(result) = record.function_queries[755].get_mut(&__args[..]) { if !__cu && *result.multiplicity == G::ZERO { aiur_fn_755(__args, record, io_buffer, false)? } else { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_755] = unsafe { *(result.output.as_ptr() as *const [G; OUT_755]) }; __ret } } else { aiur_fn_755(__args, record, io_buffer, __cu)? } }; let __v_7: G = __r_arr[0]; let __v_8: G = { let __values: [G; 4] = [__v_6, __v_3, __v_4, __v_7]; let __mq = record.memory_queries.get_mut(&4).ok_or(ExecError::InvalidMemorySize(4))?; if let Some(result) = __mq.get_mut(&__values[..]) { if !unconstrained { *result.multiplicity += G::ONE; } result.output[0] } else { let __ptr = G::from_usize(__mq.len()); __mq.insert(&__values[..], &[__ptr], G::from_bool(!unconstrained)); __ptr } }; - let __ret: [G; OUT_759] = [__v_8]; - if let Some(result) = record.function_queries[759].get_mut(&inp[..]) { debug_assert_eq!(result.output, &__ret[..]); if !unconstrained { *result.multiplicity += G::ONE; } } else { record.function_queries[759].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained)); }; + let __ret: [G; OUT_755] = [__v_8]; + if let Some(result) = record.function_queries[755].get_mut(&inp[..]) { debug_assert_eq!(result.output, &__ret[..]); if !unconstrained { *result.multiplicity += G::ONE; } } else { record.function_queries[755].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained)); }; return Ok(__ret); }, _ => { @@ -64240,15 +63968,15 @@ fn aiur_fn_759( }) } -const INPUT_SIZE_760: usize = 1; -const IN_760: usize = 1; -const OUT_760: usize = 8; -fn aiur_fn_760( - inp: [G; IN_760], +const INPUT_SIZE_756: usize = 1; +const IN_756: usize = 1; +const OUT_756: usize = 8; +fn aiur_fn_756( + inp: [G; IN_756], record: &mut QueryRecord, io_buffer: &mut IOBuffer, unconstrained: bool, -) -> Result<[G; OUT_760], ExecError> { +) -> Result<[G; OUT_756], ExecError> { stacker::maybe_grow(64 * 1024, 4 * 1024 * 1024, || { let __v_0: G = inp[0]; let __loaded: [G; 3] = { let __mq = record.memory_queries.get_mut(&3).ok_or(ExecError::InvalidMemorySize(3))?; let __ptr_u64 = __v_0.as_canonical_u64(); let __ptr_usize = usize::try_from(__ptr_u64).ok().ok_or(ExecError::PointerTooLarge(__ptr_u64))?; let (__args, __mult) = __mq.get_index_mut(__ptr_usize).ok_or(ExecError::UnboundPointer { ptr: __ptr_u64, size: 3 })?; if !unconstrained { *__mult += G::ONE; } let __arr: [G; 3] = __args[..3].try_into().unwrap(); __arr }; @@ -64265,12 +63993,12 @@ fn aiur_fn_760( let __v_9: G = G::from_u64(0); let __v_10: G = G::from_u64(0); let __v_11: G = G::from_u64(0); - let __ret: [G; OUT_760] = [__v_4, __v_5, __v_6, __v_7, __v_8, __v_9, __v_10, __v_11]; - if let Some(result) = record.function_queries[760].get_mut(&inp[..]) { debug_assert_eq!(result.output, &__ret[..]); if !unconstrained { *result.multiplicity += G::ONE; } } else { record.function_queries[760].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained)); }; + let __ret: [G; OUT_756] = [__v_4, __v_5, __v_6, __v_7, __v_8, __v_9, __v_10, __v_11]; + if let Some(result) = record.function_queries[756].get_mut(&inp[..]) { debug_assert_eq!(result.output, &__ret[..]); if !unconstrained { *result.multiplicity += G::ONE; } } else { record.function_queries[756].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained)); }; return Ok(__ret); }, 0u64 => { - let __r_arr: [G; OUT_760] = { let __args: [G; IN_760] = [__v_3]; let __cu = unconstrained; if let Some(result) = record.function_queries[760].get_mut(&__args[..]) { if !__cu && *result.multiplicity == G::ZERO { aiur_fn_760(__args, record, io_buffer, false)? } else { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_760] = unsafe { *(result.output.as_ptr() as *const [G; OUT_760]) }; __ret } } else { aiur_fn_760(__args, record, io_buffer, __cu)? } }; + let __r_arr: [G; OUT_756] = { let __args: [G; IN_756] = [__v_3]; let __cu = unconstrained; if let Some(result) = record.function_queries[756].get_mut(&__args[..]) { if !__cu && *result.multiplicity == G::ZERO { aiur_fn_756(__args, record, io_buffer, false)? } else { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_756] = unsafe { *(result.output.as_ptr() as *const [G; OUT_756]) }; __ret } } else { aiur_fn_756(__args, record, io_buffer, __cu)? } }; let __v_4: G = __r_arr[0]; let __v_5: G = __r_arr[1]; let __v_6: G = __r_arr[2]; @@ -64288,8 +64016,8 @@ fn aiur_fn_760( let __v_17: G = __r_arr[5]; let __v_18: G = __r_arr[6]; let __v_19: G = __r_arr[7]; - let __ret: [G; OUT_760] = [__v_12, __v_13, __v_14, __v_15, __v_16, __v_17, __v_18, __v_19]; - if let Some(result) = record.function_queries[760].get_mut(&inp[..]) { debug_assert_eq!(result.output, &__ret[..]); if !unconstrained { *result.multiplicity += G::ONE; } } else { record.function_queries[760].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained)); }; + let __ret: [G; OUT_756] = [__v_12, __v_13, __v_14, __v_15, __v_16, __v_17, __v_18, __v_19]; + if let Some(result) = record.function_queries[756].get_mut(&inp[..]) { debug_assert_eq!(result.output, &__ret[..]); if !unconstrained { *result.multiplicity += G::ONE; } } else { record.function_queries[756].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained)); }; return Ok(__ret); }, _ => { @@ -64299,15 +64027,15 @@ fn aiur_fn_760( }) } -const INPUT_SIZE_761: usize = 8; -const IN_761: usize = 8; -const OUT_761: usize = 1; -fn aiur_fn_761( - inp: [G; IN_761], +const INPUT_SIZE_757: usize = 8; +const IN_757: usize = 8; +const OUT_757: usize = 1; +fn aiur_fn_757( + inp: [G; IN_757], record: &mut QueryRecord, io_buffer: &mut IOBuffer, unconstrained: bool, -) -> Result<[G; OUT_761], ExecError> { +) -> Result<[G; OUT_757], ExecError> { stacker::maybe_grow(64 * 1024, 4 * 1024 * 1024, || { let __v_0: G = inp[0]; let __v_1: G = inp[1]; @@ -64319,8 +64047,8 @@ fn aiur_fn_761( let __v_7: G = inp[7]; match __v_1.as_canonical_u64() { 1u64 => { - let __ret: [G; OUT_761] = [__v_7]; - if let Some(result) = record.function_queries[761].get_mut(&inp[..]) { debug_assert_eq!(result.output, &__ret[..]); if !unconstrained { *result.multiplicity += G::ONE; } } else { record.function_queries[761].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained)); }; + let __ret: [G; OUT_757] = [__v_7]; + if let Some(result) = record.function_queries[757].get_mut(&inp[..]) { debug_assert_eq!(result.output, &__ret[..]); if !unconstrained { *result.multiplicity += G::ONE; } } else { record.function_queries[757].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained)); }; return Ok(__ret); }, 0u64 => { @@ -64341,25 +64069,25 @@ fn aiur_fn_761( let __v_20: G = { let __a_val = __v_0.as_canonical_u64(); let __b_val = __v_3.as_canonical_u64(); let __a_u32 = u32::try_from(__a_val).ok().ok_or(ExecError::U32OutOfRange(__a_val))?; let __b_u32 = u32::try_from(__b_val).ok().ok_or(ExecError::U32OutOfRange(__b_val))?; let __result = G::from_bool(__a_u32 < __b_u32); if !unconstrained { let __x_bytes = __a_u32.to_le_bytes(); let __z_bytes = __b_u32.to_le_bytes(); let __c_u32 = __b_u32.wrapping_sub(__a_u32).wrapping_sub(1); let __y_bytes = __c_u32.to_le_bytes(); record.bytes2_queries.bump_range_check(&G::from_u8(__x_bytes[0]), &G::from_u8(__x_bytes[1])); record.bytes2_queries.bump_range_check(&G::from_u8(__x_bytes[2]), &G::from_u8(__x_bytes[3])); record.bytes2_queries.bump_range_check(&G::from_u8(__y_bytes[0]), &G::from_u8(__y_bytes[1])); record.bytes2_queries.bump_range_check(&G::from_u8(__y_bytes[2]), &G::from_u8(__y_bytes[3])); record.bytes2_queries.bump_range_check(&G::from_u8(__z_bytes[0]), &G::from_u8(__z_bytes[1])); record.bytes2_queries.bump_range_check(&G::from_u8(__z_bytes[2]), &G::from_u8(__z_bytes[3])); } __result }; match __v_20.as_canonical_u64() { 1u64 => { - let __r_arr: [G; OUT_761] = { let __args: [G; IN_761] = [__v_0, __v_8, __v_9, __v_10, __v_11, __v_12, __v_13, __v_7]; let __cu = unconstrained; if let Some(result) = record.function_queries[761].get_mut(&__args[..]) { if !__cu && *result.multiplicity == G::ZERO { aiur_fn_761(__args, record, io_buffer, false)? } else { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_761] = unsafe { *(result.output.as_ptr() as *const [G; OUT_761]) }; __ret } } else { aiur_fn_761(__args, record, io_buffer, __cu)? } }; + let __r_arr: [G; OUT_757] = { let __args: [G; IN_757] = [__v_0, __v_8, __v_9, __v_10, __v_11, __v_12, __v_13, __v_7]; let __cu = unconstrained; if let Some(result) = record.function_queries[757].get_mut(&__args[..]) { if !__cu && *result.multiplicity == G::ZERO { aiur_fn_757(__args, record, io_buffer, false)? } else { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_757] = unsafe { *(result.output.as_ptr() as *const [G; OUT_757]) }; __ret } } else { aiur_fn_757(__args, record, io_buffer, __cu)? } }; let __v_21: G = __r_arr[0]; - let __ret: [G; OUT_761] = [__v_21]; - if let Some(result) = record.function_queries[761].get_mut(&inp[..]) { debug_assert_eq!(result.output, &__ret[..]); if !unconstrained { *result.multiplicity += G::ONE; } } else { record.function_queries[761].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained)); }; + let __ret: [G; OUT_757] = [__v_21]; + if let Some(result) = record.function_queries[757].get_mut(&inp[..]) { debug_assert_eq!(result.output, &__ret[..]); if !unconstrained { *result.multiplicity += G::ONE; } } else { record.function_queries[757].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained)); }; return Ok(__ret); }, _ => { let __v_21: G = (__v_0 - __v_3); match __v_21.as_canonical_u64() { 0u64 => { - let __ret: [G; OUT_761] = [__v_4]; - if let Some(result) = record.function_queries[761].get_mut(&inp[..]) { debug_assert_eq!(result.output, &__ret[..]); if !unconstrained { *result.multiplicity += G::ONE; } } else { record.function_queries[761].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained)); }; + let __ret: [G; OUT_757] = [__v_4]; + if let Some(result) = record.function_queries[757].get_mut(&inp[..]) { debug_assert_eq!(result.output, &__ret[..]); if !unconstrained { *result.multiplicity += G::ONE; } } else { record.function_queries[757].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained)); }; return Ok(__ret); }, _ => { - let __r_arr: [G; OUT_761] = { let __args: [G; IN_761] = [__v_0, __v_14, __v_15, __v_16, __v_17, __v_18, __v_19, __v_7]; let __cu = unconstrained; if let Some(result) = record.function_queries[761].get_mut(&__args[..]) { if !__cu && *result.multiplicity == G::ZERO { aiur_fn_761(__args, record, io_buffer, false)? } else { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_761] = unsafe { *(result.output.as_ptr() as *const [G; OUT_761]) }; __ret } } else { aiur_fn_761(__args, record, io_buffer, __cu)? } }; + let __r_arr: [G; OUT_757] = { let __args: [G; IN_757] = [__v_0, __v_14, __v_15, __v_16, __v_17, __v_18, __v_19, __v_7]; let __cu = unconstrained; if let Some(result) = record.function_queries[757].get_mut(&__args[..]) { if !__cu && *result.multiplicity == G::ZERO { aiur_fn_757(__args, record, io_buffer, false)? } else { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_757] = unsafe { *(result.output.as_ptr() as *const [G; OUT_757]) }; __ret } } else { aiur_fn_757(__args, record, io_buffer, __cu)? } }; let __v_22: G = __r_arr[0]; - let __ret: [G; OUT_761] = [__v_22]; - if let Some(result) = record.function_queries[761].get_mut(&inp[..]) { debug_assert_eq!(result.output, &__ret[..]); if !unconstrained { *result.multiplicity += G::ONE; } } else { record.function_queries[761].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained)); }; + let __ret: [G; OUT_757] = [__v_22]; + if let Some(result) = record.function_queries[757].get_mut(&inp[..]) { debug_assert_eq!(result.output, &__ret[..]); if !unconstrained { *result.multiplicity += G::ONE; } } else { record.function_queries[757].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained)); }; return Ok(__ret); }, } @@ -64373,37 +64101,37 @@ fn aiur_fn_761( }) } -const INPUT_SIZE_762: usize = 1; -const IN_762: usize = 1; -const OUT_762: usize = 1; -fn aiur_fn_762( - inp: [G; IN_762], +const INPUT_SIZE_758: usize = 1; +const IN_758: usize = 1; +const OUT_758: usize = 1; +fn aiur_fn_758( + inp: [G; IN_758], record: &mut QueryRecord, io_buffer: &mut IOBuffer, unconstrained: bool, -) -> Result<[G; OUT_762], ExecError> { +) -> Result<[G; OUT_758], ExecError> { stacker::maybe_grow(64 * 1024, 4 * 1024 * 1024, || { let __v_0: G = inp[0]; let __v_1: G = G::from_u64(1); let __v_2: G = G::from_u64(1); let __v_3: G = { let __values: [G; 3] = [__v_1, __v_2, __v_2]; let __mq = record.memory_queries.get_mut(&3).ok_or(ExecError::InvalidMemorySize(3))?; if let Some(result) = __mq.get_mut(&__values[..]) { if !unconstrained { *result.multiplicity += G::ONE; } result.output[0] } else { let __ptr = G::from_usize(__mq.len()); __mq.insert(&__values[..], &[__ptr], G::from_bool(!unconstrained)); __ptr } }; - let __r_arr: [G; OUT_780] = { let __args: [G; IN_780] = [__v_0, __v_3]; let __cu = unconstrained; if let Some(result) = record.function_queries[780].get_mut(&__args[..]) { if !__cu && *result.multiplicity == G::ZERO { aiur_fn_780(__args, record, io_buffer, false)? } else { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_780] = unsafe { *(result.output.as_ptr() as *const [G; OUT_780]) }; __ret } } else { aiur_fn_780(__args, record, io_buffer, __cu)? } }; + let __r_arr: [G; OUT_776] = { let __args: [G; IN_776] = [__v_0, __v_3]; let __cu = unconstrained; if let Some(result) = record.function_queries[776].get_mut(&__args[..]) { if !__cu && *result.multiplicity == G::ZERO { aiur_fn_776(__args, record, io_buffer, false)? } else { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_776] = unsafe { *(result.output.as_ptr() as *const [G; OUT_776]) }; __ret } } else { aiur_fn_776(__args, record, io_buffer, __cu)? } }; let __v_4: G = __r_arr[0]; - let __ret: [G; OUT_762] = [__v_4]; - if let Some(result) = record.function_queries[762].get_mut(&inp[..]) { debug_assert_eq!(result.output, &__ret[..]); if !unconstrained { *result.multiplicity += G::ONE; } } else { record.function_queries[762].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained)); }; + let __ret: [G; OUT_758] = [__v_4]; + if let Some(result) = record.function_queries[758].get_mut(&inp[..]) { debug_assert_eq!(result.output, &__ret[..]); if !unconstrained { *result.multiplicity += G::ONE; } } else { record.function_queries[758].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained)); }; return Ok(__ret); }) } -const INPUT_SIZE_763: usize = 2; -const IN_763: usize = 2; -const OUT_763: usize = 1; -fn aiur_fn_763( - inp: [G; IN_763], +const INPUT_SIZE_759: usize = 2; +const IN_759: usize = 2; +const OUT_759: usize = 1; +fn aiur_fn_759( + inp: [G; IN_759], record: &mut QueryRecord, io_buffer: &mut IOBuffer, unconstrained: bool, -) -> Result<[G; OUT_763], ExecError> { +) -> Result<[G; OUT_759], ExecError> { stacker::maybe_grow(64 * 1024, 4 * 1024 * 1024, || { let __v_0: G = inp[0]; let __v_1: G = inp[1]; @@ -64413,17 +64141,17 @@ fn aiur_fn_763( let __v_4: G = __loaded[2]; match __v_2.as_canonical_u64() { 1u64 => { - let __ret: [G; OUT_763] = [__v_1]; - if let Some(result) = record.function_queries[763].get_mut(&inp[..]) { debug_assert_eq!(result.output, &__ret[..]); if !unconstrained { *result.multiplicity += G::ONE; } } else { record.function_queries[763].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained)); }; + let __ret: [G; OUT_759] = [__v_1]; + if let Some(result) = record.function_queries[759].get_mut(&inp[..]) { debug_assert_eq!(result.output, &__ret[..]); if !unconstrained { *result.multiplicity += G::ONE; } } else { record.function_queries[759].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained)); }; return Ok(__ret); }, 0u64 => { let __v_5: G = G::from_u64(0); - let __r_arr: [G; OUT_763] = { let __args: [G; IN_763] = [__v_4, __v_1]; let __cu = unconstrained; if let Some(result) = record.function_queries[763].get_mut(&__args[..]) { if !__cu && *result.multiplicity == G::ZERO { aiur_fn_763(__args, record, io_buffer, false)? } else { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_763] = unsafe { *(result.output.as_ptr() as *const [G; OUT_763]) }; __ret } } else { aiur_fn_763(__args, record, io_buffer, __cu)? } }; + let __r_arr: [G; OUT_759] = { let __args: [G; IN_759] = [__v_4, __v_1]; let __cu = unconstrained; if let Some(result) = record.function_queries[759].get_mut(&__args[..]) { if !__cu && *result.multiplicity == G::ZERO { aiur_fn_759(__args, record, io_buffer, false)? } else { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_759] = unsafe { *(result.output.as_ptr() as *const [G; OUT_759]) }; __ret } } else { aiur_fn_759(__args, record, io_buffer, __cu)? } }; let __v_6: G = __r_arr[0]; let __v_7: G = { let __values: [G; 3] = [__v_5, __v_3, __v_6]; let __mq = record.memory_queries.get_mut(&3).ok_or(ExecError::InvalidMemorySize(3))?; if let Some(result) = __mq.get_mut(&__values[..]) { if !unconstrained { *result.multiplicity += G::ONE; } result.output[0] } else { let __ptr = G::from_usize(__mq.len()); __mq.insert(&__values[..], &[__ptr], G::from_bool(!unconstrained)); __ptr } }; - let __ret: [G; OUT_763] = [__v_7]; - if let Some(result) = record.function_queries[763].get_mut(&inp[..]) { debug_assert_eq!(result.output, &__ret[..]); if !unconstrained { *result.multiplicity += G::ONE; } } else { record.function_queries[763].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained)); }; + let __ret: [G; OUT_759] = [__v_7]; + if let Some(result) = record.function_queries[759].get_mut(&inp[..]) { debug_assert_eq!(result.output, &__ret[..]); if !unconstrained { *result.multiplicity += G::ONE; } } else { record.function_queries[759].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained)); }; return Ok(__ret); }, _ => { @@ -64433,15 +64161,15 @@ fn aiur_fn_763( }) } -const INPUT_SIZE_764: usize = 1; -const IN_764: usize = 1; -const OUT_764: usize = 1; -fn aiur_fn_764( - inp: [G; IN_764], +const INPUT_SIZE_760: usize = 1; +const IN_760: usize = 1; +const OUT_760: usize = 1; +fn aiur_fn_760( + inp: [G; IN_760], record: &mut QueryRecord, io_buffer: &mut IOBuffer, unconstrained: bool, -) -> Result<[G; OUT_764], ExecError> { +) -> Result<[G; OUT_760], ExecError> { stacker::maybe_grow(64 * 1024, 4 * 1024 * 1024, || { let __v_0: G = inp[0]; let __loaded: [G; 3] = { let __mq = record.memory_queries.get_mut(&3).ok_or(ExecError::InvalidMemorySize(3))?; let __ptr_u64 = __v_0.as_canonical_u64(); let __ptr_usize = usize::try_from(__ptr_u64).ok().ok_or(ExecError::PointerTooLarge(__ptr_u64))?; let (__args, __mult) = __mq.get_index_mut(__ptr_usize).ok_or(ExecError::UnboundPointer { ptr: __ptr_u64, size: 3 })?; if !unconstrained { *__mult += G::ONE; } let __arr: [G; 3] = __args[..3].try_into().unwrap(); __arr }; @@ -64451,17 +64179,17 @@ fn aiur_fn_764( match __v_1.as_canonical_u64() { 1u64 => { let __v_4: G = G::from_u64(0); - let __ret: [G; OUT_764] = [__v_4]; - if let Some(result) = record.function_queries[764].get_mut(&inp[..]) { debug_assert_eq!(result.output, &__ret[..]); if !unconstrained { *result.multiplicity += G::ONE; } } else { record.function_queries[764].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained)); }; + let __ret: [G; OUT_760] = [__v_4]; + if let Some(result) = record.function_queries[760].get_mut(&inp[..]) { debug_assert_eq!(result.output, &__ret[..]); if !unconstrained { *result.multiplicity += G::ONE; } } else { record.function_queries[760].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained)); }; return Ok(__ret); }, 0u64 => { - let __r_arr: [G; OUT_764] = { let __args: [G; IN_764] = [__v_3]; let __cu = unconstrained; if let Some(result) = record.function_queries[764].get_mut(&__args[..]) { if !__cu && *result.multiplicity == G::ZERO { aiur_fn_764(__args, record, io_buffer, false)? } else { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_764] = unsafe { *(result.output.as_ptr() as *const [G; OUT_764]) }; __ret } } else { aiur_fn_764(__args, record, io_buffer, __cu)? } }; + let __r_arr: [G; OUT_760] = { let __args: [G; IN_760] = [__v_3]; let __cu = unconstrained; if let Some(result) = record.function_queries[760].get_mut(&__args[..]) { if !__cu && *result.multiplicity == G::ZERO { aiur_fn_760(__args, record, io_buffer, false)? } else { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_760] = unsafe { *(result.output.as_ptr() as *const [G; OUT_760]) }; __ret } } else { aiur_fn_760(__args, record, io_buffer, __cu)? } }; let __v_4: G = __r_arr[0]; let __v_5: G = G::from_u64(1); let __v_6: G = (__v_4 + __v_5); - let __ret: [G; OUT_764] = [__v_6]; - if let Some(result) = record.function_queries[764].get_mut(&inp[..]) { debug_assert_eq!(result.output, &__ret[..]); if !unconstrained { *result.multiplicity += G::ONE; } } else { record.function_queries[764].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained)); }; + let __ret: [G; OUT_760] = [__v_6]; + if let Some(result) = record.function_queries[760].get_mut(&inp[..]) { debug_assert_eq!(result.output, &__ret[..]); if !unconstrained { *result.multiplicity += G::ONE; } } else { record.function_queries[760].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained)); }; return Ok(__ret); }, _ => { @@ -64471,15 +64199,15 @@ fn aiur_fn_764( }) } -const INPUT_SIZE_765: usize = 1; -const IN_765: usize = 1; -const OUT_765: usize = 8; -fn aiur_fn_765( - inp: [G; IN_765], +const INPUT_SIZE_761: usize = 1; +const IN_761: usize = 1; +const OUT_761: usize = 8; +fn aiur_fn_761( + inp: [G; IN_761], record: &mut QueryRecord, io_buffer: &mut IOBuffer, unconstrained: bool, -) -> Result<[G; OUT_765], ExecError> { +) -> Result<[G; OUT_761], ExecError> { stacker::maybe_grow(64 * 1024, 4 * 1024 * 1024, || { let __v_0: G = inp[0]; let __loaded: [G; 36] = { let __mq = record.memory_queries.get_mut(&36).ok_or(ExecError::InvalidMemorySize(36))?; let __ptr_u64 = __v_0.as_canonical_u64(); let __ptr_usize = usize::try_from(__ptr_u64).ok().ok_or(ExecError::PointerTooLarge(__ptr_u64))?; let (__args, __mult) = __mq.get_index_mut(__ptr_usize).ok_or(ExecError::UnboundPointer { ptr: __ptr_u64, size: 36 })?; if !unconstrained { *__mult += G::ONE; } let __arr: [G; 36] = __args[..36].try_into().unwrap(); __arr }; @@ -64529,12 +64257,12 @@ fn aiur_fn_765( let __v_42: G = G::from_u64(0); let __v_43: G = G::from_u64(0); let __v_44: G = G::from_u64(0); - let __ret: [G; OUT_765] = [__v_37, __v_38, __v_39, __v_40, __v_41, __v_42, __v_43, __v_44]; - if let Some(result) = record.function_queries[765].get_mut(&inp[..]) { debug_assert_eq!(result.output, &__ret[..]); if !unconstrained { *result.multiplicity += G::ONE; } } else { record.function_queries[765].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained)); }; + let __ret: [G; OUT_761] = [__v_37, __v_38, __v_39, __v_40, __v_41, __v_42, __v_43, __v_44]; + if let Some(result) = record.function_queries[761].get_mut(&inp[..]) { debug_assert_eq!(result.output, &__ret[..]); if !unconstrained { *result.multiplicity += G::ONE; } } else { record.function_queries[761].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained)); }; return Ok(__ret); }, 0u64 => { - let __r_arr: [G; OUT_765] = { let __args: [G; IN_765] = [__v_36]; let __cu = unconstrained; if let Some(result) = record.function_queries[765].get_mut(&__args[..]) { if !__cu && *result.multiplicity == G::ZERO { aiur_fn_765(__args, record, io_buffer, false)? } else { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_765] = unsafe { *(result.output.as_ptr() as *const [G; OUT_765]) }; __ret } } else { aiur_fn_765(__args, record, io_buffer, __cu)? } }; + let __r_arr: [G; OUT_761] = { let __args: [G; IN_761] = [__v_36]; let __cu = unconstrained; if let Some(result) = record.function_queries[761].get_mut(&__args[..]) { if !__cu && *result.multiplicity == G::ZERO { aiur_fn_761(__args, record, io_buffer, false)? } else { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_761] = unsafe { *(result.output.as_ptr() as *const [G; OUT_761]) }; __ret } } else { aiur_fn_761(__args, record, io_buffer, __cu)? } }; let __v_37: G = __r_arr[0]; let __v_38: G = __r_arr[1]; let __v_39: G = __r_arr[2]; @@ -64552,8 +64280,8 @@ fn aiur_fn_765( let __v_50: G = __r_arr[5]; let __v_51: G = __r_arr[6]; let __v_52: G = __r_arr[7]; - let __ret: [G; OUT_765] = [__v_45, __v_46, __v_47, __v_48, __v_49, __v_50, __v_51, __v_52]; - if let Some(result) = record.function_queries[765].get_mut(&inp[..]) { debug_assert_eq!(result.output, &__ret[..]); if !unconstrained { *result.multiplicity += G::ONE; } } else { record.function_queries[765].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained)); }; + let __ret: [G; OUT_761] = [__v_45, __v_46, __v_47, __v_48, __v_49, __v_50, __v_51, __v_52]; + if let Some(result) = record.function_queries[761].get_mut(&inp[..]) { debug_assert_eq!(result.output, &__ret[..]); if !unconstrained { *result.multiplicity += G::ONE; } } else { record.function_queries[761].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained)); }; return Ok(__ret); }, _ => { @@ -64563,19 +64291,19 @@ fn aiur_fn_765( }) } -const INPUT_SIZE_766: usize = 2; -const IN_766: usize = 2; -const OUT_766: usize = 1; -fn aiur_fn_766( - inp: [G; IN_766], +const INPUT_SIZE_762: usize = 2; +const IN_762: usize = 2; +const OUT_762: usize = 1; +fn aiur_fn_762( + inp: [G; IN_762], record: &mut QueryRecord, io_buffer: &mut IOBuffer, unconstrained: bool, -) -> Result<[G; OUT_766], ExecError> { +) -> Result<[G; OUT_762], ExecError> { stacker::maybe_grow(64 * 1024, 4 * 1024 * 1024, || { let __v_0: G = inp[0]; let __v_1: G = inp[1]; - let __r_arr: [G; OUT_775] = { let __args: [G; IN_775] = [__v_0, __v_1]; let __cu = unconstrained; if let Some(result) = record.function_queries[775].get_mut(&__args[..]) { if !__cu && *result.multiplicity == G::ZERO { aiur_fn_775(__args, record, io_buffer, false)? } else { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_775] = unsafe { *(result.output.as_ptr() as *const [G; OUT_775]) }; __ret } } else { aiur_fn_775(__args, record, io_buffer, __cu)? } }; + let __r_arr: [G; OUT_771] = { let __args: [G; IN_771] = [__v_0, __v_1]; let __cu = unconstrained; if let Some(result) = record.function_queries[771].get_mut(&__args[..]) { if !__cu && *result.multiplicity == G::ZERO { aiur_fn_771(__args, record, io_buffer, false)? } else { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_771] = unsafe { *(result.output.as_ptr() as *const [G; OUT_771]) }; __ret } } else { aiur_fn_771(__args, record, io_buffer, __cu)? } }; let __v_2: G = __r_arr[0]; let __loaded: [G; 3] = { let __mq = record.memory_queries.get_mut(&3).ok_or(ExecError::InvalidMemorySize(3))?; let __ptr_u64 = __v_2.as_canonical_u64(); let __ptr_usize = usize::try_from(__ptr_u64).ok().ok_or(ExecError::PointerTooLarge(__ptr_u64))?; let (__args, __mult) = __mq.get_index_mut(__ptr_usize).ok_or(ExecError::UnboundPointer { ptr: __ptr_u64, size: 3 })?; if !unconstrained { *__mult += G::ONE; } let __arr: [G; 3] = __args[..3].try_into().unwrap(); __arr }; let __v_3: G = __loaded[0]; @@ -64583,8 +64311,8 @@ fn aiur_fn_766( let __v_5: G = __loaded[2]; match __v_3.as_canonical_u64() { 0u64 => { - let __ret: [G; OUT_766] = [__v_4]; - if let Some(result) = record.function_queries[766].get_mut(&inp[..]) { debug_assert_eq!(result.output, &__ret[..]); if !unconstrained { *result.multiplicity += G::ONE; } } else { record.function_queries[766].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained)); }; + let __ret: [G; OUT_762] = [__v_4]; + if let Some(result) = record.function_queries[762].get_mut(&inp[..]) { debug_assert_eq!(result.output, &__ret[..]); if !unconstrained { *result.multiplicity += G::ONE; } } else { record.function_queries[762].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained)); }; return Ok(__ret); }, _ => { @@ -64594,15 +64322,15 @@ fn aiur_fn_766( }) } -const INPUT_SIZE_767: usize = 1; -const IN_767: usize = 1; -const OUT_767: usize = 1; -fn aiur_fn_767( - inp: [G; IN_767], +const INPUT_SIZE_763: usize = 1; +const IN_763: usize = 1; +const OUT_763: usize = 1; +fn aiur_fn_763( + inp: [G; IN_763], record: &mut QueryRecord, io_buffer: &mut IOBuffer, unconstrained: bool, -) -> Result<[G; OUT_767], ExecError> { +) -> Result<[G; OUT_763], ExecError> { stacker::maybe_grow(64 * 1024, 4 * 1024 * 1024, || { let __v_0: G = inp[0]; let __loaded: [G; 10] = { let __mq = record.memory_queries.get_mut(&10).ok_or(ExecError::InvalidMemorySize(10))?; let __ptr_u64 = __v_0.as_canonical_u64(); let __ptr_usize = usize::try_from(__ptr_u64).ok().ok_or(ExecError::PointerTooLarge(__ptr_u64))?; let (__args, __mult) = __mq.get_index_mut(__ptr_usize).ok_or(ExecError::UnboundPointer { ptr: __ptr_u64, size: 10 })?; if !unconstrained { *__mult += G::ONE; } let __arr: [G; 10] = __args[..10].try_into().unwrap(); __arr }; @@ -64619,17 +64347,17 @@ fn aiur_fn_767( match __v_1.as_canonical_u64() { 1u64 => { let __v_11: G = G::from_u64(0); - let __ret: [G; OUT_767] = [__v_11]; - if let Some(result) = record.function_queries[767].get_mut(&inp[..]) { debug_assert_eq!(result.output, &__ret[..]); if !unconstrained { *result.multiplicity += G::ONE; } } else { record.function_queries[767].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained)); }; + let __ret: [G; OUT_763] = [__v_11]; + if let Some(result) = record.function_queries[763].get_mut(&inp[..]) { debug_assert_eq!(result.output, &__ret[..]); if !unconstrained { *result.multiplicity += G::ONE; } } else { record.function_queries[763].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained)); }; return Ok(__ret); }, 0u64 => { - let __r_arr: [G; OUT_767] = { let __args: [G; IN_767] = [__v_10]; let __cu = unconstrained; if let Some(result) = record.function_queries[767].get_mut(&__args[..]) { if !__cu && *result.multiplicity == G::ZERO { aiur_fn_767(__args, record, io_buffer, false)? } else { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_767] = unsafe { *(result.output.as_ptr() as *const [G; OUT_767]) }; __ret } } else { aiur_fn_767(__args, record, io_buffer, __cu)? } }; + let __r_arr: [G; OUT_763] = { let __args: [G; IN_763] = [__v_10]; let __cu = unconstrained; if let Some(result) = record.function_queries[763].get_mut(&__args[..]) { if !__cu && *result.multiplicity == G::ZERO { aiur_fn_763(__args, record, io_buffer, false)? } else { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_763] = unsafe { *(result.output.as_ptr() as *const [G; OUT_763]) }; __ret } } else { aiur_fn_763(__args, record, io_buffer, __cu)? } }; let __v_11: G = __r_arr[0]; let __v_12: G = G::from_u64(1); let __v_13: G = (__v_11 + __v_12); - let __ret: [G; OUT_767] = [__v_13]; - if let Some(result) = record.function_queries[767].get_mut(&inp[..]) { debug_assert_eq!(result.output, &__ret[..]); if !unconstrained { *result.multiplicity += G::ONE; } } else { record.function_queries[767].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained)); }; + let __ret: [G; OUT_763] = [__v_13]; + if let Some(result) = record.function_queries[763].get_mut(&inp[..]) { debug_assert_eq!(result.output, &__ret[..]); if !unconstrained { *result.multiplicity += G::ONE; } } else { record.function_queries[763].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained)); }; return Ok(__ret); }, _ => { @@ -64639,15 +64367,15 @@ fn aiur_fn_767( }) } -const INPUT_SIZE_768: usize = 9; -const IN_768: usize = 9; -const OUT_768: usize = 45; -fn aiur_fn_768( - inp: [G; IN_768], +const INPUT_SIZE_764: usize = 9; +const IN_764: usize = 9; +const OUT_764: usize = 45; +fn aiur_fn_764( + inp: [G; IN_764], record: &mut QueryRecord, io_buffer: &mut IOBuffer, unconstrained: bool, -) -> Result<[G; OUT_768], ExecError> { +) -> Result<[G; OUT_764], ExecError> { stacker::maybe_grow(64 * 1024, 4 * 1024 * 1024, || { let __v_0: G = inp[0]; let __v_1: G = inp[1]; @@ -64712,8 +64440,8 @@ fn aiur_fn_768( let __v_56: G = __r_arr[0]; match __v_56.as_canonical_u64() { 1u64 => { - let __ret: [G; OUT_768] = [__v_10, __v_11, __v_12, __v_13, __v_14, __v_15, __v_16, __v_17, __v_18, __v_19, __v_20, __v_21, __v_22, __v_23, __v_24, __v_25, __v_26, __v_27, __v_28, __v_29, __v_30, __v_31, __v_32, __v_33, __v_34, __v_35, __v_36, __v_37, __v_38, __v_39, __v_40, __v_41, __v_42, __v_43, __v_44, __v_45, __v_46, __v_47, __v_48, __v_49, __v_50, __v_51, __v_52, __v_53, __v_54]; - if let Some(result) = record.function_queries[768].get_mut(&inp[..]) { debug_assert_eq!(result.output, &__ret[..]); if !unconstrained { *result.multiplicity += G::ONE; } } else { record.function_queries[768].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained)); }; + let __ret: [G; OUT_764] = [__v_10, __v_11, __v_12, __v_13, __v_14, __v_15, __v_16, __v_17, __v_18, __v_19, __v_20, __v_21, __v_22, __v_23, __v_24, __v_25, __v_26, __v_27, __v_28, __v_29, __v_30, __v_31, __v_32, __v_33, __v_34, __v_35, __v_36, __v_37, __v_38, __v_39, __v_40, __v_41, __v_42, __v_43, __v_44, __v_45, __v_46, __v_47, __v_48, __v_49, __v_50, __v_51, __v_52, __v_53, __v_54]; + if let Some(result) = record.function_queries[764].get_mut(&inp[..]) { debug_assert_eq!(result.output, &__ret[..]); if !unconstrained { *result.multiplicity += G::ONE; } } else { record.function_queries[764].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained)); }; return Ok(__ret); }, 0u64 => { @@ -64726,7 +64454,7 @@ fn aiur_fn_768( let __v_62: G = __r_arr[5]; let __v_63: G = __r_arr[6]; let __v_64: G = __r_arr[7]; - let __r_arr: [G; OUT_768] = { let __args: [G; IN_768] = [__v_55, __v_57, __v_58, __v_59, __v_60, __v_61, __v_62, __v_63, __v_64]; let __cu = unconstrained; if let Some(result) = record.function_queries[768].get_mut(&__args[..]) { if !__cu && *result.multiplicity == G::ZERO { aiur_fn_768(__args, record, io_buffer, false)? } else { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_768] = unsafe { *(result.output.as_ptr() as *const [G; OUT_768]) }; __ret } } else { aiur_fn_768(__args, record, io_buffer, __cu)? } }; + let __r_arr: [G; OUT_764] = { let __args: [G; IN_764] = [__v_55, __v_57, __v_58, __v_59, __v_60, __v_61, __v_62, __v_63, __v_64]; let __cu = unconstrained; if let Some(result) = record.function_queries[764].get_mut(&__args[..]) { if !__cu && *result.multiplicity == G::ZERO { aiur_fn_764(__args, record, io_buffer, false)? } else { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_764] = unsafe { *(result.output.as_ptr() as *const [G; OUT_764]) }; __ret } } else { aiur_fn_764(__args, record, io_buffer, __cu)? } }; let __v_65: G = __r_arr[0]; let __v_66: G = __r_arr[1]; let __v_67: G = __r_arr[2]; @@ -64772,8 +64500,8 @@ fn aiur_fn_768( let __v_107: G = __r_arr[42]; let __v_108: G = __r_arr[43]; let __v_109: G = __r_arr[44]; - let __ret: [G; OUT_768] = [__v_65, __v_66, __v_67, __v_68, __v_69, __v_70, __v_71, __v_72, __v_73, __v_74, __v_75, __v_76, __v_77, __v_78, __v_79, __v_80, __v_81, __v_82, __v_83, __v_84, __v_85, __v_86, __v_87, __v_88, __v_89, __v_90, __v_91, __v_92, __v_93, __v_94, __v_95, __v_96, __v_97, __v_98, __v_99, __v_100, __v_101, __v_102, __v_103, __v_104, __v_105, __v_106, __v_107, __v_108, __v_109]; - if let Some(result) = record.function_queries[768].get_mut(&inp[..]) { debug_assert_eq!(result.output, &__ret[..]); if !unconstrained { *result.multiplicity += G::ONE; } } else { record.function_queries[768].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained)); }; + let __ret: [G; OUT_764] = [__v_65, __v_66, __v_67, __v_68, __v_69, __v_70, __v_71, __v_72, __v_73, __v_74, __v_75, __v_76, __v_77, __v_78, __v_79, __v_80, __v_81, __v_82, __v_83, __v_84, __v_85, __v_86, __v_87, __v_88, __v_89, __v_90, __v_91, __v_92, __v_93, __v_94, __v_95, __v_96, __v_97, __v_98, __v_99, __v_100, __v_101, __v_102, __v_103, __v_104, __v_105, __v_106, __v_107, __v_108, __v_109]; + if let Some(result) = record.function_queries[764].get_mut(&inp[..]) { debug_assert_eq!(result.output, &__ret[..]); if !unconstrained { *result.multiplicity += G::ONE; } } else { record.function_queries[764].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained)); }; return Ok(__ret); }, _ => { @@ -64788,15 +64516,15 @@ fn aiur_fn_768( }) } -const INPUT_SIZE_769: usize = 1; -const IN_769: usize = 1; -const OUT_769: usize = 8; -fn aiur_fn_769( - inp: [G; IN_769], +const INPUT_SIZE_765: usize = 1; +const IN_765: usize = 1; +const OUT_765: usize = 8; +fn aiur_fn_765( + inp: [G; IN_765], record: &mut QueryRecord, io_buffer: &mut IOBuffer, unconstrained: bool, -) -> Result<[G; OUT_769], ExecError> { +) -> Result<[G; OUT_765], ExecError> { stacker::maybe_grow(64 * 1024, 4 * 1024 * 1024, || { let __v_0: G = inp[0]; let __loaded: [G; 47] = { let __mq = record.memory_queries.get_mut(&47).ok_or(ExecError::InvalidMemorySize(47))?; let __ptr_u64 = __v_0.as_canonical_u64(); let __ptr_usize = usize::try_from(__ptr_u64).ok().ok_or(ExecError::PointerTooLarge(__ptr_u64))?; let (__args, __mult) = __mq.get_index_mut(__ptr_usize).ok_or(ExecError::UnboundPointer { ptr: __ptr_u64, size: 47 })?; if !unconstrained { *__mult += G::ONE; } let __arr: [G; 47] = __args[..47].try_into().unwrap(); __arr }; @@ -64857,12 +64585,12 @@ fn aiur_fn_769( let __v_53: G = G::from_u64(0); let __v_54: G = G::from_u64(0); let __v_55: G = G::from_u64(0); - let __ret: [G; OUT_769] = [__v_48, __v_49, __v_50, __v_51, __v_52, __v_53, __v_54, __v_55]; - if let Some(result) = record.function_queries[769].get_mut(&inp[..]) { debug_assert_eq!(result.output, &__ret[..]); if !unconstrained { *result.multiplicity += G::ONE; } } else { record.function_queries[769].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained)); }; + let __ret: [G; OUT_765] = [__v_48, __v_49, __v_50, __v_51, __v_52, __v_53, __v_54, __v_55]; + if let Some(result) = record.function_queries[765].get_mut(&inp[..]) { debug_assert_eq!(result.output, &__ret[..]); if !unconstrained { *result.multiplicity += G::ONE; } } else { record.function_queries[765].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained)); }; return Ok(__ret); }, 0u64 => { - let __r_arr: [G; OUT_769] = { let __args: [G; IN_769] = [__v_47]; let __cu = unconstrained; if let Some(result) = record.function_queries[769].get_mut(&__args[..]) { if !__cu && *result.multiplicity == G::ZERO { aiur_fn_769(__args, record, io_buffer, false)? } else { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_769] = unsafe { *(result.output.as_ptr() as *const [G; OUT_769]) }; __ret } } else { aiur_fn_769(__args, record, io_buffer, __cu)? } }; + let __r_arr: [G; OUT_765] = { let __args: [G; IN_765] = [__v_47]; let __cu = unconstrained; if let Some(result) = record.function_queries[765].get_mut(&__args[..]) { if !__cu && *result.multiplicity == G::ZERO { aiur_fn_765(__args, record, io_buffer, false)? } else { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_765] = unsafe { *(result.output.as_ptr() as *const [G; OUT_765]) }; __ret } } else { aiur_fn_765(__args, record, io_buffer, __cu)? } }; let __v_48: G = __r_arr[0]; let __v_49: G = __r_arr[1]; let __v_50: G = __r_arr[2]; @@ -64880,8 +64608,8 @@ fn aiur_fn_769( let __v_61: G = __r_arr[5]; let __v_62: G = __r_arr[6]; let __v_63: G = __r_arr[7]; - let __ret: [G; OUT_769] = [__v_56, __v_57, __v_58, __v_59, __v_60, __v_61, __v_62, __v_63]; - if let Some(result) = record.function_queries[769].get_mut(&inp[..]) { debug_assert_eq!(result.output, &__ret[..]); if !unconstrained { *result.multiplicity += G::ONE; } } else { record.function_queries[769].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained)); }; + let __ret: [G; OUT_765] = [__v_56, __v_57, __v_58, __v_59, __v_60, __v_61, __v_62, __v_63]; + if let Some(result) = record.function_queries[765].get_mut(&inp[..]) { debug_assert_eq!(result.output, &__ret[..]); if !unconstrained { *result.multiplicity += G::ONE; } } else { record.function_queries[765].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained)); }; return Ok(__ret); }, _ => { @@ -64891,15 +64619,15 @@ fn aiur_fn_769( }) } -const INPUT_SIZE_770: usize = 1; -const IN_770: usize = 1; -const OUT_770: usize = 8; -fn aiur_fn_770( - inp: [G; IN_770], +const INPUT_SIZE_766: usize = 1; +const IN_766: usize = 1; +const OUT_766: usize = 8; +fn aiur_fn_766( + inp: [G; IN_766], record: &mut QueryRecord, io_buffer: &mut IOBuffer, unconstrained: bool, -) -> Result<[G; OUT_770], ExecError> { +) -> Result<[G; OUT_766], ExecError> { stacker::maybe_grow(64 * 1024, 4 * 1024 * 1024, || { let __v_0: G = inp[0]; let __loaded: [G; 11] = { let __mq = record.memory_queries.get_mut(&11).ok_or(ExecError::InvalidMemorySize(11))?; let __ptr_u64 = __v_0.as_canonical_u64(); let __ptr_usize = usize::try_from(__ptr_u64).ok().ok_or(ExecError::PointerTooLarge(__ptr_u64))?; let (__args, __mult) = __mq.get_index_mut(__ptr_usize).ok_or(ExecError::UnboundPointer { ptr: __ptr_u64, size: 11 })?; if !unconstrained { *__mult += G::ONE; } let __arr: [G; 11] = __args[..11].try_into().unwrap(); __arr }; @@ -64924,12 +64652,12 @@ fn aiur_fn_770( let __v_17: G = G::from_u64(0); let __v_18: G = G::from_u64(0); let __v_19: G = G::from_u64(0); - let __ret: [G; OUT_770] = [__v_12, __v_13, __v_14, __v_15, __v_16, __v_17, __v_18, __v_19]; - if let Some(result) = record.function_queries[770].get_mut(&inp[..]) { debug_assert_eq!(result.output, &__ret[..]); if !unconstrained { *result.multiplicity += G::ONE; } } else { record.function_queries[770].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained)); }; + let __ret: [G; OUT_766] = [__v_12, __v_13, __v_14, __v_15, __v_16, __v_17, __v_18, __v_19]; + if let Some(result) = record.function_queries[766].get_mut(&inp[..]) { debug_assert_eq!(result.output, &__ret[..]); if !unconstrained { *result.multiplicity += G::ONE; } } else { record.function_queries[766].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained)); }; return Ok(__ret); }, 0u64 => { - let __r_arr: [G; OUT_770] = { let __args: [G; IN_770] = [__v_11]; let __cu = unconstrained; if let Some(result) = record.function_queries[770].get_mut(&__args[..]) { if !__cu && *result.multiplicity == G::ZERO { aiur_fn_770(__args, record, io_buffer, false)? } else { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_770] = unsafe { *(result.output.as_ptr() as *const [G; OUT_770]) }; __ret } } else { aiur_fn_770(__args, record, io_buffer, __cu)? } }; + let __r_arr: [G; OUT_766] = { let __args: [G; IN_766] = [__v_11]; let __cu = unconstrained; if let Some(result) = record.function_queries[766].get_mut(&__args[..]) { if !__cu && *result.multiplicity == G::ZERO { aiur_fn_766(__args, record, io_buffer, false)? } else { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_766] = unsafe { *(result.output.as_ptr() as *const [G; OUT_766]) }; __ret } } else { aiur_fn_766(__args, record, io_buffer, __cu)? } }; let __v_12: G = __r_arr[0]; let __v_13: G = __r_arr[1]; let __v_14: G = __r_arr[2]; @@ -64947,8 +64675,8 @@ fn aiur_fn_770( let __v_25: G = __r_arr[5]; let __v_26: G = __r_arr[6]; let __v_27: G = __r_arr[7]; - let __ret: [G; OUT_770] = [__v_20, __v_21, __v_22, __v_23, __v_24, __v_25, __v_26, __v_27]; - if let Some(result) = record.function_queries[770].get_mut(&inp[..]) { debug_assert_eq!(result.output, &__ret[..]); if !unconstrained { *result.multiplicity += G::ONE; } } else { record.function_queries[770].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained)); }; + let __ret: [G; OUT_766] = [__v_20, __v_21, __v_22, __v_23, __v_24, __v_25, __v_26, __v_27]; + if let Some(result) = record.function_queries[766].get_mut(&inp[..]) { debug_assert_eq!(result.output, &__ret[..]); if !unconstrained { *result.multiplicity += G::ONE; } } else { record.function_queries[766].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained)); }; return Ok(__ret); }, _ => { @@ -64958,15 +64686,15 @@ fn aiur_fn_770( }) } -const INPUT_SIZE_771: usize = 9; -const IN_771: usize = 9; -const OUT_771: usize = 34; -fn aiur_fn_771( - inp: [G; IN_771], +const INPUT_SIZE_767: usize = 9; +const IN_767: usize = 9; +const OUT_767: usize = 34; +fn aiur_fn_767( + inp: [G; IN_767], record: &mut QueryRecord, io_buffer: &mut IOBuffer, unconstrained: bool, -) -> Result<[G; OUT_771], ExecError> { +) -> Result<[G; OUT_767], ExecError> { stacker::maybe_grow(64 * 1024, 4 * 1024 * 1024, || { let __v_0: G = inp[0]; let __v_1: G = inp[1]; @@ -65020,8 +64748,8 @@ fn aiur_fn_771( let __v_45: G = __r_arr[0]; match __v_45.as_canonical_u64() { 1u64 => { - let __ret: [G; OUT_771] = [__v_10, __v_11, __v_12, __v_13, __v_14, __v_15, __v_16, __v_17, __v_18, __v_19, __v_20, __v_21, __v_22, __v_23, __v_24, __v_25, __v_26, __v_27, __v_28, __v_29, __v_30, __v_31, __v_32, __v_33, __v_34, __v_35, __v_36, __v_37, __v_38, __v_39, __v_40, __v_41, __v_42, __v_43]; - if let Some(result) = record.function_queries[771].get_mut(&inp[..]) { debug_assert_eq!(result.output, &__ret[..]); if !unconstrained { *result.multiplicity += G::ONE; } } else { record.function_queries[771].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained)); }; + let __ret: [G; OUT_767] = [__v_10, __v_11, __v_12, __v_13, __v_14, __v_15, __v_16, __v_17, __v_18, __v_19, __v_20, __v_21, __v_22, __v_23, __v_24, __v_25, __v_26, __v_27, __v_28, __v_29, __v_30, __v_31, __v_32, __v_33, __v_34, __v_35, __v_36, __v_37, __v_38, __v_39, __v_40, __v_41, __v_42, __v_43]; + if let Some(result) = record.function_queries[767].get_mut(&inp[..]) { debug_assert_eq!(result.output, &__ret[..]); if !unconstrained { *result.multiplicity += G::ONE; } } else { record.function_queries[767].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained)); }; return Ok(__ret); }, 0u64 => { @@ -65034,7 +64762,7 @@ fn aiur_fn_771( let __v_51: G = __r_arr[5]; let __v_52: G = __r_arr[6]; let __v_53: G = __r_arr[7]; - let __r_arr: [G; OUT_771] = { let __args: [G; IN_771] = [__v_44, __v_46, __v_47, __v_48, __v_49, __v_50, __v_51, __v_52, __v_53]; let __cu = unconstrained; if let Some(result) = record.function_queries[771].get_mut(&__args[..]) { if !__cu && *result.multiplicity == G::ZERO { aiur_fn_771(__args, record, io_buffer, false)? } else { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_771] = unsafe { *(result.output.as_ptr() as *const [G; OUT_771]) }; __ret } } else { aiur_fn_771(__args, record, io_buffer, __cu)? } }; + let __r_arr: [G; OUT_767] = { let __args: [G; IN_767] = [__v_44, __v_46, __v_47, __v_48, __v_49, __v_50, __v_51, __v_52, __v_53]; let __cu = unconstrained; if let Some(result) = record.function_queries[767].get_mut(&__args[..]) { if !__cu && *result.multiplicity == G::ZERO { aiur_fn_767(__args, record, io_buffer, false)? } else { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_767] = unsafe { *(result.output.as_ptr() as *const [G; OUT_767]) }; __ret } } else { aiur_fn_767(__args, record, io_buffer, __cu)? } }; let __v_54: G = __r_arr[0]; let __v_55: G = __r_arr[1]; let __v_56: G = __r_arr[2]; @@ -65069,8 +64797,8 @@ fn aiur_fn_771( let __v_85: G = __r_arr[31]; let __v_86: G = __r_arr[32]; let __v_87: G = __r_arr[33]; - let __ret: [G; OUT_771] = [__v_54, __v_55, __v_56, __v_57, __v_58, __v_59, __v_60, __v_61, __v_62, __v_63, __v_64, __v_65, __v_66, __v_67, __v_68, __v_69, __v_70, __v_71, __v_72, __v_73, __v_74, __v_75, __v_76, __v_77, __v_78, __v_79, __v_80, __v_81, __v_82, __v_83, __v_84, __v_85, __v_86, __v_87]; - if let Some(result) = record.function_queries[771].get_mut(&inp[..]) { debug_assert_eq!(result.output, &__ret[..]); if !unconstrained { *result.multiplicity += G::ONE; } } else { record.function_queries[771].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained)); }; + let __ret: [G; OUT_767] = [__v_54, __v_55, __v_56, __v_57, __v_58, __v_59, __v_60, __v_61, __v_62, __v_63, __v_64, __v_65, __v_66, __v_67, __v_68, __v_69, __v_70, __v_71, __v_72, __v_73, __v_74, __v_75, __v_76, __v_77, __v_78, __v_79, __v_80, __v_81, __v_82, __v_83, __v_84, __v_85, __v_86, __v_87]; + if let Some(result) = record.function_queries[767].get_mut(&inp[..]) { debug_assert_eq!(result.output, &__ret[..]); if !unconstrained { *result.multiplicity += G::ONE; } } else { record.function_queries[767].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained)); }; return Ok(__ret); }, _ => { @@ -65085,15 +64813,15 @@ fn aiur_fn_771( }) } -const INPUT_SIZE_772: usize = 1; -const IN_772: usize = 1; -const OUT_772: usize = 1; -fn aiur_fn_772( - inp: [G; IN_772], +const INPUT_SIZE_768: usize = 1; +const IN_768: usize = 1; +const OUT_768: usize = 1; +fn aiur_fn_768( + inp: [G; IN_768], record: &mut QueryRecord, io_buffer: &mut IOBuffer, unconstrained: bool, -) -> Result<[G; OUT_772], ExecError> { +) -> Result<[G; OUT_768], ExecError> { stacker::maybe_grow(64 * 1024, 4 * 1024 * 1024, || { let __v_0: G = inp[0]; let __loaded: [G; 3] = { let __mq = record.memory_queries.get_mut(&3).ok_or(ExecError::InvalidMemorySize(3))?; let __ptr_u64 = __v_0.as_canonical_u64(); let __ptr_usize = usize::try_from(__ptr_u64).ok().ok_or(ExecError::PointerTooLarge(__ptr_u64))?; let (__args, __mult) = __mq.get_index_mut(__ptr_usize).ok_or(ExecError::UnboundPointer { ptr: __ptr_u64, size: 3 })?; if !unconstrained { *__mult += G::ONE; } let __arr: [G; 3] = __args[..3].try_into().unwrap(); __arr }; @@ -65103,14 +64831,14 @@ fn aiur_fn_772( match __v_1.as_canonical_u64() { 1u64 => { let __v_4: G = G::from_u64(1); - let __ret: [G; OUT_772] = [__v_4]; - if let Some(result) = record.function_queries[772].get_mut(&inp[..]) { debug_assert_eq!(result.output, &__ret[..]); if !unconstrained { *result.multiplicity += G::ONE; } } else { record.function_queries[772].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained)); }; + let __ret: [G; OUT_768] = [__v_4]; + if let Some(result) = record.function_queries[768].get_mut(&inp[..]) { debug_assert_eq!(result.output, &__ret[..]); if !unconstrained { *result.multiplicity += G::ONE; } } else { record.function_queries[768].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained)); }; return Ok(__ret); }, 0u64 => { let __v_4: G = G::from_u64(0); - let __ret: [G; OUT_772] = [__v_4]; - if let Some(result) = record.function_queries[772].get_mut(&inp[..]) { debug_assert_eq!(result.output, &__ret[..]); if !unconstrained { *result.multiplicity += G::ONE; } } else { record.function_queries[772].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained)); }; + let __ret: [G; OUT_768] = [__v_4]; + if let Some(result) = record.function_queries[768].get_mut(&inp[..]) { debug_assert_eq!(result.output, &__ret[..]); if !unconstrained { *result.multiplicity += G::ONE; } } else { record.function_queries[768].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained)); }; return Ok(__ret); }, _ => { @@ -65120,15 +64848,15 @@ fn aiur_fn_772( }) } -const INPUT_SIZE_773: usize = 5; -const IN_773: usize = 5; -const OUT_773: usize = 1; -fn aiur_fn_773( - inp: [G; IN_773], +const INPUT_SIZE_769: usize = 5; +const IN_769: usize = 5; +const OUT_769: usize = 1; +fn aiur_fn_769( + inp: [G; IN_769], record: &mut QueryRecord, io_buffer: &mut IOBuffer, unconstrained: bool, -) -> Result<[G; OUT_773], ExecError> { +) -> Result<[G; OUT_769], ExecError> { stacker::maybe_grow(64 * 1024, 4 * 1024 * 1024, || { let __v_0: G = inp[0]; let __v_1: G = inp[1]; @@ -65149,17 +64877,17 @@ fn aiur_fn_773( let __v_13: G = G::from_u64(1); let __v_14: G = { let __values: [G; 6] = [__v_12, __v_13, __v_13, __v_13, __v_13, __v_13]; let __mq = record.memory_queries.get_mut(&6).ok_or(ExecError::InvalidMemorySize(6))?; if let Some(result) = __mq.get_mut(&__values[..]) { if !unconstrained { *result.multiplicity += G::ONE; } result.output[0] } else { let __ptr = G::from_usize(__mq.len()); __mq.insert(&__values[..], &[__ptr], G::from_bool(!unconstrained)); __ptr } }; let __v_15: G = { let __values: [G; 6] = [__v_11, __v_1, __v_2, __v_3, __v_4, __v_14]; let __mq = record.memory_queries.get_mut(&6).ok_or(ExecError::InvalidMemorySize(6))?; if let Some(result) = __mq.get_mut(&__values[..]) { if !unconstrained { *result.multiplicity += G::ONE; } result.output[0] } else { let __ptr = G::from_usize(__mq.len()); __mq.insert(&__values[..], &[__ptr], G::from_bool(!unconstrained)); __ptr } }; - let __ret: [G; OUT_773] = [__v_15]; - if let Some(result) = record.function_queries[773].get_mut(&inp[..]) { debug_assert_eq!(result.output, &__ret[..]); if !unconstrained { *result.multiplicity += G::ONE; } } else { record.function_queries[773].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained)); }; + let __ret: [G; OUT_769] = [__v_15]; + if let Some(result) = record.function_queries[769].get_mut(&inp[..]) { debug_assert_eq!(result.output, &__ret[..]); if !unconstrained { *result.multiplicity += G::ONE; } } else { record.function_queries[769].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained)); }; return Ok(__ret); }, 0u64 => { let __v_11: G = G::from_u64(0); - let __r_arr: [G; OUT_773] = { let __args: [G; IN_773] = [__v_10, __v_1, __v_2, __v_3, __v_4]; let __cu = unconstrained; if let Some(result) = record.function_queries[773].get_mut(&__args[..]) { if !__cu && *result.multiplicity == G::ZERO { aiur_fn_773(__args, record, io_buffer, false)? } else { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_773] = unsafe { *(result.output.as_ptr() as *const [G; OUT_773]) }; __ret } } else { aiur_fn_773(__args, record, io_buffer, __cu)? } }; + let __r_arr: [G; OUT_769] = { let __args: [G; IN_769] = [__v_10, __v_1, __v_2, __v_3, __v_4]; let __cu = unconstrained; if let Some(result) = record.function_queries[769].get_mut(&__args[..]) { if !__cu && *result.multiplicity == G::ZERO { aiur_fn_769(__args, record, io_buffer, false)? } else { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_769] = unsafe { *(result.output.as_ptr() as *const [G; OUT_769]) }; __ret } } else { aiur_fn_769(__args, record, io_buffer, __cu)? } }; let __v_12: G = __r_arr[0]; let __v_13: G = { let __values: [G; 6] = [__v_11, __v_6, __v_7, __v_8, __v_9, __v_12]; let __mq = record.memory_queries.get_mut(&6).ok_or(ExecError::InvalidMemorySize(6))?; if let Some(result) = __mq.get_mut(&__values[..]) { if !unconstrained { *result.multiplicity += G::ONE; } result.output[0] } else { let __ptr = G::from_usize(__mq.len()); __mq.insert(&__values[..], &[__ptr], G::from_bool(!unconstrained)); __ptr } }; - let __ret: [G; OUT_773] = [__v_13]; - if let Some(result) = record.function_queries[773].get_mut(&inp[..]) { debug_assert_eq!(result.output, &__ret[..]); if !unconstrained { *result.multiplicity += G::ONE; } } else { record.function_queries[773].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained)); }; + let __ret: [G; OUT_769] = [__v_13]; + if let Some(result) = record.function_queries[769].get_mut(&inp[..]) { debug_assert_eq!(result.output, &__ret[..]); if !unconstrained { *result.multiplicity += G::ONE; } } else { record.function_queries[769].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained)); }; return Ok(__ret); }, _ => { @@ -65169,15 +64897,15 @@ fn aiur_fn_773( }) } -const INPUT_SIZE_774: usize = 2; -const IN_774: usize = 2; -const OUT_774: usize = 1; -fn aiur_fn_774( - inp: [G; IN_774], +const INPUT_SIZE_770: usize = 2; +const IN_770: usize = 2; +const OUT_770: usize = 1; +fn aiur_fn_770( + inp: [G; IN_770], record: &mut QueryRecord, io_buffer: &mut IOBuffer, unconstrained: bool, -) -> Result<[G; OUT_774], ExecError> { +) -> Result<[G; OUT_770], ExecError> { stacker::maybe_grow(64 * 1024, 4 * 1024 * 1024, || { let __v_0: G = inp[0]; let __v_1: G = inp[1]; @@ -65186,8 +64914,8 @@ fn aiur_fn_774( let __v_2: G = G::from_u64(1); let __v_3: G = G::from_u64(1); let __v_4: G = { let __values: [G; 3] = [__v_2, __v_3, __v_3]; let __mq = record.memory_queries.get_mut(&3).ok_or(ExecError::InvalidMemorySize(3))?; if let Some(result) = __mq.get_mut(&__values[..]) { if !unconstrained { *result.multiplicity += G::ONE; } result.output[0] } else { let __ptr = G::from_usize(__mq.len()); __mq.insert(&__values[..], &[__ptr], G::from_bool(!unconstrained)); __ptr } }; - let __ret: [G; OUT_774] = [__v_4]; - if let Some(result) = record.function_queries[774].get_mut(&inp[..]) { debug_assert_eq!(result.output, &__ret[..]); if !unconstrained { *result.multiplicity += G::ONE; } } else { record.function_queries[774].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained)); }; + let __ret: [G; OUT_770] = [__v_4]; + if let Some(result) = record.function_queries[770].get_mut(&inp[..]) { debug_assert_eq!(result.output, &__ret[..]); if !unconstrained { *result.multiplicity += G::ONE; } } else { record.function_queries[770].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained)); }; return Ok(__ret); }, _ => { @@ -65200,11 +64928,11 @@ fn aiur_fn_774( let __v_5: G = G::from_u64(0); let __v_6: G = G::from_u64(1); let __v_7: G = (__v_1 - __v_6); - let __r_arr: [G; OUT_774] = { let __args: [G; IN_774] = [__v_4, __v_7]; let __cu = unconstrained; if let Some(result) = record.function_queries[774].get_mut(&__args[..]) { if !__cu && *result.multiplicity == G::ZERO { aiur_fn_774(__args, record, io_buffer, false)? } else { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_774] = unsafe { *(result.output.as_ptr() as *const [G; OUT_774]) }; __ret } } else { aiur_fn_774(__args, record, io_buffer, __cu)? } }; + let __r_arr: [G; OUT_770] = { let __args: [G; IN_770] = [__v_4, __v_7]; let __cu = unconstrained; if let Some(result) = record.function_queries[770].get_mut(&__args[..]) { if !__cu && *result.multiplicity == G::ZERO { aiur_fn_770(__args, record, io_buffer, false)? } else { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_770] = unsafe { *(result.output.as_ptr() as *const [G; OUT_770]) }; __ret } } else { aiur_fn_770(__args, record, io_buffer, __cu)? } }; let __v_8: G = __r_arr[0]; let __v_9: G = { let __values: [G; 3] = [__v_5, __v_3, __v_8]; let __mq = record.memory_queries.get_mut(&3).ok_or(ExecError::InvalidMemorySize(3))?; if let Some(result) = __mq.get_mut(&__values[..]) { if !unconstrained { *result.multiplicity += G::ONE; } result.output[0] } else { let __ptr = G::from_usize(__mq.len()); __mq.insert(&__values[..], &[__ptr], G::from_bool(!unconstrained)); __ptr } }; - let __ret: [G; OUT_774] = [__v_9]; - if let Some(result) = record.function_queries[774].get_mut(&inp[..]) { debug_assert_eq!(result.output, &__ret[..]); if !unconstrained { *result.multiplicity += G::ONE; } } else { record.function_queries[774].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained)); }; + let __ret: [G; OUT_770] = [__v_9]; + if let Some(result) = record.function_queries[770].get_mut(&inp[..]) { debug_assert_eq!(result.output, &__ret[..]); if !unconstrained { *result.multiplicity += G::ONE; } } else { record.function_queries[770].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained)); }; return Ok(__ret); }, _ => { @@ -65216,28 +64944,28 @@ fn aiur_fn_774( }) } -const INPUT_SIZE_775: usize = 2; -const IN_775: usize = 2; -const OUT_775: usize = 1; -fn aiur_fn_775( - inp: [G; IN_775], +const INPUT_SIZE_771: usize = 2; +const IN_771: usize = 2; +const OUT_771: usize = 1; +fn aiur_fn_771( + inp: [G; IN_771], record: &mut QueryRecord, io_buffer: &mut IOBuffer, unconstrained: bool, -) -> Result<[G; OUT_775], ExecError> { +) -> Result<[G; OUT_771], ExecError> { stacker::maybe_grow(64 * 1024, 4 * 1024 * 1024, || { let __v_0: G = inp[0]; let __v_1: G = inp[1]; match __v_1.as_canonical_u64() { 0u64 => { - let __ret: [G; OUT_775] = [__v_0]; - if let Some(result) = record.function_queries[775].get_mut(&inp[..]) { debug_assert_eq!(result.output, &__ret[..]); if !unconstrained { *result.multiplicity += G::ONE; } } else { record.function_queries[775].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained)); }; + let __ret: [G; OUT_771] = [__v_0]; + if let Some(result) = record.function_queries[771].get_mut(&inp[..]) { debug_assert_eq!(result.output, &__ret[..]); if !unconstrained { *result.multiplicity += G::ONE; } } else { record.function_queries[771].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained)); }; return Ok(__ret); }, _ => { let __v_2: G = G::from_u64(1); let __v_3: G = (__v_1 - __v_2); - let __r_arr: [G; OUT_775] = { let __args: [G; IN_775] = [__v_0, __v_3]; let __cu = unconstrained; if let Some(result) = record.function_queries[775].get_mut(&__args[..]) { if !__cu && *result.multiplicity == G::ZERO { aiur_fn_775(__args, record, io_buffer, false)? } else { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_775] = unsafe { *(result.output.as_ptr() as *const [G; OUT_775]) }; __ret } } else { aiur_fn_775(__args, record, io_buffer, __cu)? } }; + let __r_arr: [G; OUT_771] = { let __args: [G; IN_771] = [__v_0, __v_3]; let __cu = unconstrained; if let Some(result) = record.function_queries[771].get_mut(&__args[..]) { if !__cu && *result.multiplicity == G::ZERO { aiur_fn_771(__args, record, io_buffer, false)? } else { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_771] = unsafe { *(result.output.as_ptr() as *const [G; OUT_771]) }; __ret } } else { aiur_fn_771(__args, record, io_buffer, __cu)? } }; let __v_4: G = __r_arr[0]; let __loaded: [G; 3] = { let __mq = record.memory_queries.get_mut(&3).ok_or(ExecError::InvalidMemorySize(3))?; let __ptr_u64 = __v_4.as_canonical_u64(); let __ptr_usize = usize::try_from(__ptr_u64).ok().ok_or(ExecError::PointerTooLarge(__ptr_u64))?; let (__args, __mult) = __mq.get_index_mut(__ptr_usize).ok_or(ExecError::UnboundPointer { ptr: __ptr_u64, size: 3 })?; if !unconstrained { *__mult += G::ONE; } let __arr: [G; 3] = __args[..3].try_into().unwrap(); __arr }; let __v_5: G = __loaded[0]; @@ -65245,8 +64973,8 @@ fn aiur_fn_775( let __v_7: G = __loaded[2]; match __v_5.as_canonical_u64() { 0u64 => { - let __ret: [G; OUT_775] = [__v_7]; - if let Some(result) = record.function_queries[775].get_mut(&inp[..]) { debug_assert_eq!(result.output, &__ret[..]); if !unconstrained { *result.multiplicity += G::ONE; } } else { record.function_queries[775].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained)); }; + let __ret: [G; OUT_771] = [__v_7]; + if let Some(result) = record.function_queries[771].get_mut(&inp[..]) { debug_assert_eq!(result.output, &__ret[..]); if !unconstrained { *result.multiplicity += G::ONE; } } else { record.function_queries[771].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained)); }; return Ok(__ret); }, _ => { @@ -65258,15 +64986,15 @@ fn aiur_fn_775( }) } -const INPUT_SIZE_776: usize = 1; -const IN_776: usize = 1; -const OUT_776: usize = 1; -fn aiur_fn_776( - inp: [G; IN_776], +const INPUT_SIZE_772: usize = 1; +const IN_772: usize = 1; +const OUT_772: usize = 1; +fn aiur_fn_772( + inp: [G; IN_772], record: &mut QueryRecord, io_buffer: &mut IOBuffer, unconstrained: bool, -) -> Result<[G; OUT_776], ExecError> { +) -> Result<[G; OUT_772], ExecError> { stacker::maybe_grow(64 * 1024, 4 * 1024 * 1024, || { let __v_0: G = inp[0]; let __loaded: [G; 5] = { let __mq = record.memory_queries.get_mut(&5).ok_or(ExecError::InvalidMemorySize(5))?; let __ptr_u64 = __v_0.as_canonical_u64(); let __ptr_usize = usize::try_from(__ptr_u64).ok().ok_or(ExecError::PointerTooLarge(__ptr_u64))?; let (__args, __mult) = __mq.get_index_mut(__ptr_usize).ok_or(ExecError::UnboundPointer { ptr: __ptr_u64, size: 5 })?; if !unconstrained { *__mult += G::ONE; } let __arr: [G; 5] = __args[..5].try_into().unwrap(); __arr }; @@ -65278,17 +65006,17 @@ fn aiur_fn_776( match __v_1.as_canonical_u64() { 1u64 => { let __v_6: G = G::from_u64(0); - let __ret: [G; OUT_776] = [__v_6]; - if let Some(result) = record.function_queries[776].get_mut(&inp[..]) { debug_assert_eq!(result.output, &__ret[..]); if !unconstrained { *result.multiplicity += G::ONE; } } else { record.function_queries[776].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained)); }; + let __ret: [G; OUT_772] = [__v_6]; + if let Some(result) = record.function_queries[772].get_mut(&inp[..]) { debug_assert_eq!(result.output, &__ret[..]); if !unconstrained { *result.multiplicity += G::ONE; } } else { record.function_queries[772].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained)); }; return Ok(__ret); }, 0u64 => { - let __r_arr: [G; OUT_776] = { let __args: [G; IN_776] = [__v_5]; let __cu = unconstrained; if let Some(result) = record.function_queries[776].get_mut(&__args[..]) { if !__cu && *result.multiplicity == G::ZERO { aiur_fn_776(__args, record, io_buffer, false)? } else { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_776] = unsafe { *(result.output.as_ptr() as *const [G; OUT_776]) }; __ret } } else { aiur_fn_776(__args, record, io_buffer, __cu)? } }; + let __r_arr: [G; OUT_772] = { let __args: [G; IN_772] = [__v_5]; let __cu = unconstrained; if let Some(result) = record.function_queries[772].get_mut(&__args[..]) { if !__cu && *result.multiplicity == G::ZERO { aiur_fn_772(__args, record, io_buffer, false)? } else { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_772] = unsafe { *(result.output.as_ptr() as *const [G; OUT_772]) }; __ret } } else { aiur_fn_772(__args, record, io_buffer, __cu)? } }; let __v_6: G = __r_arr[0]; let __v_7: G = G::from_u64(1); let __v_8: G = (__v_6 + __v_7); - let __ret: [G; OUT_776] = [__v_8]; - if let Some(result) = record.function_queries[776].get_mut(&inp[..]) { debug_assert_eq!(result.output, &__ret[..]); if !unconstrained { *result.multiplicity += G::ONE; } } else { record.function_queries[776].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained)); }; + let __ret: [G; OUT_772] = [__v_8]; + if let Some(result) = record.function_queries[772].get_mut(&inp[..]) { debug_assert_eq!(result.output, &__ret[..]); if !unconstrained { *result.multiplicity += G::ONE; } } else { record.function_queries[772].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained)); }; return Ok(__ret); }, _ => { @@ -65298,15 +65026,15 @@ fn aiur_fn_776( }) } -const INPUT_SIZE_777: usize = 8; -const IN_777: usize = 8; -const OUT_777: usize = 6; -fn aiur_fn_777( - inp: [G; IN_777], +const INPUT_SIZE_773: usize = 8; +const IN_773: usize = 8; +const OUT_773: usize = 6; +fn aiur_fn_773( + inp: [G; IN_773], record: &mut QueryRecord, io_buffer: &mut IOBuffer, unconstrained: bool, -) -> Result<[G; OUT_777], ExecError> { +) -> Result<[G; OUT_773], ExecError> { stacker::maybe_grow(64 * 1024, 4 * 1024 * 1024, || { let __v_0: G = inp[0]; let __v_1: G = inp[1]; @@ -65316,7 +65044,7 @@ fn aiur_fn_777( let __v_5: G = inp[5]; let __v_6: G = inp[6]; let __v_7: G = inp[7]; - let __r_arr: [G; OUT_781] = { let __args: [G; IN_781] = [__v_0, __v_1, __v_2, __v_3, __v_4, __v_5, __v_6, __v_7]; let __cu = unconstrained; if let Some(result) = record.function_queries[781].get_mut(&__args[..]) { if !__cu && *result.multiplicity == G::ZERO { aiur_fn_781(__args, record, io_buffer, false)? } else { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_781] = unsafe { *(result.output.as_ptr() as *const [G; OUT_781]) }; __ret } } else { aiur_fn_781(__args, record, io_buffer, __cu)? } }; + let __r_arr: [G; OUT_777] = { let __args: [G; IN_777] = [__v_0, __v_1, __v_2, __v_3, __v_4, __v_5, __v_6, __v_7]; let __cu = unconstrained; if let Some(result) = record.function_queries[777].get_mut(&__args[..]) { if !__cu && *result.multiplicity == G::ZERO { aiur_fn_777(__args, record, io_buffer, false)? } else { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_777] = unsafe { *(result.output.as_ptr() as *const [G; OUT_777]) }; __ret } } else { aiur_fn_777(__args, record, io_buffer, __cu)? } }; let __v_8: G = __r_arr[0]; let __v_9: G = __r_arr[1]; let __v_10: G = __r_arr[2]; @@ -65327,8 +65055,8 @@ fn aiur_fn_777( 0u64 => { let __v_14: G = G::from_u64(0); let __v_15: G = G::from_u64(1); - let __ret: [G; OUT_777] = [__v_14, __v_15, __v_10, __v_11, __v_12, __v_13]; - if let Some(result) = record.function_queries[777].get_mut(&inp[..]) { debug_assert_eq!(result.output, &__ret[..]); if !unconstrained { *result.multiplicity += G::ONE; } } else { record.function_queries[777].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained)); }; + let __ret: [G; OUT_773] = [__v_14, __v_15, __v_10, __v_11, __v_12, __v_13]; + if let Some(result) = record.function_queries[773].get_mut(&inp[..]) { debug_assert_eq!(result.output, &__ret[..]); if !unconstrained { *result.multiplicity += G::ONE; } } else { record.function_queries[773].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained)); }; return Ok(__ret); }, _ => { @@ -65338,15 +65066,15 @@ fn aiur_fn_777( }) } -const INPUT_SIZE_778: usize = 9; -const IN_778: usize = 9; -const OUT_778: usize = 1; -fn aiur_fn_778( - inp: [G; IN_778], +const INPUT_SIZE_774: usize = 9; +const IN_774: usize = 9; +const OUT_774: usize = 1; +fn aiur_fn_774( + inp: [G; IN_774], record: &mut QueryRecord, io_buffer: &mut IOBuffer, unconstrained: bool, -) -> Result<[G; OUT_778], ExecError> { +) -> Result<[G; OUT_774], ExecError> { stacker::maybe_grow(64 * 1024, 4 * 1024 * 1024, || { let __v_0: G = inp[0]; let __v_1: G = inp[1]; @@ -65375,17 +65103,17 @@ fn aiur_fn_778( let __v_21: G = G::from_u64(1); let __v_22: G = { let __values: [G; 10] = [__v_20, __v_21, __v_21, __v_21, __v_21, __v_21, __v_21, __v_21, __v_21, __v_21]; let __mq = record.memory_queries.get_mut(&10).ok_or(ExecError::InvalidMemorySize(10))?; if let Some(result) = __mq.get_mut(&__values[..]) { if !unconstrained { *result.multiplicity += G::ONE; } result.output[0] } else { let __ptr = G::from_usize(__mq.len()); __mq.insert(&__values[..], &[__ptr], G::from_bool(!unconstrained)); __ptr } }; let __v_23: G = { let __values: [G; 10] = [__v_19, __v_1, __v_2, __v_3, __v_4, __v_5, __v_6, __v_7, __v_8, __v_22]; let __mq = record.memory_queries.get_mut(&10).ok_or(ExecError::InvalidMemorySize(10))?; if let Some(result) = __mq.get_mut(&__values[..]) { if !unconstrained { *result.multiplicity += G::ONE; } result.output[0] } else { let __ptr = G::from_usize(__mq.len()); __mq.insert(&__values[..], &[__ptr], G::from_bool(!unconstrained)); __ptr } }; - let __ret: [G; OUT_778] = [__v_23]; - if let Some(result) = record.function_queries[778].get_mut(&inp[..]) { debug_assert_eq!(result.output, &__ret[..]); if !unconstrained { *result.multiplicity += G::ONE; } } else { record.function_queries[778].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained)); }; + let __ret: [G; OUT_774] = [__v_23]; + if let Some(result) = record.function_queries[774].get_mut(&inp[..]) { debug_assert_eq!(result.output, &__ret[..]); if !unconstrained { *result.multiplicity += G::ONE; } } else { record.function_queries[774].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained)); }; return Ok(__ret); }, 0u64 => { let __v_19: G = G::from_u64(0); - let __r_arr: [G; OUT_778] = { let __args: [G; IN_778] = [__v_18, __v_1, __v_2, __v_3, __v_4, __v_5, __v_6, __v_7, __v_8]; let __cu = unconstrained; if let Some(result) = record.function_queries[778].get_mut(&__args[..]) { if !__cu && *result.multiplicity == G::ZERO { aiur_fn_778(__args, record, io_buffer, false)? } else { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_778] = unsafe { *(result.output.as_ptr() as *const [G; OUT_778]) }; __ret } } else { aiur_fn_778(__args, record, io_buffer, __cu)? } }; + let __r_arr: [G; OUT_774] = { let __args: [G; IN_774] = [__v_18, __v_1, __v_2, __v_3, __v_4, __v_5, __v_6, __v_7, __v_8]; let __cu = unconstrained; if let Some(result) = record.function_queries[774].get_mut(&__args[..]) { if !__cu && *result.multiplicity == G::ZERO { aiur_fn_774(__args, record, io_buffer, false)? } else { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_774] = unsafe { *(result.output.as_ptr() as *const [G; OUT_774]) }; __ret } } else { aiur_fn_774(__args, record, io_buffer, __cu)? } }; let __v_20: G = __r_arr[0]; let __v_21: G = { let __values: [G; 10] = [__v_19, __v_10, __v_11, __v_12, __v_13, __v_14, __v_15, __v_16, __v_17, __v_20]; let __mq = record.memory_queries.get_mut(&10).ok_or(ExecError::InvalidMemorySize(10))?; if let Some(result) = __mq.get_mut(&__values[..]) { if !unconstrained { *result.multiplicity += G::ONE; } result.output[0] } else { let __ptr = G::from_usize(__mq.len()); __mq.insert(&__values[..], &[__ptr], G::from_bool(!unconstrained)); __ptr } }; - let __ret: [G; OUT_778] = [__v_21]; - if let Some(result) = record.function_queries[778].get_mut(&inp[..]) { debug_assert_eq!(result.output, &__ret[..]); if !unconstrained { *result.multiplicity += G::ONE; } } else { record.function_queries[778].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained)); }; + let __ret: [G; OUT_774] = [__v_21]; + if let Some(result) = record.function_queries[774].get_mut(&inp[..]) { debug_assert_eq!(result.output, &__ret[..]); if !unconstrained { *result.multiplicity += G::ONE; } } else { record.function_queries[774].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained)); }; return Ok(__ret); }, _ => { @@ -65395,15 +65123,15 @@ fn aiur_fn_778( }) } -const INPUT_SIZE_779: usize = 1; -const IN_779: usize = 1; -const OUT_779: usize = 1; -fn aiur_fn_779( - inp: [G; IN_779], +const INPUT_SIZE_775: usize = 1; +const IN_775: usize = 1; +const OUT_775: usize = 1; +fn aiur_fn_775( + inp: [G; IN_775], record: &mut QueryRecord, io_buffer: &mut IOBuffer, unconstrained: bool, -) -> Result<[G; OUT_779], ExecError> { +) -> Result<[G; OUT_775], ExecError> { stacker::maybe_grow(64 * 1024, 4 * 1024 * 1024, || { let __v_0: G = inp[0]; let __loaded: [G; 6] = { let __mq = record.memory_queries.get_mut(&6).ok_or(ExecError::InvalidMemorySize(6))?; let __ptr_u64 = __v_0.as_canonical_u64(); let __ptr_usize = usize::try_from(__ptr_u64).ok().ok_or(ExecError::PointerTooLarge(__ptr_u64))?; let (__args, __mult) = __mq.get_index_mut(__ptr_usize).ok_or(ExecError::UnboundPointer { ptr: __ptr_u64, size: 6 })?; if !unconstrained { *__mult += G::ONE; } let __arr: [G; 6] = __args[..6].try_into().unwrap(); __arr }; @@ -65416,17 +65144,17 @@ fn aiur_fn_779( match __v_1.as_canonical_u64() { 1u64 => { let __v_7: G = G::from_u64(0); - let __ret: [G; OUT_779] = [__v_7]; - if let Some(result) = record.function_queries[779].get_mut(&inp[..]) { debug_assert_eq!(result.output, &__ret[..]); if !unconstrained { *result.multiplicity += G::ONE; } } else { record.function_queries[779].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained)); }; + let __ret: [G; OUT_775] = [__v_7]; + if let Some(result) = record.function_queries[775].get_mut(&inp[..]) { debug_assert_eq!(result.output, &__ret[..]); if !unconstrained { *result.multiplicity += G::ONE; } } else { record.function_queries[775].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained)); }; return Ok(__ret); }, 0u64 => { - let __r_arr: [G; OUT_779] = { let __args: [G; IN_779] = [__v_6]; let __cu = unconstrained; if let Some(result) = record.function_queries[779].get_mut(&__args[..]) { if !__cu && *result.multiplicity == G::ZERO { aiur_fn_779(__args, record, io_buffer, false)? } else { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_779] = unsafe { *(result.output.as_ptr() as *const [G; OUT_779]) }; __ret } } else { aiur_fn_779(__args, record, io_buffer, __cu)? } }; + let __r_arr: [G; OUT_775] = { let __args: [G; IN_775] = [__v_6]; let __cu = unconstrained; if let Some(result) = record.function_queries[775].get_mut(&__args[..]) { if !__cu && *result.multiplicity == G::ZERO { aiur_fn_775(__args, record, io_buffer, false)? } else { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_775] = unsafe { *(result.output.as_ptr() as *const [G; OUT_775]) }; __ret } } else { aiur_fn_775(__args, record, io_buffer, __cu)? } }; let __v_7: G = __r_arr[0]; let __v_8: G = G::from_u64(1); let __v_9: G = (__v_7 + __v_8); - let __ret: [G; OUT_779] = [__v_9]; - if let Some(result) = record.function_queries[779].get_mut(&inp[..]) { debug_assert_eq!(result.output, &__ret[..]); if !unconstrained { *result.multiplicity += G::ONE; } } else { record.function_queries[779].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained)); }; + let __ret: [G; OUT_775] = [__v_9]; + if let Some(result) = record.function_queries[775].get_mut(&inp[..]) { debug_assert_eq!(result.output, &__ret[..]); if !unconstrained { *result.multiplicity += G::ONE; } } else { record.function_queries[775].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained)); }; return Ok(__ret); }, _ => { @@ -65436,15 +65164,15 @@ fn aiur_fn_779( }) } -const INPUT_SIZE_780: usize = 2; -const IN_780: usize = 2; -const OUT_780: usize = 1; -fn aiur_fn_780( - inp: [G; IN_780], +const INPUT_SIZE_776: usize = 2; +const IN_776: usize = 2; +const OUT_776: usize = 1; +fn aiur_fn_776( + inp: [G; IN_776], record: &mut QueryRecord, io_buffer: &mut IOBuffer, unconstrained: bool, -) -> Result<[G; OUT_780], ExecError> { +) -> Result<[G; OUT_776], ExecError> { stacker::maybe_grow(64 * 1024, 4 * 1024 * 1024, || { let __v_0: G = inp[0]; let __v_1: G = inp[1]; @@ -65454,17 +65182,17 @@ fn aiur_fn_780( let __v_4: G = __loaded[2]; match __v_2.as_canonical_u64() { 1u64 => { - let __ret: [G; OUT_780] = [__v_1]; - if let Some(result) = record.function_queries[780].get_mut(&inp[..]) { debug_assert_eq!(result.output, &__ret[..]); if !unconstrained { *result.multiplicity += G::ONE; } } else { record.function_queries[780].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained)); }; + let __ret: [G; OUT_776] = [__v_1]; + if let Some(result) = record.function_queries[776].get_mut(&inp[..]) { debug_assert_eq!(result.output, &__ret[..]); if !unconstrained { *result.multiplicity += G::ONE; } } else { record.function_queries[776].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained)); }; return Ok(__ret); }, 0u64 => { let __v_5: G = G::from_u64(0); let __v_6: G = { let __values: [G; 3] = [__v_5, __v_3, __v_1]; let __mq = record.memory_queries.get_mut(&3).ok_or(ExecError::InvalidMemorySize(3))?; if let Some(result) = __mq.get_mut(&__values[..]) { if !unconstrained { *result.multiplicity += G::ONE; } result.output[0] } else { let __ptr = G::from_usize(__mq.len()); __mq.insert(&__values[..], &[__ptr], G::from_bool(!unconstrained)); __ptr } }; - let __r_arr: [G; OUT_780] = { let __args: [G; IN_780] = [__v_4, __v_6]; let __cu = unconstrained; if let Some(result) = record.function_queries[780].get_mut(&__args[..]) { if !__cu && *result.multiplicity == G::ZERO { aiur_fn_780(__args, record, io_buffer, false)? } else { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_780] = unsafe { *(result.output.as_ptr() as *const [G; OUT_780]) }; __ret } } else { aiur_fn_780(__args, record, io_buffer, __cu)? } }; + let __r_arr: [G; OUT_776] = { let __args: [G; IN_776] = [__v_4, __v_6]; let __cu = unconstrained; if let Some(result) = record.function_queries[776].get_mut(&__args[..]) { if !__cu && *result.multiplicity == G::ZERO { aiur_fn_776(__args, record, io_buffer, false)? } else { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_776] = unsafe { *(result.output.as_ptr() as *const [G; OUT_776]) }; __ret } } else { aiur_fn_776(__args, record, io_buffer, __cu)? } }; let __v_7: G = __r_arr[0]; - let __ret: [G; OUT_780] = [__v_7]; - if let Some(result) = record.function_queries[780].get_mut(&inp[..]) { debug_assert_eq!(result.output, &__ret[..]); if !unconstrained { *result.multiplicity += G::ONE; } } else { record.function_queries[780].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained)); }; + let __ret: [G; OUT_776] = [__v_7]; + if let Some(result) = record.function_queries[776].get_mut(&inp[..]) { debug_assert_eq!(result.output, &__ret[..]); if !unconstrained { *result.multiplicity += G::ONE; } } else { record.function_queries[776].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained)); }; return Ok(__ret); }, _ => { @@ -65474,15 +65202,15 @@ fn aiur_fn_780( }) } -const INPUT_SIZE_781: usize = 8; -const IN_781: usize = 8; -const OUT_781: usize = 6; -fn aiur_fn_781( - inp: [G; IN_781], +const INPUT_SIZE_777: usize = 8; +const IN_777: usize = 8; +const OUT_777: usize = 6; +fn aiur_fn_777( + inp: [G; IN_777], record: &mut QueryRecord, io_buffer: &mut IOBuffer, unconstrained: bool, -) -> Result<[G; OUT_781], ExecError> { +) -> Result<[G; OUT_777], ExecError> { stacker::maybe_grow(64 * 1024, 4 * 1024 * 1024, || { let __v_0: G = inp[0]; let __v_1: G = inp[1]; @@ -65502,8 +65230,8 @@ fn aiur_fn_781( let __v_13: G = G::from_u64(1); let __v_14: G = G::from_u64(1); let __v_15: G = { let __values: [G; 6] = [__v_13, __v_14, __v_14, __v_14, __v_14, __v_14]; let __mq = record.memory_queries.get_mut(&6).ok_or(ExecError::InvalidMemorySize(6))?; if let Some(result) = __mq.get_mut(&__values[..]) { if !unconstrained { *result.multiplicity += G::ONE; } result.output[0] } else { let __ptr = G::from_usize(__mq.len()); __mq.insert(&__values[..], &[__ptr], G::from_bool(!unconstrained)); __ptr } }; - let __ret: [G; OUT_781] = [__v_8, __v_9, __v_0, __v_1, __v_12, __v_15]; - if let Some(result) = record.function_queries[781].get_mut(&inp[..]) { debug_assert_eq!(result.output, &__ret[..]); if !unconstrained { *result.multiplicity += G::ONE; } } else { record.function_queries[781].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained)); }; + let __ret: [G; OUT_777] = [__v_8, __v_9, __v_0, __v_1, __v_12, __v_15]; + if let Some(result) = record.function_queries[777].get_mut(&inp[..]) { debug_assert_eq!(result.output, &__ret[..]); if !unconstrained { *result.multiplicity += G::ONE; } } else { record.function_queries[777].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained)); }; return Ok(__ret); }, 0u64 => { @@ -65524,22 +65252,22 @@ fn aiur_fn_781( let __v_20: G = { let __a_val = __v_0.as_canonical_u64(); let __b_val = __v_4.as_canonical_u64(); let __a_u32 = u32::try_from(__a_val).ok().ok_or(ExecError::U32OutOfRange(__a_val))?; let __b_u32 = u32::try_from(__b_val).ok().ok_or(ExecError::U32OutOfRange(__b_val))?; let __result = G::from_bool(__a_u32 < __b_u32); if !unconstrained { let __x_bytes = __a_u32.to_le_bytes(); let __z_bytes = __b_u32.to_le_bytes(); let __c_u32 = __b_u32.wrapping_sub(__a_u32).wrapping_sub(1); let __y_bytes = __c_u32.to_le_bytes(); record.bytes2_queries.bump_range_check(&G::from_u8(__x_bytes[0]), &G::from_u8(__x_bytes[1])); record.bytes2_queries.bump_range_check(&G::from_u8(__x_bytes[2]), &G::from_u8(__x_bytes[3])); record.bytes2_queries.bump_range_check(&G::from_u8(__y_bytes[0]), &G::from_u8(__y_bytes[1])); record.bytes2_queries.bump_range_check(&G::from_u8(__y_bytes[2]), &G::from_u8(__y_bytes[3])); record.bytes2_queries.bump_range_check(&G::from_u8(__z_bytes[0]), &G::from_u8(__z_bytes[1])); record.bytes2_queries.bump_range_check(&G::from_u8(__z_bytes[2]), &G::from_u8(__z_bytes[3])); } __result }; match __v_20.as_canonical_u64() { 1u64 => { - let __r_arr: [G; OUT_781] = { let __args: [G; IN_781] = [__v_0, __v_1, __v_8, __v_9, __v_10, __v_11, __v_12, __v_13]; let __cu = unconstrained; if let Some(result) = record.function_queries[781].get_mut(&__args[..]) { if !__cu && *result.multiplicity == G::ZERO { aiur_fn_781(__args, record, io_buffer, false)? } else { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_781] = unsafe { *(result.output.as_ptr() as *const [G; OUT_781]) }; __ret } } else { aiur_fn_781(__args, record, io_buffer, __cu)? } }; + let __r_arr: [G; OUT_777] = { let __args: [G; IN_777] = [__v_0, __v_1, __v_8, __v_9, __v_10, __v_11, __v_12, __v_13]; let __cu = unconstrained; if let Some(result) = record.function_queries[777].get_mut(&__args[..]) { if !__cu && *result.multiplicity == G::ZERO { aiur_fn_777(__args, record, io_buffer, false)? } else { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_777] = unsafe { *(result.output.as_ptr() as *const [G; OUT_777]) }; __ret } } else { aiur_fn_777(__args, record, io_buffer, __cu)? } }; let __v_21: G = __r_arr[0]; let __v_22: G = __r_arr[1]; let __v_23: G = __r_arr[2]; let __v_24: G = __r_arr[3]; let __v_25: G = __r_arr[4]; let __v_26: G = __r_arr[5]; - let __r_arr: [G; OUT_782] = { let __args: [G; IN_782] = [__v_3, __v_4, __v_5, __v_21, __v_22, __v_23, __v_24, __v_25, __v_26, __v_14, __v_15, __v_16, __v_17, __v_18, __v_19]; let __cu = unconstrained; if let Some(result) = record.function_queries[782].get_mut(&__args[..]) { if !__cu && *result.multiplicity == G::ZERO { aiur_fn_782(__args, record, io_buffer, false)? } else { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_782] = unsafe { *(result.output.as_ptr() as *const [G; OUT_782]) }; __ret } } else { aiur_fn_782(__args, record, io_buffer, __cu)? } }; + let __r_arr: [G; OUT_778] = { let __args: [G; IN_778] = [__v_3, __v_4, __v_5, __v_21, __v_22, __v_23, __v_24, __v_25, __v_26, __v_14, __v_15, __v_16, __v_17, __v_18, __v_19]; let __cu = unconstrained; if let Some(result) = record.function_queries[778].get_mut(&__args[..]) { if !__cu && *result.multiplicity == G::ZERO { aiur_fn_778(__args, record, io_buffer, false)? } else { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_778] = unsafe { *(result.output.as_ptr() as *const [G; OUT_778]) }; __ret } } else { aiur_fn_778(__args, record, io_buffer, __cu)? } }; let __v_27: G = __r_arr[0]; let __v_28: G = __r_arr[1]; let __v_29: G = __r_arr[2]; let __v_30: G = __r_arr[3]; let __v_31: G = __r_arr[4]; let __v_32: G = __r_arr[5]; - let __ret: [G; OUT_781] = [__v_27, __v_28, __v_29, __v_30, __v_31, __v_32]; - if let Some(result) = record.function_queries[781].get_mut(&inp[..]) { debug_assert_eq!(result.output, &__ret[..]); if !unconstrained { *result.multiplicity += G::ONE; } } else { record.function_queries[781].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained)); }; + let __ret: [G; OUT_777] = [__v_27, __v_28, __v_29, __v_30, __v_31, __v_32]; + if let Some(result) = record.function_queries[777].get_mut(&inp[..]) { debug_assert_eq!(result.output, &__ret[..]); if !unconstrained { *result.multiplicity += G::ONE; } } else { record.function_queries[777].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained)); }; return Ok(__ret); }, _ => { @@ -65549,27 +65277,27 @@ fn aiur_fn_781( let __v_22: G = G::from_u64(0); let __v_23: G = { let __values: [G; 6] = [__v_8, __v_9, __v_10, __v_11, __v_12, __v_13]; let __mq = record.memory_queries.get_mut(&6).ok_or(ExecError::InvalidMemorySize(6))?; if let Some(result) = __mq.get_mut(&__values[..]) { if !unconstrained { *result.multiplicity += G::ONE; } result.output[0] } else { let __ptr = G::from_usize(__mq.len()); __mq.insert(&__values[..], &[__ptr], G::from_bool(!unconstrained)); __ptr } }; let __v_24: G = { let __values: [G; 6] = [__v_14, __v_15, __v_16, __v_17, __v_18, __v_19]; let __mq = record.memory_queries.get_mut(&6).ok_or(ExecError::InvalidMemorySize(6))?; if let Some(result) = __mq.get_mut(&__values[..]) { if !unconstrained { *result.multiplicity += G::ONE; } result.output[0] } else { let __ptr = G::from_usize(__mq.len()); __mq.insert(&__values[..], &[__ptr], G::from_bool(!unconstrained)); __ptr } }; - let __ret: [G; OUT_781] = [__v_22, __v_3, __v_0, __v_1, __v_23, __v_24]; - if let Some(result) = record.function_queries[781].get_mut(&inp[..]) { debug_assert_eq!(result.output, &__ret[..]); if !unconstrained { *result.multiplicity += G::ONE; } } else { record.function_queries[781].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained)); }; + let __ret: [G; OUT_777] = [__v_22, __v_3, __v_0, __v_1, __v_23, __v_24]; + if let Some(result) = record.function_queries[777].get_mut(&inp[..]) { debug_assert_eq!(result.output, &__ret[..]); if !unconstrained { *result.multiplicity += G::ONE; } } else { record.function_queries[777].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained)); }; return Ok(__ret); }, _ => { - let __r_arr: [G; OUT_781] = { let __args: [G; IN_781] = [__v_0, __v_1, __v_14, __v_15, __v_16, __v_17, __v_18, __v_19]; let __cu = unconstrained; if let Some(result) = record.function_queries[781].get_mut(&__args[..]) { if !__cu && *result.multiplicity == G::ZERO { aiur_fn_781(__args, record, io_buffer, false)? } else { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_781] = unsafe { *(result.output.as_ptr() as *const [G; OUT_781]) }; __ret } } else { aiur_fn_781(__args, record, io_buffer, __cu)? } }; + let __r_arr: [G; OUT_777] = { let __args: [G; IN_777] = [__v_0, __v_1, __v_14, __v_15, __v_16, __v_17, __v_18, __v_19]; let __cu = unconstrained; if let Some(result) = record.function_queries[777].get_mut(&__args[..]) { if !__cu && *result.multiplicity == G::ZERO { aiur_fn_777(__args, record, io_buffer, false)? } else { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_777] = unsafe { *(result.output.as_ptr() as *const [G; OUT_777]) }; __ret } } else { aiur_fn_777(__args, record, io_buffer, __cu)? } }; let __v_22: G = __r_arr[0]; let __v_23: G = __r_arr[1]; let __v_24: G = __r_arr[2]; let __v_25: G = __r_arr[3]; let __v_26: G = __r_arr[4]; let __v_27: G = __r_arr[5]; - let __r_arr: [G; OUT_782] = { let __args: [G; IN_782] = [__v_3, __v_4, __v_5, __v_8, __v_9, __v_10, __v_11, __v_12, __v_13, __v_22, __v_23, __v_24, __v_25, __v_26, __v_27]; let __cu = unconstrained; if let Some(result) = record.function_queries[782].get_mut(&__args[..]) { if !__cu && *result.multiplicity == G::ZERO { aiur_fn_782(__args, record, io_buffer, false)? } else { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_782] = unsafe { *(result.output.as_ptr() as *const [G; OUT_782]) }; __ret } } else { aiur_fn_782(__args, record, io_buffer, __cu)? } }; + let __r_arr: [G; OUT_778] = { let __args: [G; IN_778] = [__v_3, __v_4, __v_5, __v_8, __v_9, __v_10, __v_11, __v_12, __v_13, __v_22, __v_23, __v_24, __v_25, __v_26, __v_27]; let __cu = unconstrained; if let Some(result) = record.function_queries[778].get_mut(&__args[..]) { if !__cu && *result.multiplicity == G::ZERO { aiur_fn_778(__args, record, io_buffer, false)? } else { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_778] = unsafe { *(result.output.as_ptr() as *const [G; OUT_778]) }; __ret } } else { aiur_fn_778(__args, record, io_buffer, __cu)? } }; let __v_28: G = __r_arr[0]; let __v_29: G = __r_arr[1]; let __v_30: G = __r_arr[2]; let __v_31: G = __r_arr[3]; let __v_32: G = __r_arr[4]; let __v_33: G = __r_arr[5]; - let __ret: [G; OUT_781] = [__v_28, __v_29, __v_30, __v_31, __v_32, __v_33]; - if let Some(result) = record.function_queries[781].get_mut(&inp[..]) { debug_assert_eq!(result.output, &__ret[..]); if !unconstrained { *result.multiplicity += G::ONE; } } else { record.function_queries[781].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained)); }; + let __ret: [G; OUT_777] = [__v_28, __v_29, __v_30, __v_31, __v_32, __v_33]; + if let Some(result) = record.function_queries[777].get_mut(&inp[..]) { debug_assert_eq!(result.output, &__ret[..]); if !unconstrained { *result.multiplicity += G::ONE; } } else { record.function_queries[777].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained)); }; return Ok(__ret); }, } @@ -65583,15 +65311,15 @@ fn aiur_fn_781( }) } -const INPUT_SIZE_782: usize = 15; -const IN_782: usize = 15; -const OUT_782: usize = 6; -fn aiur_fn_782( - inp: [G; IN_782], +const INPUT_SIZE_778: usize = 15; +const IN_778: usize = 15; +const OUT_778: usize = 6; +fn aiur_fn_778( + inp: [G; IN_778], record: &mut QueryRecord, io_buffer: &mut IOBuffer, unconstrained: bool, -) -> Result<[G; OUT_782], ExecError> { +) -> Result<[G; OUT_778], ExecError> { stacker::maybe_grow(64 * 1024, 4 * 1024 * 1024, || { let __v_0: G = inp[0]; let __v_1: G = inp[1]; @@ -65610,38 +65338,38 @@ fn aiur_fn_782( let __v_14: G = inp[14]; match __v_0.as_canonical_u64() { 1u64 => { - let __r_arr: [G; OUT_783] = { let __args: [G; IN_783] = [__v_1, __v_2, __v_3, __v_4, __v_5, __v_6, __v_7, __v_8, __v_9, __v_10, __v_11, __v_12, __v_13, __v_14]; let __cu = unconstrained; if let Some(result) = record.function_queries[783].get_mut(&__args[..]) { if !__cu && *result.multiplicity == G::ZERO { aiur_fn_783(__args, record, io_buffer, false)? } else { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_783] = unsafe { *(result.output.as_ptr() as *const [G; OUT_783]) }; __ret } } else { aiur_fn_783(__args, record, io_buffer, __cu)? } }; + let __r_arr: [G; OUT_779] = { let __args: [G; IN_779] = [__v_1, __v_2, __v_3, __v_4, __v_5, __v_6, __v_7, __v_8, __v_9, __v_10, __v_11, __v_12, __v_13, __v_14]; let __cu = unconstrained; if let Some(result) = record.function_queries[779].get_mut(&__args[..]) { if !__cu && *result.multiplicity == G::ZERO { aiur_fn_779(__args, record, io_buffer, false)? } else { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_779] = unsafe { *(result.output.as_ptr() as *const [G; OUT_779]) }; __ret } } else { aiur_fn_779(__args, record, io_buffer, __cu)? } }; let __v_15: G = __r_arr[0]; let __v_16: G = __r_arr[1]; let __v_17: G = __r_arr[2]; let __v_18: G = __r_arr[3]; let __v_19: G = __r_arr[4]; let __v_20: G = __r_arr[5]; - let __ret: [G; OUT_782] = [__v_15, __v_16, __v_17, __v_18, __v_19, __v_20]; - if let Some(result) = record.function_queries[782].get_mut(&inp[..]) { debug_assert_eq!(result.output, &__ret[..]); if !unconstrained { *result.multiplicity += G::ONE; } } else { record.function_queries[782].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained)); }; + let __ret: [G; OUT_778] = [__v_15, __v_16, __v_17, __v_18, __v_19, __v_20]; + if let Some(result) = record.function_queries[778].get_mut(&inp[..]) { debug_assert_eq!(result.output, &__ret[..]); if !unconstrained { *result.multiplicity += G::ONE; } } else { record.function_queries[778].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained)); }; return Ok(__ret); }, _ => { let __v_15: G = G::from_u64(0); let __v_16: G = { let __values: [G; 6] = [__v_3, __v_4, __v_5, __v_6, __v_7, __v_8]; let __mq = record.memory_queries.get_mut(&6).ok_or(ExecError::InvalidMemorySize(6))?; if let Some(result) = __mq.get_mut(&__values[..]) { if !unconstrained { *result.multiplicity += G::ONE; } result.output[0] } else { let __ptr = G::from_usize(__mq.len()); __mq.insert(&__values[..], &[__ptr], G::from_bool(!unconstrained)); __ptr } }; let __v_17: G = { let __values: [G; 6] = [__v_9, __v_10, __v_11, __v_12, __v_13, __v_14]; let __mq = record.memory_queries.get_mut(&6).ok_or(ExecError::InvalidMemorySize(6))?; if let Some(result) = __mq.get_mut(&__values[..]) { if !unconstrained { *result.multiplicity += G::ONE; } result.output[0] } else { let __ptr = G::from_usize(__mq.len()); __mq.insert(&__values[..], &[__ptr], G::from_bool(!unconstrained)); __ptr } }; - let __ret: [G; OUT_782] = [__v_15, __v_0, __v_1, __v_2, __v_16, __v_17]; - if let Some(result) = record.function_queries[782].get_mut(&inp[..]) { debug_assert_eq!(result.output, &__ret[..]); if !unconstrained { *result.multiplicity += G::ONE; } } else { record.function_queries[782].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained)); }; + let __ret: [G; OUT_778] = [__v_15, __v_0, __v_1, __v_2, __v_16, __v_17]; + if let Some(result) = record.function_queries[778].get_mut(&inp[..]) { debug_assert_eq!(result.output, &__ret[..]); if !unconstrained { *result.multiplicity += G::ONE; } } else { record.function_queries[778].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained)); }; return Ok(__ret); }, } }) } -const INPUT_SIZE_783: usize = 14; -const IN_783: usize = 14; -const OUT_783: usize = 6; -fn aiur_fn_783( - inp: [G; IN_783], +const INPUT_SIZE_779: usize = 14; +const IN_779: usize = 14; +const OUT_779: usize = 6; +fn aiur_fn_779( + inp: [G; IN_779], record: &mut QueryRecord, io_buffer: &mut IOBuffer, unconstrained: bool, -) -> Result<[G; OUT_783], ExecError> { +) -> Result<[G; OUT_779], ExecError> { stacker::maybe_grow(64 * 1024, 4 * 1024 * 1024, || { let __v_0: G = inp[0]; let __v_1: G = inp[1]; @@ -65681,8 +65409,8 @@ fn aiur_fn_783( let __v_26: G = G::from_u64(1); let __v_27: G = { let __values: [G; 6] = [__v_8, __v_9, __v_10, __v_11, __v_12, __v_13]; let __mq = record.memory_queries.get_mut(&6).ok_or(ExecError::InvalidMemorySize(6))?; if let Some(result) = __mq.get_mut(&__values[..]) { if !unconstrained { *result.multiplicity += G::ONE; } result.output[0] } else { let __ptr = G::from_usize(__mq.len()); __mq.insert(&__values[..], &[__ptr], G::from_bool(!unconstrained)); __ptr } }; let __v_28: G = { let __values: [G; 6] = [__v_25, __v_26, __v_0, __v_1, __v_7, __v_27]; let __mq = record.memory_queries.get_mut(&6).ok_or(ExecError::InvalidMemorySize(6))?; if let Some(result) = __mq.get_mut(&__values[..]) { if !unconstrained { *result.multiplicity += G::ONE; } result.output[0] } else { let __ptr = G::from_usize(__mq.len()); __mq.insert(&__values[..], &[__ptr], G::from_bool(!unconstrained)); __ptr } }; - let __ret: [G; OUT_783] = [__v_20, __v_21, __v_4, __v_5, __v_24, __v_28]; - if let Some(result) = record.function_queries[783].get_mut(&inp[..]) { debug_assert_eq!(result.output, &__ret[..]); if !unconstrained { *result.multiplicity += G::ONE; } } else { record.function_queries[783].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained)); }; + let __ret: [G; OUT_779] = [__v_20, __v_21, __v_4, __v_5, __v_24, __v_28]; + if let Some(result) = record.function_queries[779].get_mut(&inp[..]) { debug_assert_eq!(result.output, &__ret[..]); if !unconstrained { *result.multiplicity += G::ONE; } } else { record.function_queries[779].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained)); }; return Ok(__ret); }, _ => { @@ -65706,8 +65434,8 @@ fn aiur_fn_783( let __v_32: G = G::from_u64(1); let __v_33: G = { let __values: [G; 6] = [__v_8, __v_9, __v_10, __v_11, __v_12, __v_13]; let __mq = record.memory_queries.get_mut(&6).ok_or(ExecError::InvalidMemorySize(6))?; if let Some(result) = __mq.get_mut(&__values[..]) { if !unconstrained { *result.multiplicity += G::ONE; } result.output[0] } else { let __ptr = G::from_usize(__mq.len()); __mq.insert(&__values[..], &[__ptr], G::from_bool(!unconstrained)); __ptr } }; let __v_34: G = { let __values: [G; 6] = [__v_31, __v_32, __v_0, __v_1, __v_25, __v_33]; let __mq = record.memory_queries.get_mut(&6).ok_or(ExecError::InvalidMemorySize(6))?; if let Some(result) = __mq.get_mut(&__values[..]) { if !unconstrained { *result.multiplicity += G::ONE; } result.output[0] } else { let __ptr = G::from_usize(__mq.len()); __mq.insert(&__values[..], &[__ptr], G::from_bool(!unconstrained)); __ptr } }; - let __ret: [G; OUT_783] = [__v_26, __v_27, __v_22, __v_23, __v_30, __v_34]; - if let Some(result) = record.function_queries[783].get_mut(&inp[..]) { debug_assert_eq!(result.output, &__ret[..]); if !unconstrained { *result.multiplicity += G::ONE; } } else { record.function_queries[783].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained)); }; + let __ret: [G; OUT_779] = [__v_26, __v_27, __v_22, __v_23, __v_30, __v_34]; + if let Some(result) = record.function_queries[779].get_mut(&inp[..]) { debug_assert_eq!(result.output, &__ret[..]); if !unconstrained { *result.multiplicity += G::ONE; } } else { record.function_queries[779].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained)); }; return Ok(__ret); }, _ => { @@ -65735,8 +65463,8 @@ fn aiur_fn_783( let __v_38: G = G::from_u64(0); let __v_39: G = G::from_u64(1); let __v_40: G = { let __values: [G; 6] = [__v_38, __v_39, __v_10, __v_11, __v_31, __v_13]; let __mq = record.memory_queries.get_mut(&6).ok_or(ExecError::InvalidMemorySize(6))?; if let Some(result) = __mq.get_mut(&__values[..]) { if !unconstrained { *result.multiplicity += G::ONE; } result.output[0] } else { let __ptr = G::from_usize(__mq.len()); __mq.insert(&__values[..], &[__ptr], G::from_bool(!unconstrained)); __ptr } }; - let __ret: [G; OUT_783] = [__v_32, __v_33, __v_28, __v_29, __v_37, __v_40]; - if let Some(result) = record.function_queries[783].get_mut(&inp[..]) { debug_assert_eq!(result.output, &__ret[..]); if !unconstrained { *result.multiplicity += G::ONE; } } else { record.function_queries[783].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained)); }; + let __ret: [G; OUT_779] = [__v_32, __v_33, __v_28, __v_29, __v_37, __v_40]; + if let Some(result) = record.function_queries[779].get_mut(&inp[..]) { debug_assert_eq!(result.output, &__ret[..]); if !unconstrained { *result.multiplicity += G::ONE; } } else { record.function_queries[779].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained)); }; return Ok(__ret); }, _ => { @@ -65760,8 +65488,8 @@ fn aiur_fn_783( let __v_44: G = G::from_u64(0); let __v_45: G = G::from_u64(1); let __v_46: G = { let __values: [G; 6] = [__v_44, __v_45, __v_34, __v_35, __v_36, __v_37]; let __mq = record.memory_queries.get_mut(&6).ok_or(ExecError::InvalidMemorySize(6))?; if let Some(result) = __mq.get_mut(&__values[..]) { if !unconstrained { *result.multiplicity += G::ONE; } result.output[0] } else { let __ptr = G::from_usize(__mq.len()); __mq.insert(&__values[..], &[__ptr], G::from_bool(!unconstrained)); __ptr } }; - let __ret: [G; OUT_783] = [__v_38, __v_39, __v_10, __v_11, __v_43, __v_46]; - if let Some(result) = record.function_queries[783].get_mut(&inp[..]) { debug_assert_eq!(result.output, &__ret[..]); if !unconstrained { *result.multiplicity += G::ONE; } } else { record.function_queries[783].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained)); }; + let __ret: [G; OUT_779] = [__v_38, __v_39, __v_10, __v_11, __v_43, __v_46]; + if let Some(result) = record.function_queries[779].get_mut(&inp[..]) { debug_assert_eq!(result.output, &__ret[..]); if !unconstrained { *result.multiplicity += G::ONE; } } else { record.function_queries[779].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained)); }; return Ok(__ret); }, _ => { @@ -65769,8 +65497,8 @@ fn aiur_fn_783( let __v_39: G = G::from_u64(1); let __v_40: G = { let __values: [G; 6] = [__v_2, __v_3, __v_4, __v_5, __v_6, __v_7]; let __mq = record.memory_queries.get_mut(&6).ok_or(ExecError::InvalidMemorySize(6))?; if let Some(result) = __mq.get_mut(&__values[..]) { if !unconstrained { *result.multiplicity += G::ONE; } result.output[0] } else { let __ptr = G::from_usize(__mq.len()); __mq.insert(&__values[..], &[__ptr], G::from_bool(!unconstrained)); __ptr } }; let __v_41: G = { let __values: [G; 6] = [__v_8, __v_9, __v_10, __v_11, __v_12, __v_13]; let __mq = record.memory_queries.get_mut(&6).ok_or(ExecError::InvalidMemorySize(6))?; if let Some(result) = __mq.get_mut(&__values[..]) { if !unconstrained { *result.multiplicity += G::ONE; } result.output[0] } else { let __ptr = G::from_usize(__mq.len()); __mq.insert(&__values[..], &[__ptr], G::from_bool(!unconstrained)); __ptr } }; - let __ret: [G; OUT_783] = [__v_38, __v_39, __v_0, __v_1, __v_40, __v_41]; - if let Some(result) = record.function_queries[783].get_mut(&inp[..]) { debug_assert_eq!(result.output, &__ret[..]); if !unconstrained { *result.multiplicity += G::ONE; } } else { record.function_queries[783].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained)); }; + let __ret: [G; OUT_779] = [__v_38, __v_39, __v_0, __v_1, __v_40, __v_41]; + if let Some(result) = record.function_queries[779].get_mut(&inp[..]) { debug_assert_eq!(result.output, &__ret[..]); if !unconstrained { *result.multiplicity += G::ONE; } } else { record.function_queries[779].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained)); }; return Ok(__ret); }, } @@ -65780,8 +65508,8 @@ fn aiur_fn_783( let __v_39: G = G::from_u64(1); let __v_40: G = { let __values: [G; 6] = [__v_2, __v_3, __v_4, __v_5, __v_6, __v_7]; let __mq = record.memory_queries.get_mut(&6).ok_or(ExecError::InvalidMemorySize(6))?; if let Some(result) = __mq.get_mut(&__values[..]) { if !unconstrained { *result.multiplicity += G::ONE; } result.output[0] } else { let __ptr = G::from_usize(__mq.len()); __mq.insert(&__values[..], &[__ptr], G::from_bool(!unconstrained)); __ptr } }; let __v_41: G = { let __values: [G; 6] = [__v_8, __v_9, __v_10, __v_11, __v_12, __v_13]; let __mq = record.memory_queries.get_mut(&6).ok_or(ExecError::InvalidMemorySize(6))?; if let Some(result) = __mq.get_mut(&__values[..]) { if !unconstrained { *result.multiplicity += G::ONE; } result.output[0] } else { let __ptr = G::from_usize(__mq.len()); __mq.insert(&__values[..], &[__ptr], G::from_bool(!unconstrained)); __ptr } }; - let __ret: [G; OUT_783] = [__v_38, __v_39, __v_0, __v_1, __v_40, __v_41]; - if let Some(result) = record.function_queries[783].get_mut(&inp[..]) { debug_assert_eq!(result.output, &__ret[..]); if !unconstrained { *result.multiplicity += G::ONE; } } else { record.function_queries[783].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained)); }; + let __ret: [G; OUT_779] = [__v_38, __v_39, __v_0, __v_1, __v_40, __v_41]; + if let Some(result) = record.function_queries[779].get_mut(&inp[..]) { debug_assert_eq!(result.output, &__ret[..]); if !unconstrained { *result.multiplicity += G::ONE; } } else { record.function_queries[779].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained)); }; return Ok(__ret); }, } @@ -65809,8 +65537,8 @@ fn aiur_fn_783( let __v_44: G = G::from_u64(0); let __v_45: G = G::from_u64(1); let __v_46: G = { let __values: [G; 6] = [__v_44, __v_45, __v_34, __v_35, __v_36, __v_37]; let __mq = record.memory_queries.get_mut(&6).ok_or(ExecError::InvalidMemorySize(6))?; if let Some(result) = __mq.get_mut(&__values[..]) { if !unconstrained { *result.multiplicity += G::ONE; } result.output[0] } else { let __ptr = G::from_usize(__mq.len()); __mq.insert(&__values[..], &[__ptr], G::from_bool(!unconstrained)); __ptr } }; - let __ret: [G; OUT_783] = [__v_38, __v_39, __v_10, __v_11, __v_43, __v_46]; - if let Some(result) = record.function_queries[783].get_mut(&inp[..]) { debug_assert_eq!(result.output, &__ret[..]); if !unconstrained { *result.multiplicity += G::ONE; } } else { record.function_queries[783].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained)); }; + let __ret: [G; OUT_779] = [__v_38, __v_39, __v_10, __v_11, __v_43, __v_46]; + if let Some(result) = record.function_queries[779].get_mut(&inp[..]) { debug_assert_eq!(result.output, &__ret[..]); if !unconstrained { *result.multiplicity += G::ONE; } } else { record.function_queries[779].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained)); }; return Ok(__ret); }, _ => { @@ -65818,8 +65546,8 @@ fn aiur_fn_783( let __v_39: G = G::from_u64(1); let __v_40: G = { let __values: [G; 6] = [__v_2, __v_3, __v_4, __v_5, __v_6, __v_7]; let __mq = record.memory_queries.get_mut(&6).ok_or(ExecError::InvalidMemorySize(6))?; if let Some(result) = __mq.get_mut(&__values[..]) { if !unconstrained { *result.multiplicity += G::ONE; } result.output[0] } else { let __ptr = G::from_usize(__mq.len()); __mq.insert(&__values[..], &[__ptr], G::from_bool(!unconstrained)); __ptr } }; let __v_41: G = { let __values: [G; 6] = [__v_8, __v_9, __v_10, __v_11, __v_12, __v_13]; let __mq = record.memory_queries.get_mut(&6).ok_or(ExecError::InvalidMemorySize(6))?; if let Some(result) = __mq.get_mut(&__values[..]) { if !unconstrained { *result.multiplicity += G::ONE; } result.output[0] } else { let __ptr = G::from_usize(__mq.len()); __mq.insert(&__values[..], &[__ptr], G::from_bool(!unconstrained)); __ptr } }; - let __ret: [G; OUT_783] = [__v_38, __v_39, __v_0, __v_1, __v_40, __v_41]; - if let Some(result) = record.function_queries[783].get_mut(&inp[..]) { debug_assert_eq!(result.output, &__ret[..]); if !unconstrained { *result.multiplicity += G::ONE; } } else { record.function_queries[783].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained)); }; + let __ret: [G; OUT_779] = [__v_38, __v_39, __v_0, __v_1, __v_40, __v_41]; + if let Some(result) = record.function_queries[779].get_mut(&inp[..]) { debug_assert_eq!(result.output, &__ret[..]); if !unconstrained { *result.multiplicity += G::ONE; } } else { record.function_queries[779].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained)); }; return Ok(__ret); }, } @@ -65829,8 +65557,8 @@ fn aiur_fn_783( let __v_39: G = G::from_u64(1); let __v_40: G = { let __values: [G; 6] = [__v_2, __v_3, __v_4, __v_5, __v_6, __v_7]; let __mq = record.memory_queries.get_mut(&6).ok_or(ExecError::InvalidMemorySize(6))?; if let Some(result) = __mq.get_mut(&__values[..]) { if !unconstrained { *result.multiplicity += G::ONE; } result.output[0] } else { let __ptr = G::from_usize(__mq.len()); __mq.insert(&__values[..], &[__ptr], G::from_bool(!unconstrained)); __ptr } }; let __v_41: G = { let __values: [G; 6] = [__v_8, __v_9, __v_10, __v_11, __v_12, __v_13]; let __mq = record.memory_queries.get_mut(&6).ok_or(ExecError::InvalidMemorySize(6))?; if let Some(result) = __mq.get_mut(&__values[..]) { if !unconstrained { *result.multiplicity += G::ONE; } result.output[0] } else { let __ptr = G::from_usize(__mq.len()); __mq.insert(&__values[..], &[__ptr], G::from_bool(!unconstrained)); __ptr } }; - let __ret: [G; OUT_783] = [__v_38, __v_39, __v_0, __v_1, __v_40, __v_41]; - if let Some(result) = record.function_queries[783].get_mut(&inp[..]) { debug_assert_eq!(result.output, &__ret[..]); if !unconstrained { *result.multiplicity += G::ONE; } } else { record.function_queries[783].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained)); }; + let __ret: [G; OUT_779] = [__v_38, __v_39, __v_0, __v_1, __v_40, __v_41]; + if let Some(result) = record.function_queries[779].get_mut(&inp[..]) { debug_assert_eq!(result.output, &__ret[..]); if !unconstrained { *result.multiplicity += G::ONE; } } else { record.function_queries[779].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained)); }; return Ok(__ret); }, } @@ -65842,8 +65570,8 @@ fn aiur_fn_783( let __v_27: G = G::from_u64(1); let __v_28: G = { let __values: [G; 6] = [__v_2, __v_3, __v_4, __v_5, __v_6, __v_7]; let __mq = record.memory_queries.get_mut(&6).ok_or(ExecError::InvalidMemorySize(6))?; if let Some(result) = __mq.get_mut(&__values[..]) { if !unconstrained { *result.multiplicity += G::ONE; } result.output[0] } else { let __ptr = G::from_usize(__mq.len()); __mq.insert(&__values[..], &[__ptr], G::from_bool(!unconstrained)); __ptr } }; let __v_29: G = { let __values: [G; 6] = [__v_8, __v_9, __v_10, __v_11, __v_12, __v_13]; let __mq = record.memory_queries.get_mut(&6).ok_or(ExecError::InvalidMemorySize(6))?; if let Some(result) = __mq.get_mut(&__values[..]) { if !unconstrained { *result.multiplicity += G::ONE; } result.output[0] } else { let __ptr = G::from_usize(__mq.len()); __mq.insert(&__values[..], &[__ptr], G::from_bool(!unconstrained)); __ptr } }; - let __ret: [G; OUT_783] = [__v_26, __v_27, __v_0, __v_1, __v_28, __v_29]; - if let Some(result) = record.function_queries[783].get_mut(&inp[..]) { debug_assert_eq!(result.output, &__ret[..]); if !unconstrained { *result.multiplicity += G::ONE; } } else { record.function_queries[783].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained)); }; + let __ret: [G; OUT_779] = [__v_26, __v_27, __v_0, __v_1, __v_28, __v_29]; + if let Some(result) = record.function_queries[779].get_mut(&inp[..]) { debug_assert_eq!(result.output, &__ret[..]); if !unconstrained { *result.multiplicity += G::ONE; } } else { record.function_queries[779].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained)); }; return Ok(__ret); }, } @@ -65853,8 +65581,8 @@ fn aiur_fn_783( let __v_27: G = G::from_u64(1); let __v_28: G = { let __values: [G; 6] = [__v_2, __v_3, __v_4, __v_5, __v_6, __v_7]; let __mq = record.memory_queries.get_mut(&6).ok_or(ExecError::InvalidMemorySize(6))?; if let Some(result) = __mq.get_mut(&__values[..]) { if !unconstrained { *result.multiplicity += G::ONE; } result.output[0] } else { let __ptr = G::from_usize(__mq.len()); __mq.insert(&__values[..], &[__ptr], G::from_bool(!unconstrained)); __ptr } }; let __v_29: G = { let __values: [G; 6] = [__v_8, __v_9, __v_10, __v_11, __v_12, __v_13]; let __mq = record.memory_queries.get_mut(&6).ok_or(ExecError::InvalidMemorySize(6))?; if let Some(result) = __mq.get_mut(&__values[..]) { if !unconstrained { *result.multiplicity += G::ONE; } result.output[0] } else { let __ptr = G::from_usize(__mq.len()); __mq.insert(&__values[..], &[__ptr], G::from_bool(!unconstrained)); __ptr } }; - let __ret: [G; OUT_783] = [__v_26, __v_27, __v_0, __v_1, __v_28, __v_29]; - if let Some(result) = record.function_queries[783].get_mut(&inp[..]) { debug_assert_eq!(result.output, &__ret[..]); if !unconstrained { *result.multiplicity += G::ONE; } } else { record.function_queries[783].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained)); }; + let __ret: [G; OUT_779] = [__v_26, __v_27, __v_0, __v_1, __v_28, __v_29]; + if let Some(result) = record.function_queries[779].get_mut(&inp[..]) { debug_assert_eq!(result.output, &__ret[..]); if !unconstrained { *result.multiplicity += G::ONE; } } else { record.function_queries[779].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained)); }; return Ok(__ret); }, } @@ -65886,8 +65614,8 @@ fn aiur_fn_783( let __v_38: G = G::from_u64(0); let __v_39: G = G::from_u64(1); let __v_40: G = { let __values: [G; 6] = [__v_38, __v_39, __v_10, __v_11, __v_31, __v_13]; let __mq = record.memory_queries.get_mut(&6).ok_or(ExecError::InvalidMemorySize(6))?; if let Some(result) = __mq.get_mut(&__values[..]) { if !unconstrained { *result.multiplicity += G::ONE; } result.output[0] } else { let __ptr = G::from_usize(__mq.len()); __mq.insert(&__values[..], &[__ptr], G::from_bool(!unconstrained)); __ptr } }; - let __ret: [G; OUT_783] = [__v_32, __v_33, __v_28, __v_29, __v_37, __v_40]; - if let Some(result) = record.function_queries[783].get_mut(&inp[..]) { debug_assert_eq!(result.output, &__ret[..]); if !unconstrained { *result.multiplicity += G::ONE; } } else { record.function_queries[783].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained)); }; + let __ret: [G; OUT_779] = [__v_32, __v_33, __v_28, __v_29, __v_37, __v_40]; + if let Some(result) = record.function_queries[779].get_mut(&inp[..]) { debug_assert_eq!(result.output, &__ret[..]); if !unconstrained { *result.multiplicity += G::ONE; } } else { record.function_queries[779].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained)); }; return Ok(__ret); }, _ => { @@ -65911,8 +65639,8 @@ fn aiur_fn_783( let __v_44: G = G::from_u64(0); let __v_45: G = G::from_u64(1); let __v_46: G = { let __values: [G; 6] = [__v_44, __v_45, __v_34, __v_35, __v_36, __v_37]; let __mq = record.memory_queries.get_mut(&6).ok_or(ExecError::InvalidMemorySize(6))?; if let Some(result) = __mq.get_mut(&__values[..]) { if !unconstrained { *result.multiplicity += G::ONE; } result.output[0] } else { let __ptr = G::from_usize(__mq.len()); __mq.insert(&__values[..], &[__ptr], G::from_bool(!unconstrained)); __ptr } }; - let __ret: [G; OUT_783] = [__v_38, __v_39, __v_10, __v_11, __v_43, __v_46]; - if let Some(result) = record.function_queries[783].get_mut(&inp[..]) { debug_assert_eq!(result.output, &__ret[..]); if !unconstrained { *result.multiplicity += G::ONE; } } else { record.function_queries[783].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained)); }; + let __ret: [G; OUT_779] = [__v_38, __v_39, __v_10, __v_11, __v_43, __v_46]; + if let Some(result) = record.function_queries[779].get_mut(&inp[..]) { debug_assert_eq!(result.output, &__ret[..]); if !unconstrained { *result.multiplicity += G::ONE; } } else { record.function_queries[779].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained)); }; return Ok(__ret); }, _ => { @@ -65920,8 +65648,8 @@ fn aiur_fn_783( let __v_39: G = G::from_u64(1); let __v_40: G = { let __values: [G; 6] = [__v_2, __v_3, __v_4, __v_5, __v_6, __v_7]; let __mq = record.memory_queries.get_mut(&6).ok_or(ExecError::InvalidMemorySize(6))?; if let Some(result) = __mq.get_mut(&__values[..]) { if !unconstrained { *result.multiplicity += G::ONE; } result.output[0] } else { let __ptr = G::from_usize(__mq.len()); __mq.insert(&__values[..], &[__ptr], G::from_bool(!unconstrained)); __ptr } }; let __v_41: G = { let __values: [G; 6] = [__v_8, __v_9, __v_10, __v_11, __v_12, __v_13]; let __mq = record.memory_queries.get_mut(&6).ok_or(ExecError::InvalidMemorySize(6))?; if let Some(result) = __mq.get_mut(&__values[..]) { if !unconstrained { *result.multiplicity += G::ONE; } result.output[0] } else { let __ptr = G::from_usize(__mq.len()); __mq.insert(&__values[..], &[__ptr], G::from_bool(!unconstrained)); __ptr } }; - let __ret: [G; OUT_783] = [__v_38, __v_39, __v_0, __v_1, __v_40, __v_41]; - if let Some(result) = record.function_queries[783].get_mut(&inp[..]) { debug_assert_eq!(result.output, &__ret[..]); if !unconstrained { *result.multiplicity += G::ONE; } } else { record.function_queries[783].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained)); }; + let __ret: [G; OUT_779] = [__v_38, __v_39, __v_0, __v_1, __v_40, __v_41]; + if let Some(result) = record.function_queries[779].get_mut(&inp[..]) { debug_assert_eq!(result.output, &__ret[..]); if !unconstrained { *result.multiplicity += G::ONE; } } else { record.function_queries[779].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained)); }; return Ok(__ret); }, } @@ -65931,8 +65659,8 @@ fn aiur_fn_783( let __v_39: G = G::from_u64(1); let __v_40: G = { let __values: [G; 6] = [__v_2, __v_3, __v_4, __v_5, __v_6, __v_7]; let __mq = record.memory_queries.get_mut(&6).ok_or(ExecError::InvalidMemorySize(6))?; if let Some(result) = __mq.get_mut(&__values[..]) { if !unconstrained { *result.multiplicity += G::ONE; } result.output[0] } else { let __ptr = G::from_usize(__mq.len()); __mq.insert(&__values[..], &[__ptr], G::from_bool(!unconstrained)); __ptr } }; let __v_41: G = { let __values: [G; 6] = [__v_8, __v_9, __v_10, __v_11, __v_12, __v_13]; let __mq = record.memory_queries.get_mut(&6).ok_or(ExecError::InvalidMemorySize(6))?; if let Some(result) = __mq.get_mut(&__values[..]) { if !unconstrained { *result.multiplicity += G::ONE; } result.output[0] } else { let __ptr = G::from_usize(__mq.len()); __mq.insert(&__values[..], &[__ptr], G::from_bool(!unconstrained)); __ptr } }; - let __ret: [G; OUT_783] = [__v_38, __v_39, __v_0, __v_1, __v_40, __v_41]; - if let Some(result) = record.function_queries[783].get_mut(&inp[..]) { debug_assert_eq!(result.output, &__ret[..]); if !unconstrained { *result.multiplicity += G::ONE; } } else { record.function_queries[783].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained)); }; + let __ret: [G; OUT_779] = [__v_38, __v_39, __v_0, __v_1, __v_40, __v_41]; + if let Some(result) = record.function_queries[779].get_mut(&inp[..]) { debug_assert_eq!(result.output, &__ret[..]); if !unconstrained { *result.multiplicity += G::ONE; } } else { record.function_queries[779].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained)); }; return Ok(__ret); }, } @@ -65960,8 +65688,8 @@ fn aiur_fn_783( let __v_44: G = G::from_u64(0); let __v_45: G = G::from_u64(1); let __v_46: G = { let __values: [G; 6] = [__v_44, __v_45, __v_34, __v_35, __v_36, __v_37]; let __mq = record.memory_queries.get_mut(&6).ok_or(ExecError::InvalidMemorySize(6))?; if let Some(result) = __mq.get_mut(&__values[..]) { if !unconstrained { *result.multiplicity += G::ONE; } result.output[0] } else { let __ptr = G::from_usize(__mq.len()); __mq.insert(&__values[..], &[__ptr], G::from_bool(!unconstrained)); __ptr } }; - let __ret: [G; OUT_783] = [__v_38, __v_39, __v_10, __v_11, __v_43, __v_46]; - if let Some(result) = record.function_queries[783].get_mut(&inp[..]) { debug_assert_eq!(result.output, &__ret[..]); if !unconstrained { *result.multiplicity += G::ONE; } } else { record.function_queries[783].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained)); }; + let __ret: [G; OUT_779] = [__v_38, __v_39, __v_10, __v_11, __v_43, __v_46]; + if let Some(result) = record.function_queries[779].get_mut(&inp[..]) { debug_assert_eq!(result.output, &__ret[..]); if !unconstrained { *result.multiplicity += G::ONE; } } else { record.function_queries[779].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained)); }; return Ok(__ret); }, _ => { @@ -65969,8 +65697,8 @@ fn aiur_fn_783( let __v_39: G = G::from_u64(1); let __v_40: G = { let __values: [G; 6] = [__v_2, __v_3, __v_4, __v_5, __v_6, __v_7]; let __mq = record.memory_queries.get_mut(&6).ok_or(ExecError::InvalidMemorySize(6))?; if let Some(result) = __mq.get_mut(&__values[..]) { if !unconstrained { *result.multiplicity += G::ONE; } result.output[0] } else { let __ptr = G::from_usize(__mq.len()); __mq.insert(&__values[..], &[__ptr], G::from_bool(!unconstrained)); __ptr } }; let __v_41: G = { let __values: [G; 6] = [__v_8, __v_9, __v_10, __v_11, __v_12, __v_13]; let __mq = record.memory_queries.get_mut(&6).ok_or(ExecError::InvalidMemorySize(6))?; if let Some(result) = __mq.get_mut(&__values[..]) { if !unconstrained { *result.multiplicity += G::ONE; } result.output[0] } else { let __ptr = G::from_usize(__mq.len()); __mq.insert(&__values[..], &[__ptr], G::from_bool(!unconstrained)); __ptr } }; - let __ret: [G; OUT_783] = [__v_38, __v_39, __v_0, __v_1, __v_40, __v_41]; - if let Some(result) = record.function_queries[783].get_mut(&inp[..]) { debug_assert_eq!(result.output, &__ret[..]); if !unconstrained { *result.multiplicity += G::ONE; } } else { record.function_queries[783].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained)); }; + let __ret: [G; OUT_779] = [__v_38, __v_39, __v_0, __v_1, __v_40, __v_41]; + if let Some(result) = record.function_queries[779].get_mut(&inp[..]) { debug_assert_eq!(result.output, &__ret[..]); if !unconstrained { *result.multiplicity += G::ONE; } } else { record.function_queries[779].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained)); }; return Ok(__ret); }, } @@ -65980,8 +65708,8 @@ fn aiur_fn_783( let __v_39: G = G::from_u64(1); let __v_40: G = { let __values: [G; 6] = [__v_2, __v_3, __v_4, __v_5, __v_6, __v_7]; let __mq = record.memory_queries.get_mut(&6).ok_or(ExecError::InvalidMemorySize(6))?; if let Some(result) = __mq.get_mut(&__values[..]) { if !unconstrained { *result.multiplicity += G::ONE; } result.output[0] } else { let __ptr = G::from_usize(__mq.len()); __mq.insert(&__values[..], &[__ptr], G::from_bool(!unconstrained)); __ptr } }; let __v_41: G = { let __values: [G; 6] = [__v_8, __v_9, __v_10, __v_11, __v_12, __v_13]; let __mq = record.memory_queries.get_mut(&6).ok_or(ExecError::InvalidMemorySize(6))?; if let Some(result) = __mq.get_mut(&__values[..]) { if !unconstrained { *result.multiplicity += G::ONE; } result.output[0] } else { let __ptr = G::from_usize(__mq.len()); __mq.insert(&__values[..], &[__ptr], G::from_bool(!unconstrained)); __ptr } }; - let __ret: [G; OUT_783] = [__v_38, __v_39, __v_0, __v_1, __v_40, __v_41]; - if let Some(result) = record.function_queries[783].get_mut(&inp[..]) { debug_assert_eq!(result.output, &__ret[..]); if !unconstrained { *result.multiplicity += G::ONE; } } else { record.function_queries[783].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained)); }; + let __ret: [G; OUT_779] = [__v_38, __v_39, __v_0, __v_1, __v_40, __v_41]; + if let Some(result) = record.function_queries[779].get_mut(&inp[..]) { debug_assert_eq!(result.output, &__ret[..]); if !unconstrained { *result.multiplicity += G::ONE; } } else { record.function_queries[779].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained)); }; return Ok(__ret); }, } @@ -65993,8 +65721,8 @@ fn aiur_fn_783( let __v_27: G = G::from_u64(1); let __v_28: G = { let __values: [G; 6] = [__v_2, __v_3, __v_4, __v_5, __v_6, __v_7]; let __mq = record.memory_queries.get_mut(&6).ok_or(ExecError::InvalidMemorySize(6))?; if let Some(result) = __mq.get_mut(&__values[..]) { if !unconstrained { *result.multiplicity += G::ONE; } result.output[0] } else { let __ptr = G::from_usize(__mq.len()); __mq.insert(&__values[..], &[__ptr], G::from_bool(!unconstrained)); __ptr } }; let __v_29: G = { let __values: [G; 6] = [__v_8, __v_9, __v_10, __v_11, __v_12, __v_13]; let __mq = record.memory_queries.get_mut(&6).ok_or(ExecError::InvalidMemorySize(6))?; if let Some(result) = __mq.get_mut(&__values[..]) { if !unconstrained { *result.multiplicity += G::ONE; } result.output[0] } else { let __ptr = G::from_usize(__mq.len()); __mq.insert(&__values[..], &[__ptr], G::from_bool(!unconstrained)); __ptr } }; - let __ret: [G; OUT_783] = [__v_26, __v_27, __v_0, __v_1, __v_28, __v_29]; - if let Some(result) = record.function_queries[783].get_mut(&inp[..]) { debug_assert_eq!(result.output, &__ret[..]); if !unconstrained { *result.multiplicity += G::ONE; } } else { record.function_queries[783].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained)); }; + let __ret: [G; OUT_779] = [__v_26, __v_27, __v_0, __v_1, __v_28, __v_29]; + if let Some(result) = record.function_queries[779].get_mut(&inp[..]) { debug_assert_eq!(result.output, &__ret[..]); if !unconstrained { *result.multiplicity += G::ONE; } } else { record.function_queries[779].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained)); }; return Ok(__ret); }, } @@ -66004,8 +65732,8 @@ fn aiur_fn_783( let __v_27: G = G::from_u64(1); let __v_28: G = { let __values: [G; 6] = [__v_2, __v_3, __v_4, __v_5, __v_6, __v_7]; let __mq = record.memory_queries.get_mut(&6).ok_or(ExecError::InvalidMemorySize(6))?; if let Some(result) = __mq.get_mut(&__values[..]) { if !unconstrained { *result.multiplicity += G::ONE; } result.output[0] } else { let __ptr = G::from_usize(__mq.len()); __mq.insert(&__values[..], &[__ptr], G::from_bool(!unconstrained)); __ptr } }; let __v_29: G = { let __values: [G; 6] = [__v_8, __v_9, __v_10, __v_11, __v_12, __v_13]; let __mq = record.memory_queries.get_mut(&6).ok_or(ExecError::InvalidMemorySize(6))?; if let Some(result) = __mq.get_mut(&__values[..]) { if !unconstrained { *result.multiplicity += G::ONE; } result.output[0] } else { let __ptr = G::from_usize(__mq.len()); __mq.insert(&__values[..], &[__ptr], G::from_bool(!unconstrained)); __ptr } }; - let __ret: [G; OUT_783] = [__v_26, __v_27, __v_0, __v_1, __v_28, __v_29]; - if let Some(result) = record.function_queries[783].get_mut(&inp[..]) { debug_assert_eq!(result.output, &__ret[..]); if !unconstrained { *result.multiplicity += G::ONE; } } else { record.function_queries[783].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained)); }; + let __ret: [G; OUT_779] = [__v_26, __v_27, __v_0, __v_1, __v_28, __v_29]; + if let Some(result) = record.function_queries[779].get_mut(&inp[..]) { debug_assert_eq!(result.output, &__ret[..]); if !unconstrained { *result.multiplicity += G::ONE; } } else { record.function_queries[779].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained)); }; return Ok(__ret); }, } @@ -66035,8 +65763,8 @@ fn aiur_fn_783( let __v_32: G = G::from_u64(1); let __v_33: G = { let __values: [G; 6] = [__v_8, __v_9, __v_10, __v_11, __v_12, __v_13]; let __mq = record.memory_queries.get_mut(&6).ok_or(ExecError::InvalidMemorySize(6))?; if let Some(result) = __mq.get_mut(&__values[..]) { if !unconstrained { *result.multiplicity += G::ONE; } result.output[0] } else { let __ptr = G::from_usize(__mq.len()); __mq.insert(&__values[..], &[__ptr], G::from_bool(!unconstrained)); __ptr } }; let __v_34: G = { let __values: [G; 6] = [__v_31, __v_32, __v_0, __v_1, __v_25, __v_33]; let __mq = record.memory_queries.get_mut(&6).ok_or(ExecError::InvalidMemorySize(6))?; if let Some(result) = __mq.get_mut(&__values[..]) { if !unconstrained { *result.multiplicity += G::ONE; } result.output[0] } else { let __ptr = G::from_usize(__mq.len()); __mq.insert(&__values[..], &[__ptr], G::from_bool(!unconstrained)); __ptr } }; - let __ret: [G; OUT_783] = [__v_26, __v_27, __v_22, __v_23, __v_30, __v_34]; - if let Some(result) = record.function_queries[783].get_mut(&inp[..]) { debug_assert_eq!(result.output, &__ret[..]); if !unconstrained { *result.multiplicity += G::ONE; } } else { record.function_queries[783].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained)); }; + let __ret: [G; OUT_779] = [__v_26, __v_27, __v_22, __v_23, __v_30, __v_34]; + if let Some(result) = record.function_queries[779].get_mut(&inp[..]) { debug_assert_eq!(result.output, &__ret[..]); if !unconstrained { *result.multiplicity += G::ONE; } } else { record.function_queries[779].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained)); }; return Ok(__ret); }, _ => { @@ -66064,8 +65792,8 @@ fn aiur_fn_783( let __v_38: G = G::from_u64(0); let __v_39: G = G::from_u64(1); let __v_40: G = { let __values: [G; 6] = [__v_38, __v_39, __v_10, __v_11, __v_31, __v_13]; let __mq = record.memory_queries.get_mut(&6).ok_or(ExecError::InvalidMemorySize(6))?; if let Some(result) = __mq.get_mut(&__values[..]) { if !unconstrained { *result.multiplicity += G::ONE; } result.output[0] } else { let __ptr = G::from_usize(__mq.len()); __mq.insert(&__values[..], &[__ptr], G::from_bool(!unconstrained)); __ptr } }; - let __ret: [G; OUT_783] = [__v_32, __v_33, __v_28, __v_29, __v_37, __v_40]; - if let Some(result) = record.function_queries[783].get_mut(&inp[..]) { debug_assert_eq!(result.output, &__ret[..]); if !unconstrained { *result.multiplicity += G::ONE; } } else { record.function_queries[783].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained)); }; + let __ret: [G; OUT_779] = [__v_32, __v_33, __v_28, __v_29, __v_37, __v_40]; + if let Some(result) = record.function_queries[779].get_mut(&inp[..]) { debug_assert_eq!(result.output, &__ret[..]); if !unconstrained { *result.multiplicity += G::ONE; } } else { record.function_queries[779].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained)); }; return Ok(__ret); }, _ => { @@ -66089,8 +65817,8 @@ fn aiur_fn_783( let __v_44: G = G::from_u64(0); let __v_45: G = G::from_u64(1); let __v_46: G = { let __values: [G; 6] = [__v_44, __v_45, __v_34, __v_35, __v_36, __v_37]; let __mq = record.memory_queries.get_mut(&6).ok_or(ExecError::InvalidMemorySize(6))?; if let Some(result) = __mq.get_mut(&__values[..]) { if !unconstrained { *result.multiplicity += G::ONE; } result.output[0] } else { let __ptr = G::from_usize(__mq.len()); __mq.insert(&__values[..], &[__ptr], G::from_bool(!unconstrained)); __ptr } }; - let __ret: [G; OUT_783] = [__v_38, __v_39, __v_10, __v_11, __v_43, __v_46]; - if let Some(result) = record.function_queries[783].get_mut(&inp[..]) { debug_assert_eq!(result.output, &__ret[..]); if !unconstrained { *result.multiplicity += G::ONE; } } else { record.function_queries[783].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained)); }; + let __ret: [G; OUT_779] = [__v_38, __v_39, __v_10, __v_11, __v_43, __v_46]; + if let Some(result) = record.function_queries[779].get_mut(&inp[..]) { debug_assert_eq!(result.output, &__ret[..]); if !unconstrained { *result.multiplicity += G::ONE; } } else { record.function_queries[779].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained)); }; return Ok(__ret); }, _ => { @@ -66098,8 +65826,8 @@ fn aiur_fn_783( let __v_39: G = G::from_u64(1); let __v_40: G = { let __values: [G; 6] = [__v_2, __v_3, __v_4, __v_5, __v_6, __v_7]; let __mq = record.memory_queries.get_mut(&6).ok_or(ExecError::InvalidMemorySize(6))?; if let Some(result) = __mq.get_mut(&__values[..]) { if !unconstrained { *result.multiplicity += G::ONE; } result.output[0] } else { let __ptr = G::from_usize(__mq.len()); __mq.insert(&__values[..], &[__ptr], G::from_bool(!unconstrained)); __ptr } }; let __v_41: G = { let __values: [G; 6] = [__v_8, __v_9, __v_10, __v_11, __v_12, __v_13]; let __mq = record.memory_queries.get_mut(&6).ok_or(ExecError::InvalidMemorySize(6))?; if let Some(result) = __mq.get_mut(&__values[..]) { if !unconstrained { *result.multiplicity += G::ONE; } result.output[0] } else { let __ptr = G::from_usize(__mq.len()); __mq.insert(&__values[..], &[__ptr], G::from_bool(!unconstrained)); __ptr } }; - let __ret: [G; OUT_783] = [__v_38, __v_39, __v_0, __v_1, __v_40, __v_41]; - if let Some(result) = record.function_queries[783].get_mut(&inp[..]) { debug_assert_eq!(result.output, &__ret[..]); if !unconstrained { *result.multiplicity += G::ONE; } } else { record.function_queries[783].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained)); }; + let __ret: [G; OUT_779] = [__v_38, __v_39, __v_0, __v_1, __v_40, __v_41]; + if let Some(result) = record.function_queries[779].get_mut(&inp[..]) { debug_assert_eq!(result.output, &__ret[..]); if !unconstrained { *result.multiplicity += G::ONE; } } else { record.function_queries[779].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained)); }; return Ok(__ret); }, } @@ -66109,8 +65837,8 @@ fn aiur_fn_783( let __v_39: G = G::from_u64(1); let __v_40: G = { let __values: [G; 6] = [__v_2, __v_3, __v_4, __v_5, __v_6, __v_7]; let __mq = record.memory_queries.get_mut(&6).ok_or(ExecError::InvalidMemorySize(6))?; if let Some(result) = __mq.get_mut(&__values[..]) { if !unconstrained { *result.multiplicity += G::ONE; } result.output[0] } else { let __ptr = G::from_usize(__mq.len()); __mq.insert(&__values[..], &[__ptr], G::from_bool(!unconstrained)); __ptr } }; let __v_41: G = { let __values: [G; 6] = [__v_8, __v_9, __v_10, __v_11, __v_12, __v_13]; let __mq = record.memory_queries.get_mut(&6).ok_or(ExecError::InvalidMemorySize(6))?; if let Some(result) = __mq.get_mut(&__values[..]) { if !unconstrained { *result.multiplicity += G::ONE; } result.output[0] } else { let __ptr = G::from_usize(__mq.len()); __mq.insert(&__values[..], &[__ptr], G::from_bool(!unconstrained)); __ptr } }; - let __ret: [G; OUT_783] = [__v_38, __v_39, __v_0, __v_1, __v_40, __v_41]; - if let Some(result) = record.function_queries[783].get_mut(&inp[..]) { debug_assert_eq!(result.output, &__ret[..]); if !unconstrained { *result.multiplicity += G::ONE; } } else { record.function_queries[783].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained)); }; + let __ret: [G; OUT_779] = [__v_38, __v_39, __v_0, __v_1, __v_40, __v_41]; + if let Some(result) = record.function_queries[779].get_mut(&inp[..]) { debug_assert_eq!(result.output, &__ret[..]); if !unconstrained { *result.multiplicity += G::ONE; } } else { record.function_queries[779].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained)); }; return Ok(__ret); }, } @@ -66138,8 +65866,8 @@ fn aiur_fn_783( let __v_44: G = G::from_u64(0); let __v_45: G = G::from_u64(1); let __v_46: G = { let __values: [G; 6] = [__v_44, __v_45, __v_34, __v_35, __v_36, __v_37]; let __mq = record.memory_queries.get_mut(&6).ok_or(ExecError::InvalidMemorySize(6))?; if let Some(result) = __mq.get_mut(&__values[..]) { if !unconstrained { *result.multiplicity += G::ONE; } result.output[0] } else { let __ptr = G::from_usize(__mq.len()); __mq.insert(&__values[..], &[__ptr], G::from_bool(!unconstrained)); __ptr } }; - let __ret: [G; OUT_783] = [__v_38, __v_39, __v_10, __v_11, __v_43, __v_46]; - if let Some(result) = record.function_queries[783].get_mut(&inp[..]) { debug_assert_eq!(result.output, &__ret[..]); if !unconstrained { *result.multiplicity += G::ONE; } } else { record.function_queries[783].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained)); }; + let __ret: [G; OUT_779] = [__v_38, __v_39, __v_10, __v_11, __v_43, __v_46]; + if let Some(result) = record.function_queries[779].get_mut(&inp[..]) { debug_assert_eq!(result.output, &__ret[..]); if !unconstrained { *result.multiplicity += G::ONE; } } else { record.function_queries[779].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained)); }; return Ok(__ret); }, _ => { @@ -66147,8 +65875,8 @@ fn aiur_fn_783( let __v_39: G = G::from_u64(1); let __v_40: G = { let __values: [G; 6] = [__v_2, __v_3, __v_4, __v_5, __v_6, __v_7]; let __mq = record.memory_queries.get_mut(&6).ok_or(ExecError::InvalidMemorySize(6))?; if let Some(result) = __mq.get_mut(&__values[..]) { if !unconstrained { *result.multiplicity += G::ONE; } result.output[0] } else { let __ptr = G::from_usize(__mq.len()); __mq.insert(&__values[..], &[__ptr], G::from_bool(!unconstrained)); __ptr } }; let __v_41: G = { let __values: [G; 6] = [__v_8, __v_9, __v_10, __v_11, __v_12, __v_13]; let __mq = record.memory_queries.get_mut(&6).ok_or(ExecError::InvalidMemorySize(6))?; if let Some(result) = __mq.get_mut(&__values[..]) { if !unconstrained { *result.multiplicity += G::ONE; } result.output[0] } else { let __ptr = G::from_usize(__mq.len()); __mq.insert(&__values[..], &[__ptr], G::from_bool(!unconstrained)); __ptr } }; - let __ret: [G; OUT_783] = [__v_38, __v_39, __v_0, __v_1, __v_40, __v_41]; - if let Some(result) = record.function_queries[783].get_mut(&inp[..]) { debug_assert_eq!(result.output, &__ret[..]); if !unconstrained { *result.multiplicity += G::ONE; } } else { record.function_queries[783].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained)); }; + let __ret: [G; OUT_779] = [__v_38, __v_39, __v_0, __v_1, __v_40, __v_41]; + if let Some(result) = record.function_queries[779].get_mut(&inp[..]) { debug_assert_eq!(result.output, &__ret[..]); if !unconstrained { *result.multiplicity += G::ONE; } } else { record.function_queries[779].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained)); }; return Ok(__ret); }, } @@ -66158,8 +65886,8 @@ fn aiur_fn_783( let __v_39: G = G::from_u64(1); let __v_40: G = { let __values: [G; 6] = [__v_2, __v_3, __v_4, __v_5, __v_6, __v_7]; let __mq = record.memory_queries.get_mut(&6).ok_or(ExecError::InvalidMemorySize(6))?; if let Some(result) = __mq.get_mut(&__values[..]) { if !unconstrained { *result.multiplicity += G::ONE; } result.output[0] } else { let __ptr = G::from_usize(__mq.len()); __mq.insert(&__values[..], &[__ptr], G::from_bool(!unconstrained)); __ptr } }; let __v_41: G = { let __values: [G; 6] = [__v_8, __v_9, __v_10, __v_11, __v_12, __v_13]; let __mq = record.memory_queries.get_mut(&6).ok_or(ExecError::InvalidMemorySize(6))?; if let Some(result) = __mq.get_mut(&__values[..]) { if !unconstrained { *result.multiplicity += G::ONE; } result.output[0] } else { let __ptr = G::from_usize(__mq.len()); __mq.insert(&__values[..], &[__ptr], G::from_bool(!unconstrained)); __ptr } }; - let __ret: [G; OUT_783] = [__v_38, __v_39, __v_0, __v_1, __v_40, __v_41]; - if let Some(result) = record.function_queries[783].get_mut(&inp[..]) { debug_assert_eq!(result.output, &__ret[..]); if !unconstrained { *result.multiplicity += G::ONE; } } else { record.function_queries[783].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained)); }; + let __ret: [G; OUT_779] = [__v_38, __v_39, __v_0, __v_1, __v_40, __v_41]; + if let Some(result) = record.function_queries[779].get_mut(&inp[..]) { debug_assert_eq!(result.output, &__ret[..]); if !unconstrained { *result.multiplicity += G::ONE; } } else { record.function_queries[779].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained)); }; return Ok(__ret); }, } @@ -66171,8 +65899,8 @@ fn aiur_fn_783( let __v_27: G = G::from_u64(1); let __v_28: G = { let __values: [G; 6] = [__v_2, __v_3, __v_4, __v_5, __v_6, __v_7]; let __mq = record.memory_queries.get_mut(&6).ok_or(ExecError::InvalidMemorySize(6))?; if let Some(result) = __mq.get_mut(&__values[..]) { if !unconstrained { *result.multiplicity += G::ONE; } result.output[0] } else { let __ptr = G::from_usize(__mq.len()); __mq.insert(&__values[..], &[__ptr], G::from_bool(!unconstrained)); __ptr } }; let __v_29: G = { let __values: [G; 6] = [__v_8, __v_9, __v_10, __v_11, __v_12, __v_13]; let __mq = record.memory_queries.get_mut(&6).ok_or(ExecError::InvalidMemorySize(6))?; if let Some(result) = __mq.get_mut(&__values[..]) { if !unconstrained { *result.multiplicity += G::ONE; } result.output[0] } else { let __ptr = G::from_usize(__mq.len()); __mq.insert(&__values[..], &[__ptr], G::from_bool(!unconstrained)); __ptr } }; - let __ret: [G; OUT_783] = [__v_26, __v_27, __v_0, __v_1, __v_28, __v_29]; - if let Some(result) = record.function_queries[783].get_mut(&inp[..]) { debug_assert_eq!(result.output, &__ret[..]); if !unconstrained { *result.multiplicity += G::ONE; } } else { record.function_queries[783].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained)); }; + let __ret: [G; OUT_779] = [__v_26, __v_27, __v_0, __v_1, __v_28, __v_29]; + if let Some(result) = record.function_queries[779].get_mut(&inp[..]) { debug_assert_eq!(result.output, &__ret[..]); if !unconstrained { *result.multiplicity += G::ONE; } } else { record.function_queries[779].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained)); }; return Ok(__ret); }, } @@ -66182,8 +65910,8 @@ fn aiur_fn_783( let __v_27: G = G::from_u64(1); let __v_28: G = { let __values: [G; 6] = [__v_2, __v_3, __v_4, __v_5, __v_6, __v_7]; let __mq = record.memory_queries.get_mut(&6).ok_or(ExecError::InvalidMemorySize(6))?; if let Some(result) = __mq.get_mut(&__values[..]) { if !unconstrained { *result.multiplicity += G::ONE; } result.output[0] } else { let __ptr = G::from_usize(__mq.len()); __mq.insert(&__values[..], &[__ptr], G::from_bool(!unconstrained)); __ptr } }; let __v_29: G = { let __values: [G; 6] = [__v_8, __v_9, __v_10, __v_11, __v_12, __v_13]; let __mq = record.memory_queries.get_mut(&6).ok_or(ExecError::InvalidMemorySize(6))?; if let Some(result) = __mq.get_mut(&__values[..]) { if !unconstrained { *result.multiplicity += G::ONE; } result.output[0] } else { let __ptr = G::from_usize(__mq.len()); __mq.insert(&__values[..], &[__ptr], G::from_bool(!unconstrained)); __ptr } }; - let __ret: [G; OUT_783] = [__v_26, __v_27, __v_0, __v_1, __v_28, __v_29]; - if let Some(result) = record.function_queries[783].get_mut(&inp[..]) { debug_assert_eq!(result.output, &__ret[..]); if !unconstrained { *result.multiplicity += G::ONE; } } else { record.function_queries[783].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained)); }; + let __ret: [G; OUT_779] = [__v_26, __v_27, __v_0, __v_1, __v_28, __v_29]; + if let Some(result) = record.function_queries[779].get_mut(&inp[..]) { debug_assert_eq!(result.output, &__ret[..]); if !unconstrained { *result.multiplicity += G::ONE; } } else { record.function_queries[779].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained)); }; return Ok(__ret); }, } @@ -66215,8 +65943,8 @@ fn aiur_fn_783( let __v_38: G = G::from_u64(0); let __v_39: G = G::from_u64(1); let __v_40: G = { let __values: [G; 6] = [__v_38, __v_39, __v_10, __v_11, __v_31, __v_13]; let __mq = record.memory_queries.get_mut(&6).ok_or(ExecError::InvalidMemorySize(6))?; if let Some(result) = __mq.get_mut(&__values[..]) { if !unconstrained { *result.multiplicity += G::ONE; } result.output[0] } else { let __ptr = G::from_usize(__mq.len()); __mq.insert(&__values[..], &[__ptr], G::from_bool(!unconstrained)); __ptr } }; - let __ret: [G; OUT_783] = [__v_32, __v_33, __v_28, __v_29, __v_37, __v_40]; - if let Some(result) = record.function_queries[783].get_mut(&inp[..]) { debug_assert_eq!(result.output, &__ret[..]); if !unconstrained { *result.multiplicity += G::ONE; } } else { record.function_queries[783].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained)); }; + let __ret: [G; OUT_779] = [__v_32, __v_33, __v_28, __v_29, __v_37, __v_40]; + if let Some(result) = record.function_queries[779].get_mut(&inp[..]) { debug_assert_eq!(result.output, &__ret[..]); if !unconstrained { *result.multiplicity += G::ONE; } } else { record.function_queries[779].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained)); }; return Ok(__ret); }, _ => { @@ -66240,8 +65968,8 @@ fn aiur_fn_783( let __v_44: G = G::from_u64(0); let __v_45: G = G::from_u64(1); let __v_46: G = { let __values: [G; 6] = [__v_44, __v_45, __v_34, __v_35, __v_36, __v_37]; let __mq = record.memory_queries.get_mut(&6).ok_or(ExecError::InvalidMemorySize(6))?; if let Some(result) = __mq.get_mut(&__values[..]) { if !unconstrained { *result.multiplicity += G::ONE; } result.output[0] } else { let __ptr = G::from_usize(__mq.len()); __mq.insert(&__values[..], &[__ptr], G::from_bool(!unconstrained)); __ptr } }; - let __ret: [G; OUT_783] = [__v_38, __v_39, __v_10, __v_11, __v_43, __v_46]; - if let Some(result) = record.function_queries[783].get_mut(&inp[..]) { debug_assert_eq!(result.output, &__ret[..]); if !unconstrained { *result.multiplicity += G::ONE; } } else { record.function_queries[783].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained)); }; + let __ret: [G; OUT_779] = [__v_38, __v_39, __v_10, __v_11, __v_43, __v_46]; + if let Some(result) = record.function_queries[779].get_mut(&inp[..]) { debug_assert_eq!(result.output, &__ret[..]); if !unconstrained { *result.multiplicity += G::ONE; } } else { record.function_queries[779].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained)); }; return Ok(__ret); }, _ => { @@ -66249,8 +65977,8 @@ fn aiur_fn_783( let __v_39: G = G::from_u64(1); let __v_40: G = { let __values: [G; 6] = [__v_2, __v_3, __v_4, __v_5, __v_6, __v_7]; let __mq = record.memory_queries.get_mut(&6).ok_or(ExecError::InvalidMemorySize(6))?; if let Some(result) = __mq.get_mut(&__values[..]) { if !unconstrained { *result.multiplicity += G::ONE; } result.output[0] } else { let __ptr = G::from_usize(__mq.len()); __mq.insert(&__values[..], &[__ptr], G::from_bool(!unconstrained)); __ptr } }; let __v_41: G = { let __values: [G; 6] = [__v_8, __v_9, __v_10, __v_11, __v_12, __v_13]; let __mq = record.memory_queries.get_mut(&6).ok_or(ExecError::InvalidMemorySize(6))?; if let Some(result) = __mq.get_mut(&__values[..]) { if !unconstrained { *result.multiplicity += G::ONE; } result.output[0] } else { let __ptr = G::from_usize(__mq.len()); __mq.insert(&__values[..], &[__ptr], G::from_bool(!unconstrained)); __ptr } }; - let __ret: [G; OUT_783] = [__v_38, __v_39, __v_0, __v_1, __v_40, __v_41]; - if let Some(result) = record.function_queries[783].get_mut(&inp[..]) { debug_assert_eq!(result.output, &__ret[..]); if !unconstrained { *result.multiplicity += G::ONE; } } else { record.function_queries[783].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained)); }; + let __ret: [G; OUT_779] = [__v_38, __v_39, __v_0, __v_1, __v_40, __v_41]; + if let Some(result) = record.function_queries[779].get_mut(&inp[..]) { debug_assert_eq!(result.output, &__ret[..]); if !unconstrained { *result.multiplicity += G::ONE; } } else { record.function_queries[779].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained)); }; return Ok(__ret); }, } @@ -66260,8 +65988,8 @@ fn aiur_fn_783( let __v_39: G = G::from_u64(1); let __v_40: G = { let __values: [G; 6] = [__v_2, __v_3, __v_4, __v_5, __v_6, __v_7]; let __mq = record.memory_queries.get_mut(&6).ok_or(ExecError::InvalidMemorySize(6))?; if let Some(result) = __mq.get_mut(&__values[..]) { if !unconstrained { *result.multiplicity += G::ONE; } result.output[0] } else { let __ptr = G::from_usize(__mq.len()); __mq.insert(&__values[..], &[__ptr], G::from_bool(!unconstrained)); __ptr } }; let __v_41: G = { let __values: [G; 6] = [__v_8, __v_9, __v_10, __v_11, __v_12, __v_13]; let __mq = record.memory_queries.get_mut(&6).ok_or(ExecError::InvalidMemorySize(6))?; if let Some(result) = __mq.get_mut(&__values[..]) { if !unconstrained { *result.multiplicity += G::ONE; } result.output[0] } else { let __ptr = G::from_usize(__mq.len()); __mq.insert(&__values[..], &[__ptr], G::from_bool(!unconstrained)); __ptr } }; - let __ret: [G; OUT_783] = [__v_38, __v_39, __v_0, __v_1, __v_40, __v_41]; - if let Some(result) = record.function_queries[783].get_mut(&inp[..]) { debug_assert_eq!(result.output, &__ret[..]); if !unconstrained { *result.multiplicity += G::ONE; } } else { record.function_queries[783].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained)); }; + let __ret: [G; OUT_779] = [__v_38, __v_39, __v_0, __v_1, __v_40, __v_41]; + if let Some(result) = record.function_queries[779].get_mut(&inp[..]) { debug_assert_eq!(result.output, &__ret[..]); if !unconstrained { *result.multiplicity += G::ONE; } } else { record.function_queries[779].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained)); }; return Ok(__ret); }, } @@ -66289,8 +66017,8 @@ fn aiur_fn_783( let __v_44: G = G::from_u64(0); let __v_45: G = G::from_u64(1); let __v_46: G = { let __values: [G; 6] = [__v_44, __v_45, __v_34, __v_35, __v_36, __v_37]; let __mq = record.memory_queries.get_mut(&6).ok_or(ExecError::InvalidMemorySize(6))?; if let Some(result) = __mq.get_mut(&__values[..]) { if !unconstrained { *result.multiplicity += G::ONE; } result.output[0] } else { let __ptr = G::from_usize(__mq.len()); __mq.insert(&__values[..], &[__ptr], G::from_bool(!unconstrained)); __ptr } }; - let __ret: [G; OUT_783] = [__v_38, __v_39, __v_10, __v_11, __v_43, __v_46]; - if let Some(result) = record.function_queries[783].get_mut(&inp[..]) { debug_assert_eq!(result.output, &__ret[..]); if !unconstrained { *result.multiplicity += G::ONE; } } else { record.function_queries[783].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained)); }; + let __ret: [G; OUT_779] = [__v_38, __v_39, __v_10, __v_11, __v_43, __v_46]; + if let Some(result) = record.function_queries[779].get_mut(&inp[..]) { debug_assert_eq!(result.output, &__ret[..]); if !unconstrained { *result.multiplicity += G::ONE; } } else { record.function_queries[779].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained)); }; return Ok(__ret); }, _ => { @@ -66298,8 +66026,8 @@ fn aiur_fn_783( let __v_39: G = G::from_u64(1); let __v_40: G = { let __values: [G; 6] = [__v_2, __v_3, __v_4, __v_5, __v_6, __v_7]; let __mq = record.memory_queries.get_mut(&6).ok_or(ExecError::InvalidMemorySize(6))?; if let Some(result) = __mq.get_mut(&__values[..]) { if !unconstrained { *result.multiplicity += G::ONE; } result.output[0] } else { let __ptr = G::from_usize(__mq.len()); __mq.insert(&__values[..], &[__ptr], G::from_bool(!unconstrained)); __ptr } }; let __v_41: G = { let __values: [G; 6] = [__v_8, __v_9, __v_10, __v_11, __v_12, __v_13]; let __mq = record.memory_queries.get_mut(&6).ok_or(ExecError::InvalidMemorySize(6))?; if let Some(result) = __mq.get_mut(&__values[..]) { if !unconstrained { *result.multiplicity += G::ONE; } result.output[0] } else { let __ptr = G::from_usize(__mq.len()); __mq.insert(&__values[..], &[__ptr], G::from_bool(!unconstrained)); __ptr } }; - let __ret: [G; OUT_783] = [__v_38, __v_39, __v_0, __v_1, __v_40, __v_41]; - if let Some(result) = record.function_queries[783].get_mut(&inp[..]) { debug_assert_eq!(result.output, &__ret[..]); if !unconstrained { *result.multiplicity += G::ONE; } } else { record.function_queries[783].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained)); }; + let __ret: [G; OUT_779] = [__v_38, __v_39, __v_0, __v_1, __v_40, __v_41]; + if let Some(result) = record.function_queries[779].get_mut(&inp[..]) { debug_assert_eq!(result.output, &__ret[..]); if !unconstrained { *result.multiplicity += G::ONE; } } else { record.function_queries[779].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained)); }; return Ok(__ret); }, } @@ -66309,8 +66037,8 @@ fn aiur_fn_783( let __v_39: G = G::from_u64(1); let __v_40: G = { let __values: [G; 6] = [__v_2, __v_3, __v_4, __v_5, __v_6, __v_7]; let __mq = record.memory_queries.get_mut(&6).ok_or(ExecError::InvalidMemorySize(6))?; if let Some(result) = __mq.get_mut(&__values[..]) { if !unconstrained { *result.multiplicity += G::ONE; } result.output[0] } else { let __ptr = G::from_usize(__mq.len()); __mq.insert(&__values[..], &[__ptr], G::from_bool(!unconstrained)); __ptr } }; let __v_41: G = { let __values: [G; 6] = [__v_8, __v_9, __v_10, __v_11, __v_12, __v_13]; let __mq = record.memory_queries.get_mut(&6).ok_or(ExecError::InvalidMemorySize(6))?; if let Some(result) = __mq.get_mut(&__values[..]) { if !unconstrained { *result.multiplicity += G::ONE; } result.output[0] } else { let __ptr = G::from_usize(__mq.len()); __mq.insert(&__values[..], &[__ptr], G::from_bool(!unconstrained)); __ptr } }; - let __ret: [G; OUT_783] = [__v_38, __v_39, __v_0, __v_1, __v_40, __v_41]; - if let Some(result) = record.function_queries[783].get_mut(&inp[..]) { debug_assert_eq!(result.output, &__ret[..]); if !unconstrained { *result.multiplicity += G::ONE; } } else { record.function_queries[783].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained)); }; + let __ret: [G; OUT_779] = [__v_38, __v_39, __v_0, __v_1, __v_40, __v_41]; + if let Some(result) = record.function_queries[779].get_mut(&inp[..]) { debug_assert_eq!(result.output, &__ret[..]); if !unconstrained { *result.multiplicity += G::ONE; } } else { record.function_queries[779].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained)); }; return Ok(__ret); }, } @@ -66322,8 +66050,8 @@ fn aiur_fn_783( let __v_27: G = G::from_u64(1); let __v_28: G = { let __values: [G; 6] = [__v_2, __v_3, __v_4, __v_5, __v_6, __v_7]; let __mq = record.memory_queries.get_mut(&6).ok_or(ExecError::InvalidMemorySize(6))?; if let Some(result) = __mq.get_mut(&__values[..]) { if !unconstrained { *result.multiplicity += G::ONE; } result.output[0] } else { let __ptr = G::from_usize(__mq.len()); __mq.insert(&__values[..], &[__ptr], G::from_bool(!unconstrained)); __ptr } }; let __v_29: G = { let __values: [G; 6] = [__v_8, __v_9, __v_10, __v_11, __v_12, __v_13]; let __mq = record.memory_queries.get_mut(&6).ok_or(ExecError::InvalidMemorySize(6))?; if let Some(result) = __mq.get_mut(&__values[..]) { if !unconstrained { *result.multiplicity += G::ONE; } result.output[0] } else { let __ptr = G::from_usize(__mq.len()); __mq.insert(&__values[..], &[__ptr], G::from_bool(!unconstrained)); __ptr } }; - let __ret: [G; OUT_783] = [__v_26, __v_27, __v_0, __v_1, __v_28, __v_29]; - if let Some(result) = record.function_queries[783].get_mut(&inp[..]) { debug_assert_eq!(result.output, &__ret[..]); if !unconstrained { *result.multiplicity += G::ONE; } } else { record.function_queries[783].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained)); }; + let __ret: [G; OUT_779] = [__v_26, __v_27, __v_0, __v_1, __v_28, __v_29]; + if let Some(result) = record.function_queries[779].get_mut(&inp[..]) { debug_assert_eq!(result.output, &__ret[..]); if !unconstrained { *result.multiplicity += G::ONE; } } else { record.function_queries[779].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained)); }; return Ok(__ret); }, } @@ -66333,8 +66061,8 @@ fn aiur_fn_783( let __v_27: G = G::from_u64(1); let __v_28: G = { let __values: [G; 6] = [__v_2, __v_3, __v_4, __v_5, __v_6, __v_7]; let __mq = record.memory_queries.get_mut(&6).ok_or(ExecError::InvalidMemorySize(6))?; if let Some(result) = __mq.get_mut(&__values[..]) { if !unconstrained { *result.multiplicity += G::ONE; } result.output[0] } else { let __ptr = G::from_usize(__mq.len()); __mq.insert(&__values[..], &[__ptr], G::from_bool(!unconstrained)); __ptr } }; let __v_29: G = { let __values: [G; 6] = [__v_8, __v_9, __v_10, __v_11, __v_12, __v_13]; let __mq = record.memory_queries.get_mut(&6).ok_or(ExecError::InvalidMemorySize(6))?; if let Some(result) = __mq.get_mut(&__values[..]) { if !unconstrained { *result.multiplicity += G::ONE; } result.output[0] } else { let __ptr = G::from_usize(__mq.len()); __mq.insert(&__values[..], &[__ptr], G::from_bool(!unconstrained)); __ptr } }; - let __ret: [G; OUT_783] = [__v_26, __v_27, __v_0, __v_1, __v_28, __v_29]; - if let Some(result) = record.function_queries[783].get_mut(&inp[..]) { debug_assert_eq!(result.output, &__ret[..]); if !unconstrained { *result.multiplicity += G::ONE; } } else { record.function_queries[783].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained)); }; + let __ret: [G; OUT_779] = [__v_26, __v_27, __v_0, __v_1, __v_28, __v_29]; + if let Some(result) = record.function_queries[779].get_mut(&inp[..]) { debug_assert_eq!(result.output, &__ret[..]); if !unconstrained { *result.multiplicity += G::ONE; } } else { record.function_queries[779].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained)); }; return Ok(__ret); }, } @@ -66368,8 +66096,8 @@ fn aiur_fn_783( let __v_26: G = G::from_u64(0); let __v_27: G = G::from_u64(1); let __v_28: G = { let __values: [G; 6] = [__v_26, __v_27, __v_10, __v_11, __v_19, __v_13]; let __mq = record.memory_queries.get_mut(&6).ok_or(ExecError::InvalidMemorySize(6))?; if let Some(result) = __mq.get_mut(&__values[..]) { if !unconstrained { *result.multiplicity += G::ONE; } result.output[0] } else { let __ptr = G::from_usize(__mq.len()); __mq.insert(&__values[..], &[__ptr], G::from_bool(!unconstrained)); __ptr } }; - let __ret: [G; OUT_783] = [__v_20, __v_21, __v_16, __v_17, __v_25, __v_28]; - if let Some(result) = record.function_queries[783].get_mut(&inp[..]) { debug_assert_eq!(result.output, &__ret[..]); if !unconstrained { *result.multiplicity += G::ONE; } } else { record.function_queries[783].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained)); }; + let __ret: [G; OUT_779] = [__v_20, __v_21, __v_16, __v_17, __v_25, __v_28]; + if let Some(result) = record.function_queries[779].get_mut(&inp[..]) { debug_assert_eq!(result.output, &__ret[..]); if !unconstrained { *result.multiplicity += G::ONE; } } else { record.function_queries[779].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained)); }; return Ok(__ret); }, _ => { @@ -66393,8 +66121,8 @@ fn aiur_fn_783( let __v_32: G = G::from_u64(0); let __v_33: G = G::from_u64(1); let __v_34: G = { let __values: [G; 6] = [__v_32, __v_33, __v_22, __v_23, __v_24, __v_25]; let __mq = record.memory_queries.get_mut(&6).ok_or(ExecError::InvalidMemorySize(6))?; if let Some(result) = __mq.get_mut(&__values[..]) { if !unconstrained { *result.multiplicity += G::ONE; } result.output[0] } else { let __ptr = G::from_usize(__mq.len()); __mq.insert(&__values[..], &[__ptr], G::from_bool(!unconstrained)); __ptr } }; - let __ret: [G; OUT_783] = [__v_26, __v_27, __v_10, __v_11, __v_31, __v_34]; - if let Some(result) = record.function_queries[783].get_mut(&inp[..]) { debug_assert_eq!(result.output, &__ret[..]); if !unconstrained { *result.multiplicity += G::ONE; } } else { record.function_queries[783].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained)); }; + let __ret: [G; OUT_779] = [__v_26, __v_27, __v_10, __v_11, __v_31, __v_34]; + if let Some(result) = record.function_queries[779].get_mut(&inp[..]) { debug_assert_eq!(result.output, &__ret[..]); if !unconstrained { *result.multiplicity += G::ONE; } } else { record.function_queries[779].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained)); }; return Ok(__ret); }, _ => { @@ -66402,8 +66130,8 @@ fn aiur_fn_783( let __v_27: G = G::from_u64(1); let __v_28: G = { let __values: [G; 6] = [__v_2, __v_3, __v_4, __v_5, __v_6, __v_7]; let __mq = record.memory_queries.get_mut(&6).ok_or(ExecError::InvalidMemorySize(6))?; if let Some(result) = __mq.get_mut(&__values[..]) { if !unconstrained { *result.multiplicity += G::ONE; } result.output[0] } else { let __ptr = G::from_usize(__mq.len()); __mq.insert(&__values[..], &[__ptr], G::from_bool(!unconstrained)); __ptr } }; let __v_29: G = { let __values: [G; 6] = [__v_8, __v_9, __v_10, __v_11, __v_12, __v_13]; let __mq = record.memory_queries.get_mut(&6).ok_or(ExecError::InvalidMemorySize(6))?; if let Some(result) = __mq.get_mut(&__values[..]) { if !unconstrained { *result.multiplicity += G::ONE; } result.output[0] } else { let __ptr = G::from_usize(__mq.len()); __mq.insert(&__values[..], &[__ptr], G::from_bool(!unconstrained)); __ptr } }; - let __ret: [G; OUT_783] = [__v_26, __v_27, __v_0, __v_1, __v_28, __v_29]; - if let Some(result) = record.function_queries[783].get_mut(&inp[..]) { debug_assert_eq!(result.output, &__ret[..]); if !unconstrained { *result.multiplicity += G::ONE; } } else { record.function_queries[783].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained)); }; + let __ret: [G; OUT_779] = [__v_26, __v_27, __v_0, __v_1, __v_28, __v_29]; + if let Some(result) = record.function_queries[779].get_mut(&inp[..]) { debug_assert_eq!(result.output, &__ret[..]); if !unconstrained { *result.multiplicity += G::ONE; } } else { record.function_queries[779].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained)); }; return Ok(__ret); }, } @@ -66413,8 +66141,8 @@ fn aiur_fn_783( let __v_27: G = G::from_u64(1); let __v_28: G = { let __values: [G; 6] = [__v_2, __v_3, __v_4, __v_5, __v_6, __v_7]; let __mq = record.memory_queries.get_mut(&6).ok_or(ExecError::InvalidMemorySize(6))?; if let Some(result) = __mq.get_mut(&__values[..]) { if !unconstrained { *result.multiplicity += G::ONE; } result.output[0] } else { let __ptr = G::from_usize(__mq.len()); __mq.insert(&__values[..], &[__ptr], G::from_bool(!unconstrained)); __ptr } }; let __v_29: G = { let __values: [G; 6] = [__v_8, __v_9, __v_10, __v_11, __v_12, __v_13]; let __mq = record.memory_queries.get_mut(&6).ok_or(ExecError::InvalidMemorySize(6))?; if let Some(result) = __mq.get_mut(&__values[..]) { if !unconstrained { *result.multiplicity += G::ONE; } result.output[0] } else { let __ptr = G::from_usize(__mq.len()); __mq.insert(&__values[..], &[__ptr], G::from_bool(!unconstrained)); __ptr } }; - let __ret: [G; OUT_783] = [__v_26, __v_27, __v_0, __v_1, __v_28, __v_29]; - if let Some(result) = record.function_queries[783].get_mut(&inp[..]) { debug_assert_eq!(result.output, &__ret[..]); if !unconstrained { *result.multiplicity += G::ONE; } } else { record.function_queries[783].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained)); }; + let __ret: [G; OUT_779] = [__v_26, __v_27, __v_0, __v_1, __v_28, __v_29]; + if let Some(result) = record.function_queries[779].get_mut(&inp[..]) { debug_assert_eq!(result.output, &__ret[..]); if !unconstrained { *result.multiplicity += G::ONE; } } else { record.function_queries[779].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained)); }; return Ok(__ret); }, } @@ -66442,8 +66170,8 @@ fn aiur_fn_783( let __v_32: G = G::from_u64(0); let __v_33: G = G::from_u64(1); let __v_34: G = { let __values: [G; 6] = [__v_32, __v_33, __v_22, __v_23, __v_24, __v_25]; let __mq = record.memory_queries.get_mut(&6).ok_or(ExecError::InvalidMemorySize(6))?; if let Some(result) = __mq.get_mut(&__values[..]) { if !unconstrained { *result.multiplicity += G::ONE; } result.output[0] } else { let __ptr = G::from_usize(__mq.len()); __mq.insert(&__values[..], &[__ptr], G::from_bool(!unconstrained)); __ptr } }; - let __ret: [G; OUT_783] = [__v_26, __v_27, __v_10, __v_11, __v_31, __v_34]; - if let Some(result) = record.function_queries[783].get_mut(&inp[..]) { debug_assert_eq!(result.output, &__ret[..]); if !unconstrained { *result.multiplicity += G::ONE; } } else { record.function_queries[783].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained)); }; + let __ret: [G; OUT_779] = [__v_26, __v_27, __v_10, __v_11, __v_31, __v_34]; + if let Some(result) = record.function_queries[779].get_mut(&inp[..]) { debug_assert_eq!(result.output, &__ret[..]); if !unconstrained { *result.multiplicity += G::ONE; } } else { record.function_queries[779].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained)); }; return Ok(__ret); }, _ => { @@ -66451,8 +66179,8 @@ fn aiur_fn_783( let __v_27: G = G::from_u64(1); let __v_28: G = { let __values: [G; 6] = [__v_2, __v_3, __v_4, __v_5, __v_6, __v_7]; let __mq = record.memory_queries.get_mut(&6).ok_or(ExecError::InvalidMemorySize(6))?; if let Some(result) = __mq.get_mut(&__values[..]) { if !unconstrained { *result.multiplicity += G::ONE; } result.output[0] } else { let __ptr = G::from_usize(__mq.len()); __mq.insert(&__values[..], &[__ptr], G::from_bool(!unconstrained)); __ptr } }; let __v_29: G = { let __values: [G; 6] = [__v_8, __v_9, __v_10, __v_11, __v_12, __v_13]; let __mq = record.memory_queries.get_mut(&6).ok_or(ExecError::InvalidMemorySize(6))?; if let Some(result) = __mq.get_mut(&__values[..]) { if !unconstrained { *result.multiplicity += G::ONE; } result.output[0] } else { let __ptr = G::from_usize(__mq.len()); __mq.insert(&__values[..], &[__ptr], G::from_bool(!unconstrained)); __ptr } }; - let __ret: [G; OUT_783] = [__v_26, __v_27, __v_0, __v_1, __v_28, __v_29]; - if let Some(result) = record.function_queries[783].get_mut(&inp[..]) { debug_assert_eq!(result.output, &__ret[..]); if !unconstrained { *result.multiplicity += G::ONE; } } else { record.function_queries[783].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained)); }; + let __ret: [G; OUT_779] = [__v_26, __v_27, __v_0, __v_1, __v_28, __v_29]; + if let Some(result) = record.function_queries[779].get_mut(&inp[..]) { debug_assert_eq!(result.output, &__ret[..]); if !unconstrained { *result.multiplicity += G::ONE; } } else { record.function_queries[779].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained)); }; return Ok(__ret); }, } @@ -66462,8 +66190,8 @@ fn aiur_fn_783( let __v_27: G = G::from_u64(1); let __v_28: G = { let __values: [G; 6] = [__v_2, __v_3, __v_4, __v_5, __v_6, __v_7]; let __mq = record.memory_queries.get_mut(&6).ok_or(ExecError::InvalidMemorySize(6))?; if let Some(result) = __mq.get_mut(&__values[..]) { if !unconstrained { *result.multiplicity += G::ONE; } result.output[0] } else { let __ptr = G::from_usize(__mq.len()); __mq.insert(&__values[..], &[__ptr], G::from_bool(!unconstrained)); __ptr } }; let __v_29: G = { let __values: [G; 6] = [__v_8, __v_9, __v_10, __v_11, __v_12, __v_13]; let __mq = record.memory_queries.get_mut(&6).ok_or(ExecError::InvalidMemorySize(6))?; if let Some(result) = __mq.get_mut(&__values[..]) { if !unconstrained { *result.multiplicity += G::ONE; } result.output[0] } else { let __ptr = G::from_usize(__mq.len()); __mq.insert(&__values[..], &[__ptr], G::from_bool(!unconstrained)); __ptr } }; - let __ret: [G; OUT_783] = [__v_26, __v_27, __v_0, __v_1, __v_28, __v_29]; - if let Some(result) = record.function_queries[783].get_mut(&inp[..]) { debug_assert_eq!(result.output, &__ret[..]); if !unconstrained { *result.multiplicity += G::ONE; } } else { record.function_queries[783].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained)); }; + let __ret: [G; OUT_779] = [__v_26, __v_27, __v_0, __v_1, __v_28, __v_29]; + if let Some(result) = record.function_queries[779].get_mut(&inp[..]) { debug_assert_eq!(result.output, &__ret[..]); if !unconstrained { *result.multiplicity += G::ONE; } } else { record.function_queries[779].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained)); }; return Ok(__ret); }, } @@ -66475,8 +66203,8 @@ fn aiur_fn_783( let __v_15: G = G::from_u64(1); let __v_16: G = { let __values: [G; 6] = [__v_2, __v_3, __v_4, __v_5, __v_6, __v_7]; let __mq = record.memory_queries.get_mut(&6).ok_or(ExecError::InvalidMemorySize(6))?; if let Some(result) = __mq.get_mut(&__values[..]) { if !unconstrained { *result.multiplicity += G::ONE; } result.output[0] } else { let __ptr = G::from_usize(__mq.len()); __mq.insert(&__values[..], &[__ptr], G::from_bool(!unconstrained)); __ptr } }; let __v_17: G = { let __values: [G; 6] = [__v_8, __v_9, __v_10, __v_11, __v_12, __v_13]; let __mq = record.memory_queries.get_mut(&6).ok_or(ExecError::InvalidMemorySize(6))?; if let Some(result) = __mq.get_mut(&__values[..]) { if !unconstrained { *result.multiplicity += G::ONE; } result.output[0] } else { let __ptr = G::from_usize(__mq.len()); __mq.insert(&__values[..], &[__ptr], G::from_bool(!unconstrained)); __ptr } }; - let __ret: [G; OUT_783] = [__v_14, __v_15, __v_0, __v_1, __v_16, __v_17]; - if let Some(result) = record.function_queries[783].get_mut(&inp[..]) { debug_assert_eq!(result.output, &__ret[..]); if !unconstrained { *result.multiplicity += G::ONE; } } else { record.function_queries[783].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained)); }; + let __ret: [G; OUT_779] = [__v_14, __v_15, __v_0, __v_1, __v_16, __v_17]; + if let Some(result) = record.function_queries[779].get_mut(&inp[..]) { debug_assert_eq!(result.output, &__ret[..]); if !unconstrained { *result.multiplicity += G::ONE; } } else { record.function_queries[779].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained)); }; return Ok(__ret); }, } @@ -66486,8 +66214,8 @@ fn aiur_fn_783( let __v_15: G = G::from_u64(1); let __v_16: G = { let __values: [G; 6] = [__v_2, __v_3, __v_4, __v_5, __v_6, __v_7]; let __mq = record.memory_queries.get_mut(&6).ok_or(ExecError::InvalidMemorySize(6))?; if let Some(result) = __mq.get_mut(&__values[..]) { if !unconstrained { *result.multiplicity += G::ONE; } result.output[0] } else { let __ptr = G::from_usize(__mq.len()); __mq.insert(&__values[..], &[__ptr], G::from_bool(!unconstrained)); __ptr } }; let __v_17: G = { let __values: [G; 6] = [__v_8, __v_9, __v_10, __v_11, __v_12, __v_13]; let __mq = record.memory_queries.get_mut(&6).ok_or(ExecError::InvalidMemorySize(6))?; if let Some(result) = __mq.get_mut(&__values[..]) { if !unconstrained { *result.multiplicity += G::ONE; } result.output[0] } else { let __ptr = G::from_usize(__mq.len()); __mq.insert(&__values[..], &[__ptr], G::from_bool(!unconstrained)); __ptr } }; - let __ret: [G; OUT_783] = [__v_14, __v_15, __v_0, __v_1, __v_16, __v_17]; - if let Some(result) = record.function_queries[783].get_mut(&inp[..]) { debug_assert_eq!(result.output, &__ret[..]); if !unconstrained { *result.multiplicity += G::ONE; } } else { record.function_queries[783].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained)); }; + let __ret: [G; OUT_779] = [__v_14, __v_15, __v_0, __v_1, __v_16, __v_17]; + if let Some(result) = record.function_queries[779].get_mut(&inp[..]) { debug_assert_eq!(result.output, &__ret[..]); if !unconstrained { *result.multiplicity += G::ONE; } } else { record.function_queries[779].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained)); }; return Ok(__ret); }, } @@ -66519,8 +66247,8 @@ fn aiur_fn_783( let __v_26: G = G::from_u64(0); let __v_27: G = G::from_u64(1); let __v_28: G = { let __values: [G; 6] = [__v_26, __v_27, __v_10, __v_11, __v_19, __v_13]; let __mq = record.memory_queries.get_mut(&6).ok_or(ExecError::InvalidMemorySize(6))?; if let Some(result) = __mq.get_mut(&__values[..]) { if !unconstrained { *result.multiplicity += G::ONE; } result.output[0] } else { let __ptr = G::from_usize(__mq.len()); __mq.insert(&__values[..], &[__ptr], G::from_bool(!unconstrained)); __ptr } }; - let __ret: [G; OUT_783] = [__v_20, __v_21, __v_16, __v_17, __v_25, __v_28]; - if let Some(result) = record.function_queries[783].get_mut(&inp[..]) { debug_assert_eq!(result.output, &__ret[..]); if !unconstrained { *result.multiplicity += G::ONE; } } else { record.function_queries[783].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained)); }; + let __ret: [G; OUT_779] = [__v_20, __v_21, __v_16, __v_17, __v_25, __v_28]; + if let Some(result) = record.function_queries[779].get_mut(&inp[..]) { debug_assert_eq!(result.output, &__ret[..]); if !unconstrained { *result.multiplicity += G::ONE; } } else { record.function_queries[779].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained)); }; return Ok(__ret); }, _ => { @@ -66544,8 +66272,8 @@ fn aiur_fn_783( let __v_32: G = G::from_u64(0); let __v_33: G = G::from_u64(1); let __v_34: G = { let __values: [G; 6] = [__v_32, __v_33, __v_22, __v_23, __v_24, __v_25]; let __mq = record.memory_queries.get_mut(&6).ok_or(ExecError::InvalidMemorySize(6))?; if let Some(result) = __mq.get_mut(&__values[..]) { if !unconstrained { *result.multiplicity += G::ONE; } result.output[0] } else { let __ptr = G::from_usize(__mq.len()); __mq.insert(&__values[..], &[__ptr], G::from_bool(!unconstrained)); __ptr } }; - let __ret: [G; OUT_783] = [__v_26, __v_27, __v_10, __v_11, __v_31, __v_34]; - if let Some(result) = record.function_queries[783].get_mut(&inp[..]) { debug_assert_eq!(result.output, &__ret[..]); if !unconstrained { *result.multiplicity += G::ONE; } } else { record.function_queries[783].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained)); }; + let __ret: [G; OUT_779] = [__v_26, __v_27, __v_10, __v_11, __v_31, __v_34]; + if let Some(result) = record.function_queries[779].get_mut(&inp[..]) { debug_assert_eq!(result.output, &__ret[..]); if !unconstrained { *result.multiplicity += G::ONE; } } else { record.function_queries[779].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained)); }; return Ok(__ret); }, _ => { @@ -66553,8 +66281,8 @@ fn aiur_fn_783( let __v_27: G = G::from_u64(1); let __v_28: G = { let __values: [G; 6] = [__v_2, __v_3, __v_4, __v_5, __v_6, __v_7]; let __mq = record.memory_queries.get_mut(&6).ok_or(ExecError::InvalidMemorySize(6))?; if let Some(result) = __mq.get_mut(&__values[..]) { if !unconstrained { *result.multiplicity += G::ONE; } result.output[0] } else { let __ptr = G::from_usize(__mq.len()); __mq.insert(&__values[..], &[__ptr], G::from_bool(!unconstrained)); __ptr } }; let __v_29: G = { let __values: [G; 6] = [__v_8, __v_9, __v_10, __v_11, __v_12, __v_13]; let __mq = record.memory_queries.get_mut(&6).ok_or(ExecError::InvalidMemorySize(6))?; if let Some(result) = __mq.get_mut(&__values[..]) { if !unconstrained { *result.multiplicity += G::ONE; } result.output[0] } else { let __ptr = G::from_usize(__mq.len()); __mq.insert(&__values[..], &[__ptr], G::from_bool(!unconstrained)); __ptr } }; - let __ret: [G; OUT_783] = [__v_26, __v_27, __v_0, __v_1, __v_28, __v_29]; - if let Some(result) = record.function_queries[783].get_mut(&inp[..]) { debug_assert_eq!(result.output, &__ret[..]); if !unconstrained { *result.multiplicity += G::ONE; } } else { record.function_queries[783].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained)); }; + let __ret: [G; OUT_779] = [__v_26, __v_27, __v_0, __v_1, __v_28, __v_29]; + if let Some(result) = record.function_queries[779].get_mut(&inp[..]) { debug_assert_eq!(result.output, &__ret[..]); if !unconstrained { *result.multiplicity += G::ONE; } } else { record.function_queries[779].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained)); }; return Ok(__ret); }, } @@ -66564,8 +66292,8 @@ fn aiur_fn_783( let __v_27: G = G::from_u64(1); let __v_28: G = { let __values: [G; 6] = [__v_2, __v_3, __v_4, __v_5, __v_6, __v_7]; let __mq = record.memory_queries.get_mut(&6).ok_or(ExecError::InvalidMemorySize(6))?; if let Some(result) = __mq.get_mut(&__values[..]) { if !unconstrained { *result.multiplicity += G::ONE; } result.output[0] } else { let __ptr = G::from_usize(__mq.len()); __mq.insert(&__values[..], &[__ptr], G::from_bool(!unconstrained)); __ptr } }; let __v_29: G = { let __values: [G; 6] = [__v_8, __v_9, __v_10, __v_11, __v_12, __v_13]; let __mq = record.memory_queries.get_mut(&6).ok_or(ExecError::InvalidMemorySize(6))?; if let Some(result) = __mq.get_mut(&__values[..]) { if !unconstrained { *result.multiplicity += G::ONE; } result.output[0] } else { let __ptr = G::from_usize(__mq.len()); __mq.insert(&__values[..], &[__ptr], G::from_bool(!unconstrained)); __ptr } }; - let __ret: [G; OUT_783] = [__v_26, __v_27, __v_0, __v_1, __v_28, __v_29]; - if let Some(result) = record.function_queries[783].get_mut(&inp[..]) { debug_assert_eq!(result.output, &__ret[..]); if !unconstrained { *result.multiplicity += G::ONE; } } else { record.function_queries[783].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained)); }; + let __ret: [G; OUT_779] = [__v_26, __v_27, __v_0, __v_1, __v_28, __v_29]; + if let Some(result) = record.function_queries[779].get_mut(&inp[..]) { debug_assert_eq!(result.output, &__ret[..]); if !unconstrained { *result.multiplicity += G::ONE; } } else { record.function_queries[779].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained)); }; return Ok(__ret); }, } @@ -66593,8 +66321,8 @@ fn aiur_fn_783( let __v_32: G = G::from_u64(0); let __v_33: G = G::from_u64(1); let __v_34: G = { let __values: [G; 6] = [__v_32, __v_33, __v_22, __v_23, __v_24, __v_25]; let __mq = record.memory_queries.get_mut(&6).ok_or(ExecError::InvalidMemorySize(6))?; if let Some(result) = __mq.get_mut(&__values[..]) { if !unconstrained { *result.multiplicity += G::ONE; } result.output[0] } else { let __ptr = G::from_usize(__mq.len()); __mq.insert(&__values[..], &[__ptr], G::from_bool(!unconstrained)); __ptr } }; - let __ret: [G; OUT_783] = [__v_26, __v_27, __v_10, __v_11, __v_31, __v_34]; - if let Some(result) = record.function_queries[783].get_mut(&inp[..]) { debug_assert_eq!(result.output, &__ret[..]); if !unconstrained { *result.multiplicity += G::ONE; } } else { record.function_queries[783].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained)); }; + let __ret: [G; OUT_779] = [__v_26, __v_27, __v_10, __v_11, __v_31, __v_34]; + if let Some(result) = record.function_queries[779].get_mut(&inp[..]) { debug_assert_eq!(result.output, &__ret[..]); if !unconstrained { *result.multiplicity += G::ONE; } } else { record.function_queries[779].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained)); }; return Ok(__ret); }, _ => { @@ -66602,8 +66330,8 @@ fn aiur_fn_783( let __v_27: G = G::from_u64(1); let __v_28: G = { let __values: [G; 6] = [__v_2, __v_3, __v_4, __v_5, __v_6, __v_7]; let __mq = record.memory_queries.get_mut(&6).ok_or(ExecError::InvalidMemorySize(6))?; if let Some(result) = __mq.get_mut(&__values[..]) { if !unconstrained { *result.multiplicity += G::ONE; } result.output[0] } else { let __ptr = G::from_usize(__mq.len()); __mq.insert(&__values[..], &[__ptr], G::from_bool(!unconstrained)); __ptr } }; let __v_29: G = { let __values: [G; 6] = [__v_8, __v_9, __v_10, __v_11, __v_12, __v_13]; let __mq = record.memory_queries.get_mut(&6).ok_or(ExecError::InvalidMemorySize(6))?; if let Some(result) = __mq.get_mut(&__values[..]) { if !unconstrained { *result.multiplicity += G::ONE; } result.output[0] } else { let __ptr = G::from_usize(__mq.len()); __mq.insert(&__values[..], &[__ptr], G::from_bool(!unconstrained)); __ptr } }; - let __ret: [G; OUT_783] = [__v_26, __v_27, __v_0, __v_1, __v_28, __v_29]; - if let Some(result) = record.function_queries[783].get_mut(&inp[..]) { debug_assert_eq!(result.output, &__ret[..]); if !unconstrained { *result.multiplicity += G::ONE; } } else { record.function_queries[783].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained)); }; + let __ret: [G; OUT_779] = [__v_26, __v_27, __v_0, __v_1, __v_28, __v_29]; + if let Some(result) = record.function_queries[779].get_mut(&inp[..]) { debug_assert_eq!(result.output, &__ret[..]); if !unconstrained { *result.multiplicity += G::ONE; } } else { record.function_queries[779].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained)); }; return Ok(__ret); }, } @@ -66613,8 +66341,8 @@ fn aiur_fn_783( let __v_27: G = G::from_u64(1); let __v_28: G = { let __values: [G; 6] = [__v_2, __v_3, __v_4, __v_5, __v_6, __v_7]; let __mq = record.memory_queries.get_mut(&6).ok_or(ExecError::InvalidMemorySize(6))?; if let Some(result) = __mq.get_mut(&__values[..]) { if !unconstrained { *result.multiplicity += G::ONE; } result.output[0] } else { let __ptr = G::from_usize(__mq.len()); __mq.insert(&__values[..], &[__ptr], G::from_bool(!unconstrained)); __ptr } }; let __v_29: G = { let __values: [G; 6] = [__v_8, __v_9, __v_10, __v_11, __v_12, __v_13]; let __mq = record.memory_queries.get_mut(&6).ok_or(ExecError::InvalidMemorySize(6))?; if let Some(result) = __mq.get_mut(&__values[..]) { if !unconstrained { *result.multiplicity += G::ONE; } result.output[0] } else { let __ptr = G::from_usize(__mq.len()); __mq.insert(&__values[..], &[__ptr], G::from_bool(!unconstrained)); __ptr } }; - let __ret: [G; OUT_783] = [__v_26, __v_27, __v_0, __v_1, __v_28, __v_29]; - if let Some(result) = record.function_queries[783].get_mut(&inp[..]) { debug_assert_eq!(result.output, &__ret[..]); if !unconstrained { *result.multiplicity += G::ONE; } } else { record.function_queries[783].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained)); }; + let __ret: [G; OUT_779] = [__v_26, __v_27, __v_0, __v_1, __v_28, __v_29]; + if let Some(result) = record.function_queries[779].get_mut(&inp[..]) { debug_assert_eq!(result.output, &__ret[..]); if !unconstrained { *result.multiplicity += G::ONE; } } else { record.function_queries[779].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained)); }; return Ok(__ret); }, } @@ -66626,8 +66354,8 @@ fn aiur_fn_783( let __v_15: G = G::from_u64(1); let __v_16: G = { let __values: [G; 6] = [__v_2, __v_3, __v_4, __v_5, __v_6, __v_7]; let __mq = record.memory_queries.get_mut(&6).ok_or(ExecError::InvalidMemorySize(6))?; if let Some(result) = __mq.get_mut(&__values[..]) { if !unconstrained { *result.multiplicity += G::ONE; } result.output[0] } else { let __ptr = G::from_usize(__mq.len()); __mq.insert(&__values[..], &[__ptr], G::from_bool(!unconstrained)); __ptr } }; let __v_17: G = { let __values: [G; 6] = [__v_8, __v_9, __v_10, __v_11, __v_12, __v_13]; let __mq = record.memory_queries.get_mut(&6).ok_or(ExecError::InvalidMemorySize(6))?; if let Some(result) = __mq.get_mut(&__values[..]) { if !unconstrained { *result.multiplicity += G::ONE; } result.output[0] } else { let __ptr = G::from_usize(__mq.len()); __mq.insert(&__values[..], &[__ptr], G::from_bool(!unconstrained)); __ptr } }; - let __ret: [G; OUT_783] = [__v_14, __v_15, __v_0, __v_1, __v_16, __v_17]; - if let Some(result) = record.function_queries[783].get_mut(&inp[..]) { debug_assert_eq!(result.output, &__ret[..]); if !unconstrained { *result.multiplicity += G::ONE; } } else { record.function_queries[783].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained)); }; + let __ret: [G; OUT_779] = [__v_14, __v_15, __v_0, __v_1, __v_16, __v_17]; + if let Some(result) = record.function_queries[779].get_mut(&inp[..]) { debug_assert_eq!(result.output, &__ret[..]); if !unconstrained { *result.multiplicity += G::ONE; } } else { record.function_queries[779].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained)); }; return Ok(__ret); }, } @@ -66637,8 +66365,8 @@ fn aiur_fn_783( let __v_15: G = G::from_u64(1); let __v_16: G = { let __values: [G; 6] = [__v_2, __v_3, __v_4, __v_5, __v_6, __v_7]; let __mq = record.memory_queries.get_mut(&6).ok_or(ExecError::InvalidMemorySize(6))?; if let Some(result) = __mq.get_mut(&__values[..]) { if !unconstrained { *result.multiplicity += G::ONE; } result.output[0] } else { let __ptr = G::from_usize(__mq.len()); __mq.insert(&__values[..], &[__ptr], G::from_bool(!unconstrained)); __ptr } }; let __v_17: G = { let __values: [G; 6] = [__v_8, __v_9, __v_10, __v_11, __v_12, __v_13]; let __mq = record.memory_queries.get_mut(&6).ok_or(ExecError::InvalidMemorySize(6))?; if let Some(result) = __mq.get_mut(&__values[..]) { if !unconstrained { *result.multiplicity += G::ONE; } result.output[0] } else { let __ptr = G::from_usize(__mq.len()); __mq.insert(&__values[..], &[__ptr], G::from_bool(!unconstrained)); __ptr } }; - let __ret: [G; OUT_783] = [__v_14, __v_15, __v_0, __v_1, __v_16, __v_17]; - if let Some(result) = record.function_queries[783].get_mut(&inp[..]) { debug_assert_eq!(result.output, &__ret[..]); if !unconstrained { *result.multiplicity += G::ONE; } } else { record.function_queries[783].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained)); }; + let __ret: [G; OUT_779] = [__v_14, __v_15, __v_0, __v_1, __v_16, __v_17]; + if let Some(result) = record.function_queries[779].get_mut(&inp[..]) { debug_assert_eq!(result.output, &__ret[..]); if !unconstrained { *result.multiplicity += G::ONE; } } else { record.function_queries[779].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained)); }; return Ok(__ret); }, } @@ -70554,26 +70282,6 @@ pub(crate) fn execute_generated( let __out = aiur_fn_779(__inp, record, io_buffer, false)?; return Ok(__out.to_vec()); }, - 780u64 => { - let __inp: [G; IN_780] = args.try_into().expect("input size mismatch"); - let __out = aiur_fn_780(__inp, record, io_buffer, false)?; - return Ok(__out.to_vec()); - }, - 781u64 => { - let __inp: [G; IN_781] = args.try_into().expect("input size mismatch"); - let __out = aiur_fn_781(__inp, record, io_buffer, false)?; - return Ok(__out.to_vec()); - }, - 782u64 => { - let __inp: [G; IN_782] = args.try_into().expect("input size mismatch"); - let __out = aiur_fn_782(__inp, record, io_buffer, false)?; - return Ok(__out.to_vec()); - }, - 783u64 => { - let __inp: [G; IN_783] = args.try_into().expect("input size mismatch"); - let __out = aiur_fn_783(__inp, record, io_buffer, false)?; - return Ok(__out.to_vec()); - }, _ => { return Err(ExecError::InvalidFunIdx(fun_idx)); },